INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 1 Bewertungen - 1 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
I2C Master ohne ACK
09.07.2019, 17:07
Beitrag #1
I2C Master ohne ACK
Hallo Gemeinde,

zur Kommunikation mit einem Volumen Chip (NJU72343) benötige ich ein I2C welches ohne die ACK bits aus kommt.

Gefunden habe ich zwei geeignete Library's:
SoftIIC und cI2C

Da ich recht ungeübt bin, kann ich die o.g. Library's nicht umsetzen.

Kann mir bitte jemand auf die Sprünge helfen?
vielen Dank
Andre
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.07.2019, 17:22
Beitrag #2
RE: I2C Master ohne ACK
Ich habe die ICs und die Libraries bisher noch nicht eingesetzt, würde mich aber immer an den Beispielen der Library orientieren. Da ist es doch genausten vorgemacht.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.07.2019, 19:24 (Dieser Beitrag wurde zuletzt bearbeitet: 09.07.2019 19:40 von dremeier.)
Beitrag #3
RE: I2C Master ohne ACK
(09.07.2019 17:22)hotsystems schrieb:  Ich habe die ICs und die Libraries bisher noch nicht eingesetzt, würde mich aber immer an den Beispielen der Library orientieren. Da ist es doch genausten vorgemacht.

Es ist ja nicht so als hätte ich mir keine Mühe gegeben. Das Thema Arduino und Besonders I2C ist neu für mich. Seit 5 Tagen recherchiere ich nun.
Mein Problem ist die *.h, also die Classen zu verstehen um dann im Sketch diese anzuwenden.
Wenn sich jemand damit auskennt, wäre es hilfreich wenn mir jemand sagen kann wie ich das ACK bit abschalte. In den Beispielen ist da nichts von erwähnt.
Ich denke du wirst dir die Beistiele nicht angesehen haben oder ich habe Tomaten auf den Augen.

hier die Header Datei:

Code:
/*
* SoftIIC, a library for IIC communications on any pins.
* Copyright (C) 2015 cirthix@gmail.com
*
*
* This file is part of SoftIIC.
*
* This software is free software: you can redistribute it and/or modify it under the terms of the
* GNU General Public License as published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.  In addition to or superseding this license, this
* software may not be used in any form which is not completely free without the author's written
* consent.
*
* This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* See the GNU General Public License for more details. You should have received a copy of the GNU
* General Public License along with This software. If not, see <http://www.gnu.org/licenses/>.
*
* Authors: cirthix@gmail.com
*/

// This library takes some tricks from https://github.com/todbot/SoftI2CMaster



#ifndef SOFTIIC_h
#define SOFTIIC_h

#include <Arduino.h>
#include <inttypes.h>
#include <avr/wdt.h>

// You can define this to gain a tiny bit of speed+space (may matter at 100KHz)
//#define SOFTIIC_OPTIMIZE_NOPULLUPS

// This is necessary for 100KHz host operation at less than 16MHz core clock
//#define SOFTIIC_OPTIMIZE_FAST

#ifdef SOFTIIC_OPTIMIZE_FAST
    #pragma GCC optimize("O3")
#endif


#define FORCE_INLINE __attribute__((always_inline)) inline


// Define this if using the extra debug pins for timing debug/analysis
// Note that during debugging, timer2 is used, digitalwrite2 library is pulled in, and the pins SOFTIIC_DEBUGPIN_A and SOFTIIC_DEBUGPIN_B are used.
//#define SOFTIIC_DEGBUG_MODE
  

// You can externally override the debug pins when using debug mode.
#ifdef SOFTIIC_DEGBUG_MODE
    #ifndef SOFTIIC_DEBUGPIN_A
        #define SOFTIIC_DEBUGPIN_A 14        // This debug-output pin is used to verify timing relationships between the code and physical sda/scl pins.
    #endif
    #ifndef SOFTIIC_DEBUGPIN_B
        #define SOFTIIC_DEBUGPIN_B 15        // This debug-output pin is used to verify timing relationships between the code and physical sda/scl pins.
    #endif
#endif

#ifdef SOFTIIC_DEBUGPIN_A
    #include "arduino2.h"  // include the fast I/O 2 functions
#endif

#ifdef SOFTIIC_DEBUGPIN_B
    #include "arduino2.h"  // include the fast I/O 2 functions
#endif


#ifndef NOP
    #define NOP __asm__ __volatile__ ("nop\n\t") // delay with a single clock of no-operate instruction
#endif


#define IIC_SPEED_DEFAULT 100 // Units = KHz
#define CHIP_SIZE 256  // For now, only support 8bit IIC communications.  10bit addresses do exist, but this is not yet supported

const uint8_t TIMEOUT_CLOCKS_BYTE_SLACK = 1;
const uint8_t TIMEOUT_CLOCKS_BYTE = 8+1+TIMEOUT_CLOCKS_BYTE_SLACK;
const uint8_t TIMEOUT_CLOCKS_TRANSACTION = 64;  // NOTE: *255
const uint8_t TIMEOUT_CLOCKS_SENDACK = 4;


//            PLEASE NOTE THAT THIS LIBRARY USES 7 BIT ADDRESSES FOR ALL 'SMART' FUNCTIONS AND 8 BIT ADDRESES FOR LOWER LEVEL FUNCTIONS.
class SoftIIC
{
  public:  
      
                        // Constructor
      // note: speed is in KHz, ~10-100 is reasonable.                                            
    SoftIIC(uint8_t pin_scl, uint8_t pin_sda, uint16_t speed, bool pullups, bool multimastersupport, bool timeout);
    ~SoftIIC();
    
                        // Higher level master functions
    //MasterDumpAll scans the entire iic address space for devices which ACK an address, reading and printing all registers that were read from each device.
    // Returns: number of detected devices (0-127)
    uint8_t MasterDumpAll();
    
    //MasterDumpRegisters scans an iic address reading and printing all registers that were read from the device.
    // Returns: number of successfully read registers
    uint8_t MasterDumpRegisters(uint8_t addressRW);
    
    // MasterReadByte attempts to read a single byte from the target chip and register and places it in the 'value' pointer location.  
    // Arguments: device_address is the 7-bit iic address, register_address is the register within the chip, and value is a pointer to a uint8_t for the read data.
    // Returns: RETVAL_SUCCESS, RETVAL_PROTOCOL_FAILURE, or RETVAL_TIMEOUT    
    uint8_t MasterReadByte(uint8_t device_address, uint8_t register_address, uint8_t* value);    
    
    // MasterReadByte  attempts to read a single byte from the target chip and register and returns it.  
    // Arguments: device_address is the 7-bit iic address, register_address is the register within the chip.
    // Returns: the byte read.  if no byte was read, returns 0xff.
    uint8_t MasterReadByte(uint8_t device_address, uint8_t register_address);
        
    // MasterWriteByte attempts to write a single byte to the target chip and register.
    // Returns: RETVAL_SUCCESS, RETVAL_PROTOCOL_FAILURE, or RETVAL_TIMEOUT        
    uint8_t MasterWriteByte(uint8_t device_address, uint8_t register_address, uint8_t value);
    
    // MasterWriteByte attempts to write a single byte to the target chip and register.  After a delay, the register is read and verified.
    // Returns: RETVAL_SUCCESS, RETVAL_PROTOCOL_FAILURE, or RETVAL_TIMEOUT        
    uint8_t MasterWriteByte(uint8_t device_address, uint8_t register_address, uint8_t value, uint8_t writeverify);
    
    // MasterCheckExists inserts an empty transaction to the targeted device and listens for an ACK.
    // Returns: RETVAL_SUCCESS if a device responded to the transaction with an ACK, RETVAL_PROTOCOL_FAILURE or RETVAL_TIMEOUT otherwise
    uint8_t MasterCheckExists(uint8_t device_address);
    
    // Master functions for doing multibyte transfers.  These should be significantly faster for doing things like programming an eeprom.
    uint16_t MasterReadPage (uint8_t device_address, uint8_t register_address, uint16_t number_bytes, uint8_t* bytes);
    uint16_t MasterReadPage (uint8_t device_address, uint8_t register_address, uint16_t number_bytes, uint8_t isverify, uint8_t* bytes);
    uint16_t MasterWritePage(uint8_t device_address, uint8_t register_address, uint16_t number_bytes, uint8_t* bytes);
    uint16_t MasterWritePage(uint8_t device_address, uint8_t register_address, uint16_t number_bytes, uint8_t writeverify, uint8_t* bytes);
    
                        // Lower level master functions do all of the legwork of handling the iic master protocol.  
    uint8_t MasterBusRestart();
    uint8_t MasterStart();
    uint8_t MasterStart(uint8_t device_address);
    uint8_t MasterRestart(uint8_t device_address);
    void     MasterStop();
    uint8_t MasterWrite(uint8_t value);
    uint8_t MasterRead(bool last);
    uint8_t wait_until_bus_is_idle();
    
    
// Watches the I2c bus and prints transactions.  Never returns.  Useful for observing systems and testing the library.
    // Returns: number of bytes snooped.
    uint16_t Snoop(uint16_t to_snoop);
    
// Toggles the debug pin in response to incoming events (0, 1, start, stop)    
    void         test_input_response_time();
    
    
// Toggles the debug pins a few times.  Useful as a sanity-check or to ensure probing the right pin.
    void         debug_pin_test();
    void             PrintSpeed();  
    
// Service one slave request.  Call this function by providing function pointers to functions which will provide the data necessary to handle the transaction.  See example code.
// Returns: number of bytes successfully handled.
    uint16_t SlaveHandleTransaction(
                uint8_t (*fp_respond_to_address)(uint8_t chip_address),
                uint8_t (*fp_respond_to_command)(uint8_t chip_address),
                uint8_t (*fp_respond_to_data)(uint8_t chip_address),
                uint8_t (*fp_get_register_address)(uint8_t chip_address),
                uint8_t (*fp_set_register_address)(uint8_t chip_address, uint8_t reg_address ),
                uint8_t (*fp_generate_byte)(uint8_t chip_address, uint8_t* byte),
                uint8_t (*fp_receive_byte)(uint8_t chip_address, uint8_t byte)
    );

                                    uint8_t             are_timeouts_enabled();
                                    uint8_t            GetStateSoftIIC();
    
    
  private:              
      
            // Pin interactions and precomputed bitmasks
        const uint8_t usePullups            ;
        const uint8_t MULTIMASTERSUPPORT    ;
        const uint8_t TimeoutsEnabled        ;
          const uint8_t PIN_SCL                ;
        const uint8_t PIN_SDA                ;
        const uint8_t _sclBitMask            ;
        const uint8_t _sclBitMaskINVERTED    ;
        const uint8_t _sdaBitMask            ;
        const uint8_t _sdaBitMaskINVERTED    ;
        const uint8_t _busBitMask            ;
        const volatile uint8_t* _sclPortRegIN            ;
        const volatile uint8_t* _sdaPortRegIN         ;
        volatile uint8_t* _sclPortReg              ;
        volatile uint8_t* _sclDirReg               ;
        volatile uint8_t* _sdaPortReg              ;
        volatile uint8_t* _sdaDirReg            ;    
      
            // IIC timing related functions/variables
        const    uint16_t         IIC_CLOCK_SPEED;                // Units are ticks of TCNT1
            uint16_t         HalfclockTimeout;                // Units are ticks of TCNT1
            uint16_t         TransferTimeout;                // Units are ticks of TCNT1
            uint16_t         ByteTimeout;                    // Units are ticks of TCNT1
            uint16_t         ByteAckTimeout;                    // Units are ticks of TCNT1
      
      
      
            // Initialization functions
                    void             SetSpeed(uint16_t speed);  
FORCE_INLINE        void             spin_until_half_clock_period();

            // IIC slave mode timing related functions/variables
FORCE_INLINE        uint8_t         spin_until_start();
FORCE_INLINE        uint8_t            spin_until_clock_rises();
FORCE_INLINE        uint8_t         spin_until_clock_falls();

            
            // IIC slave mode lower level functions
FORCE_INLINE        void             wait_for_bus_activity();
FORCE_INLINE        uint8_t         set_next_bus_activity(uint8_t value);
FORCE_INLINE        uint8_t         get_byte(uint8_t* value);                                                //Note: does not handle ACK/NACK.
FORCE_INLINE        uint8_t         get_byte(uint8_t* value, uint8_t (*my_ack_function)(uint8_t rxbyte));    //Note: handles ACK/NACK
FORCE_INLINE        uint8_t         set_byte(uint8_t value);
                                    
            // IIC state functions
                    uint8_t         IIC_STATE;
                    uint8_t         IIC_STATE_PREVIOUS;
FORCE_INLINE        uint8_t         StateIdle();
FORCE_INLINE        uint8_t         StateStart();
FORCE_INLINE        uint8_t         StateStop();
FORCE_INLINE        uint8_t         StateData();
FORCE_INLINE        uint8_t         StateClockFell();
FORCE_INLINE        uint8_t         StateDataBit();
FORCE_INLINE        uint8_t         StateClockLow();
FORCE_INLINE        uint8_t         StateClockHigh();

        
FORCE_INLINE        void             clock_pull_down();
FORCE_INLINE        void             data_pull_down();
FORCE_INLINE        void             clock_release();
FORCE_INLINE        void             data_release();
FORCE_INLINE        uint8_t            clock_read();
FORCE_INLINE        uint8_t            data_read();
FORCE_INLINE        void             bus_read();
FORCE_INLINE        void             bus_read_same_port();
FORCE_INLINE        void             bus_read_different_port();        
// These items are pointers to hardware which will definitely change state beyond the control of program flow (volatile)
            
            // Timer interaction functions and saved previous state
inline                void             reset_timer();
inline                void            RestoreTimer1Settings();
inline                void            SaveTimer1Settings();
inline                void            ConfigureTimer1Settings();
FORCE_INLINE        uint16_t         get_timer();
FORCE_INLINE        void             TransferTimerConfigureTransfer();
FORCE_INLINE        void             TransferTimerConfigureByte();
FORCE_INLINE        void             TransferTimerConfigureByteWithAck();
FORCE_INLINE        void             TransferTimerConfigureHalfclock();
FORCE_INLINE        void             TimerReset();
FORCE_INLINE        void             TimerClearMatch();
FORCE_INLINE        uint8_t         TimerElapsed();
inline                uint8_t         GetCurrentTimer1Divider();
inline                uint16_t         GetRatioOfTimer1Divider(uint8_t divider);
inline                uint16_t         GetFrequencyOfTimer1Divider(uint8_t divider);
inline                uint8_t         GetCurrentTimer2Divider();
inline                uint16_t         GetRatioOfTimer2Divider(uint8_t divider);
inline                uint16_t         GetFrequencyOfTimer2Divider(uint8_t divider);
                    uint8_t         p_TCCR1A;
                    uint8_t         p_TCCR1B;
                    uint8_t         p_OCR1A;
                    uint8_t         p_OCR1B;
                    uint8_t         p_TIMSK1;
                    uint8_t         p_TIFR1;  
                    uint8_t         my_TCCR1A;
                    uint8_t         my_TCCR1B;
                    uint8_t         my_OCR1A;
                    uint8_t         my_OCR1B;
                    uint8_t         my_TIMSK1;
                    uint8_t         my_TIFR1;  
                    uint8_t         timer_is_configured;  
                    
                    // Debugging functions+state
                    uint8_t         DEBUG_PIN_A_STATE;
                    uint8_t         DEBUG_PIN_B_STATE;
                    void            InitDebugpins();
FORCE_INLINE        void            debug_pin_A_test();
FORCE_INLINE        void            debug_pin_B_test();
FORCE_INLINE        void             debug_pin_A_low();
FORCE_INLINE        void             debug_pin_B_low();
FORCE_INLINE        void             debug_pin_A_high();
FORCE_INLINE        void             debug_pin_B_high();
FORCE_INLINE        void             debug_pin_A_toggle();
FORCE_INLINE        void             debug_pin_B_toggle();
FORCE_INLINE        void             fastprinthexbyte(uint8_t hexbyte);    
FORCE_INLINE        void            functimer_start();
FORCE_INLINE        void            functimer_stop();
};
#endif

Wie würdet Ihr damit nun einen I2C slave ansprechen?
Chip Adresse 0x82, Register 0x00 bis 0x09, Data 0x00 bis 0xFF
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.07.2019, 21:46
Beitrag #4
RE: I2C Master ohne ACK
Sorry, dann habe ich dich falsch verstanden.
Dachte die gefundenen Libs können ohne ACK schon arbeiten.
Da habe ich dann keine Idee.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.07.2019, 22:55
Beitrag #5
RE: I2C Master ohne ACK
So wie ich das mit schnellem Blick sehe, gibt es z.B. zwei get_byte-Funktionen. Eine, die ACK nicht bearbeitet, eine andere, die es bearbeitet:

Code:
FORCE_INLINE uint8_t  get_byte(uint8_t* value);  //Note: does not handle ACK/NACK.
FORCE_INLINE uint8_t  get_byte(uint8_t* value, uint8_t (*my_ack_function)(uint8_t rxbyte));    //Note: handles ACK/NACK

Bei der 2. Variante (die ACK behandelt) muss man dann wohl eine Acknowledge-Funktion als 2. Parameter übergeben.

Die andere ruft man ohne 2. Parameter auf. Die würde dann ACk ignorieren.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.07.2019, 12:50
Beitrag #6
RE: I2C Master ohne ACK
Vielen Dank für eure Bemühungen.

Mit der XantoI2C lib habe ich mein Problem lösen können.
Die sehr gute und sehr gut dokumentierte SoftI2C Library ist hier zufinden.

Das I2C Schreiben ohne ACK bit habe ich wie folgt gelöst:

Code:
const uint8_t NJU72343_1 = 0x80;        // Volume Chip Adresse 1 (Adresse 40H +1 Bit for write = 80H)
const uint8_t NJU72343_2 = 0x82;        // Volume Chip Address 2
XantoI2C i2c(PIN_SCL, PIN_SDA, 1);        // Create I2C Bus / time 1 bis 10 in mSec.
.
.
.
.
//Funktion: Write Register and Data to the NJU72343
uint8_t write_NJU(uint8_t register_address, uint8_t NJU_Data){        
    i2c.start();                            //I2C Start Command
    i2c.writeByte(NJU72343_2);                //Chip Adresse
    if (i2c.readNack()){                    //1. Bit (ACK) is not high then
        return 0;
    }
    i2c.writeByte(register_address);        //i2c write Register address
    if (i2c.readNack()) {                    //1. Bit (ACK) is not high then
        return 0;
    }
    i2c.writeByte(NJU_Data);                //write Data (Inhalt)
    if (i2c.readNack()) {                    //1. Bit (ACK) is not high then
        return 0;
    }
    i2c.stop();                                // Stop Transmisson

Evlt. kann es jemand brauchenWink.

viele Grüße
Andre
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.07.2019, 13:04
Beitrag #7
RE: I2C Master ohne ACK
Oh...prima.
Vielen Dank für deine Rückmeldung und dein Ergebnis.
Dann kann ich mir das auch mal ansehen.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Schleife nur 1x durchlaufen ohne for... Hanibal_Smith 3 377 01.10.2019 19:44
Letzter Beitrag: Tommy56
  For-Schleife ohne Begrenzung? Batucada 4 596 26.04.2019 09:54
Letzter Beitrag: Batucada
  [Vorstellung] Serieller Sender ohne 2. MC Tommy56 2 478 13.04.2019 22:03
Letzter Beitrag: Tommy56
  2 PWM-Signale ohne Überschneidung mephistopheles 8 1.075 27.03.2019 09:45
Letzter Beitrag: mephistopheles
  GShield v5B / Arduino Due / Verwendung ohne G-Code bytecook 0 527 26.08.2018 11:33
Letzter Beitrag: bytecook
  Doppelte Abfrage der Bedingung mit Wartezeit ohne Delay soluman 3 1.462 05.07.2018 20:53
Letzter Beitrag: GuaAck
  Leds dimmen ohne delay jennerlein 9 2.247 20.04.2018 02:04
Letzter Beitrag: Corvus
  Struct mit Defaultdaten ohne initalisieren nutzen? da_user 14 2.285 22.03.2018 19:11
Letzter Beitrag: da_user
Exclamation Frage zur I2C zwischen Master und Slave saberlucien 6 1.668 27.02.2018 15:49
Letzter Beitrag: Tommy56
  Buzzer ohne Delay Harry 9 2.276 23.01.2018 12:30
Letzter Beitrag: Tommy56

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste