ATtiny85 I²C Slave übernimmt empfangenen Wert nicht.

[Marcel B. (gigi)]

Hallo zusammen,

Ich versuche einen ESP und ATtiny85 miteinander kommunizieren zu lassen. 
#
Der Attiny soll PWM-Werte Empfangen und eine LED schalten.

Der ESP sendet die Daten korrekt, soweit ich das beurteilen kann, aber 
der Attiny will die Daten einfach nicht verarbeiten.

Habe mal 2 Screenshots hochgeladen.

Habe als Test, ob die Routine überhaupt aufgerufen wird eine LED 
schalten lassen beim receiveEvent(). Dies funktioniert, aber die 
Variable pwm, wird einfach nicht geändert.  Sie ist am Anfang auf 150 
gesetzt und bleibt auch fröhlich dort.

Sitze da jetzt seit 2 Tagen dran und hab echt ein Brett vorm Kopf 
anscheinend.

Der ATtinycode :

#define I2C_SLAVE_ADDRESS 0x8 // the 7-bit address (remember to change this when adapting this example)
// Get this from https://github.com/rambo/TinyWire
#include <TinyWireS.h>
#include <Arduino.h>
// The default buffer size, Can't recall the scope of defines right now
#ifndef TWI_RX_BUFFER_SIZE
#define TWI_RX_BUFFER_SIZE ( 16 )
#endif

volatile int pwm = 150;

/**
 * This is called for each read request we receive, never put more than one byte of data (with TinyWireS.send) to the 
 * send-buffer when using this callback
 */
void requestEvent()
{  
    TinyWireS.send(pwm);
}


/**
 * The I2C data received -handler
 *
 * This needs to complete before the next incoming transaction (start, data, restart/stop) on the bus does
 * so be quick, set flags for long running tasks to be called from the mainloop instead of running them directly,
 */
 void receiveEvent(uint8_t howMany)
{ 
    digitalWrite(3,HIGH);
    if (howMany < 1)
    {
        // Sanity-check
        return;
    }
    if (howMany > TWI_RX_BUFFER_SIZE)
    {
        // Also insane number
        return;
    }

    // ignore write address
    TinyWireS.receive();
    howMany--;
    
    if (!howMany)
    {
        // This write was only to set the buffer for next read
        return;
    }

    while(howMany--)
    {
      byte recv = TinyWireS.receive();
      pwm = recv;  
    }
}


void setup()
{

    pinMode(1, OUTPUT); // OC1A, also The only HW-PWM -pin supported by the tiny core analogWrite
    pinMode(3, OUTPUT);
    /**
     * Reminder: taking care of pull-ups is the masters job
     */

    TinyWireS.begin(I2C_SLAVE_ADDRESS);
    TinyWireS.onReceive(receiveEvent);
    TinyWireS.onRequest(requestEvent);
}

void loop()
{
    /**
     * This is the only way we can detect stop condition (http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&p=984716&sid=82e9dc7299a8243b86cf7969dd41b5b5#984716)
     * it needs to be called in a very tight loop in order not to miss any (REMINDER: Do *not* use delay() anywhere, use tws_delay() instead).
     * It will call the function registered via TinyWireS.onReceive(); if there is data in the buffer on stop.
     */
    TinyWireS_stop_check();
    analogWrite(1, pwm);
}

ESP :

int pwm = 0;

void setup() {
 Serial.begin(115200); /* begin serial for debug */
 Wire.begin(); /* join i2c bus with SDA=D1 and SCL=D2 of NodeMCU */
}

void loop() {

if(pwm < 255){
  pwm +=5;
  Serial.printf("Dimming up... Next pwm value : %i", pwm);
  Serial.println();
}

else if (pwm >= 255){
  pwm =0;
  Serial.println("Reset PWM");
}

 Wire.beginTransmission(8); /* begin with device address 8 */
 Wire.write(pwm);  /* sends hello string */
 Wire.endTransmission();    /* stop transmitting */
 delay(500);
 
 Serial.printf("Sent pwm value : %i", pwm);;
 Serial.println();

Wire.requestFrom(8, 1);    // request 6 bytes from slave device #8

  while (Wire.available()) { // slave may send less than requested
    byte c = Wire.read(); // receive a byte as character
    Serial.println("Requested value from Slave:");
    Serial.print(c);         // print the character
    Serial.println();
  }

  delay(500);

}

Ich kann hier einfach keinen Fehler entdecken.

Hat jemand von Euch eine Idee ?

Grüße

[Helmut H. (helmuth)]

Marcel B. schrieb:
> // ignore write address
>     TinyWireS.receive();
>     howMany--;

Kann es sein, dass hier der erwartete pwm-Wert verschluckt wird?
Das läuft mit attiny85 problemlos:

#include <Wire.h>
...
void receiveEvent(int howMany) {
  if (howMany == 0) return;
  char c = Wire.read();
  if (c == 'S') ...

[Marcel B. (gigi)]

Danke Helmut, das wars!

Denn Sinn verstehe ich zwar immer noch nicht, aber es funktioniert 
jetzt!

Der angesprochene Code soll ja quasi die Adresse überspringen.
Sieht so aus als sei dies garnicht nötig.

Ich danke dir vielmals!

[Arduino F. (Firma: Gast) (arduinof)]

Marcel B. schrieb:
> Der angesprochene Code soll ja quasi die Adresse überspringen.
Zuviel Fantasie, an der falschen Stelle.