I2C Verständnisprobleme

[Dirk]

@RP6fahrer,

... welche Funktion hat RP6data?

Das ist eine uint8_t Variable, die den Wert des/der gelesenen Register enthält. Wenn du mehrere Register liest, müßte das ein Array sein.
Wenn alle Register da rein passen sollen: uint8_t RP6data[32];
Wenn du nur 1 Register liest, kann das auch eine einfache 8-bit Variable sein oder du nimmst Var = I2CTWI_readByte(I2C_RP6_BASE_ADR);

Anzeigen: Einfach die Variable z.B. mit writeInteger() ausgeben.

Mit der RP6Control_I2CMasterLib kannst du die ADCs tatsächlich mit den Variablen adc0 / adc1 anzeigen. Neu werden die Werte aber nur angezeigt, wenn du sie mit der Funktion readAllRegisters() eingelesen hast. Diese Funktion müßtest du dann regelmäßig aufrufen.
Wenn du nicht immer alle Register der Base lesen willst, müßtest du z.B für die ADCs eine eigene Lesefunktion schreiben.
Die sieht dann so aus, wie z.B. die für die Lichtsensoren (readLightSensors), aber ohne die Ausgabe.

[RP6fahrer]

@Rolf
Ja, danke. Kannst dich erstmal um deine Baustelle kümmern. Ich habe da nicht so ein stress.

Also, zum Problem ADC. In meinem Programm steht das hier so:

void task_test(void)
{
    I2CTWI_transmitByte(10, 23); Also hier erfolgt die Anfrage an das Register 23 von Slave(adresse 10)
    uint8_t result1 = I2CTWI_readByte(10);   und hier wird es eingelesen
    writeString_P("\n ADC0 High :   ");
    writeIntegerLength(result1, DEC, 3);  Und hier wird er über die serielle Schnittstelle ausgegeben.
    mSleep(500);
  
    I2CTWI_transmitByte(10, 25);
    uint8_t ergebnis = I2CTWI_readByte(10);
    writeString_P("\n ADC1 High :   ");
    writeIntegerLength(ergebnis, DEC, 3);
    mSleep(500);
    
        I2CTWI_transmitByte(10, 22);
    uint8_t ergebniss = I2CTWI_readByte(10);
    writeString_P("\n Batterie High :   ");
    writeIntegerLength(ergebniss, DEC, 3);
    mSleep(500);
    
    writeString_P(" | BAT:");writeIntegerLength(adcBat,DEC,4);
    writeString_P(" | AD0:");writeIntegerLength(adc0,DEC,4);
    writeString_P(" | AD1:");writeIntegerLength(adc1,DEC,4);
    writeChar('\n');

}
/**
 * Timed Watchdog display only - the other heartbeat function
 * does not work in this example as we use blocked moving functions here.
 */
void watchDogRequest(void)
{
    static uint8_t heartbeat2 = false;
    if(heartbeat2)
    {
        clearPosLCD(0, 14, 1);
        heartbeat2 = false;
    }
    else
    {
        setCursorPosLCD(0, 14);
        writeStringLCD_P("#"); 
        heartbeat2 = true;
    }
}

/*****************************************************************************/
// I2C Requests: 

/**
 * The I2C_requestedDataReady Event Handler
 */
void I2C_requestedDataReady(uint8_t dataRequestID)
{
    checkRP6Status(dataRequestID);
}

/*****************************************************************************/
// I2C Error handler

/**
 * This function gets called automatically if there was an I2C Error like
 * the slave sent a "not acknowledge" (NACK, error codes e.g. 0x20 or 0x30).
 */
void I2C_transmissionError(uint8_t errorState)
{
    writeString_P("\nI2C ERROR - TWI STATE: 0x");
    writeInteger(errorState, HEX);
    writeChar('\n');
}

void I2C_requestedDataReady(uint8_t dataRequestID)
{
    // We need to check if this is an INT0 Request from the Robot Base unit.
    // The Function call inside the if condition returns true if it was an
    // interrupt request, so we have to negate it here and if it was NOT
    // an interrupt request from the Robot base we can check any other sensors
    // from which you may have requested data...
    if(!checkRP6Status(dataRequestID)) 
    {
        // Here you can Check other sensors/microcontrollers with their own
        // request IDs - if there are any... 
    }
}

/*****************************************************************************/
// Main function - The program starts here:

int main(void)
{
    initRP6Control();  
    initLCD();
    
    writeString_P("\n\nRP6 CONTROL M32 I2C Master Example Program!\n"); 
    writeString_P("\nMoving...\n"); 

    // ---------------------------------------
    WDT_setRequestHandler(watchDogRequest); 
    
    // ---------------------------------------
    // Init TWI Interface:
    I2CTWI_initMaster(100);  
    I2CTWI_setRequestedDataReadyHandler(I2C_requestedDataReady);
    I2CTWI_setTransmissionErrorHandler(I2C_transmissionError);

    sound(180,80,25);
    sound(220,80,25);

    setLEDs(0b1111);

    showScreenLCD("################", "################");
    mSleep(500);
    showScreenLCD("I2C-Master", "Movement...");
    mSleep(1000);
    setLEDs(0b0000);
    
    WDT_setRequestHandler(watchDogRequest); 
    
    // ---------------------------------------
    //I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_ACS_POWER, ACS_PWR_MED);
    //writeString_P("ACS Power ist medium\n");
    //mSleep(500);
    I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_WDT, true);
    writeString_P("WDT ist true\n");
    mSleep(500);
    I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_WDT_RQ, true);
    writeString_P("WDT-RQ ist true\n");
    mSleep(500);
        //I2CTWI_transmit3Bytes(10, 0, 6, FWD);
        
        I2CTWI_setRequestedDataReadyHandler(I2C_requestedDataReady);
    
    while(true) 
    {     
    task_I2CTWI();
    task_test();    
    
        }
    return 0;
}

Das Problem ist jetzt, dass der Wert diese ADC0 normal (durch Lichtsensor) 780 ist, aber über das M32 sind dass nur 230 ungefähr. mache ich da noch was falsch?
Und beu ubat zeigt er mir 000 an.
Und dann würde ich noch gern wissen wollen, was das wdt und wdt_RQ ist.
LG

[Dirk]

Wenn du diese 2 Funktionen benutzt, liest du adc0 und adc1 richtig ein.

void getADC0(void)
{
 I2CTWI_readRegisters(I2C_RP6_BASE_ADR, I2C_REG_ADC_ADC0_L, RP6data, 2);
 adc0 = RP6data[0] + (RP6data[1]<<8);
}
 
void getADC1(void)
{
 I2CTWI_readRegisters(I2C_RP6_BASE_ADR, I2C_REG_ADC_ADC1_L, RP6data, 2);
 adc1 = RP6data[0] + (RP6data[1]<<8);
}

RP6data müßtest du als uint8_t RP6data[2] deklarieren.
Für Ubat sieht die Funktion genauso aus. Der 2. Parameter in der I2C-Lesefunktion wäre dann I2C_REG_ADC_UBAT_L.

[RolfD]

Ich bin mir sehr sicher, das dies Übertragungsfehler verursacht durch I2C sind. Genau solche Fehler treten z.B. auch mit Remotrol auf, einer Steuersoftware für den RP6. Wenn es dich wirklich interssiert, schau mal in den Thread:
https://www.roboternetz.de/community...-RP6Lib-Bugfix
LG Rolf

[Dirk]

Ich bin mir sehr sicher, das dies Übertragungsfehler verursacht durch I2C sind.

Bevor man das sagen kann, muss das Testprog erst mal funktionieren:
1. Von Ubat wird nur das Highbyte gelesen und das sollte zwar auch nicht 0 sein, aber das müßte man noch checken.
2. Von ADC0 und ADC1 wird nur das Lowbyte gelesen, da kann man nicht mit den direkt ermittelten 16-Bit-Werten vergleichen.

[RolfD]

@Dirk
Welchen Grund sollte es sonst haben das Werte bei der Übertragung ab und zu verloren gehen.. und zwar ausgerechnet die spät gelesenen Register so ca. ab pos 20?
Ausserdem funktioniert das Testprogramm schon was länger.
Is aber auch egal. Mein Bot macht was er soll...

Edit: Sorry, das war wohl ein Missverständnis zwischen mir und Dirk

[Dirk]

Ausserdem funktioniert das Testprogramm schon was länger.

Ich habe vom Testprog von RP6fahrer (17:25) "task_test" gesprochen.

[RP6fahrer]

@Dirk
Ja, dein Vorschlag hat funktioniert. Jetzt zeigt er die richtigen Werte an. Ich habe allerdings dazu noch ein paar fragen

I2CTWI_readRegisters(10, I2C_REG_ADC_ADC0_L, RP6data, 2);
    adc0 = RP6data[0] + (RP6data[1]<<8);

I2CTWI_readRegisters ist der Befehl zum Lesen der Register
10 die Adresse des Slave
I2C_REG_ADC_ADC0_L das Register zum Lesen des Adc0 Registers -- Warum nicht I2C_REG_ADC_ADC0_H?
RP6data ne Variable?
2 wozu ist die gut?

RP6data[0] + (RP6data[1]<< und was hat das im einzelnen zu sagen?

Ich hoffe ich nerve euch nicht damit. Aber ich finde irgendwie nirgendwo eine einfache Erklärung zu den ganzen Aufrufen.

Naja, denn noch nen schönen Abend und schöne Ostern
LG RP6fahrer