Direkte Serielle Kommunikation zwischen Attiny85 und Arduino UNO

JA. Das ist auch richtig.

ABER da wird (TX mit RX) und (RX mit TX) verbunden.

Die Boards sind völlig egal. Das ist das was man in alten Zeiten eine NULLMODEM- Kommunikation nannte.

Es gibt als 2 Möglichkeiten das die mit ein andere Reden.

  1. Verdrahtung ändern (die Verbindung muss über Kreuz sein).
    ODER
  2. die Parameter der SoftwareSerial vertauschen.

ABER NICHT BEIDES.

z.b. auf den UNO so.

SoftwareSerial mySerial(4, 3);  // RX = 4, TX = 3

und auf den Atiny-85 so.

SoftwareSerial mySerial(3, 4);  // RX = 4, TX = 3

Der eine sendet und der andere Empfängt ja.

Seriell ist eine Schnittstelle KEIN BUS.

DANN Reden die auch beide miteinander. Was du auf den Link im Post 2 gut auf den Plan sehen kannst.

Gruß

Pucki

Oh, achso. Werde ich später ausprobieren

Lies man die letzten beiden Zeilen VOR den Befehlen.

Zitat: "Um sie zur Kommunikation mit einem externen seriellen TTL-Gerät zu verwenden, verbinde den TX-Pin mit dem RX-Pin deines Geräts, den RX mit dem TX-Pin deines Geräts und die Masse deines Mega mit der Masse deines Geräts."

Das geht entweder Per Kabel oder bei SoftwareSerial auch per Software.

Gruß

Pucki

Per Software hab ich bis jetzt noch nie eine leitende Verbindung zwischen verschiedenen Pegeln hinbekommen...
... man lernt nie aus :wink:

Löl. Man kann sich aber auch anstellen. :roll_eyes:

Gruß

Pucki

Wie hier schon vorgeschlagen kannst Du es mit I2C machen....

Code Master (Uno/Nano):

#include <Arduino.h>
#include <Wire.h>

//////////////////////////////////////////////////////////////////////////////
/// global variable(s)
//////////////////////////////////////////////////////////////////////////////
constexpr uint8_t I2C_SLAVE_ADDRESS {0x30};
constexpr size_t NUMBER_OF_BYTES {2};
uint8_t buffer[NUMBER_OF_BYTES] {0, 0};

uint16_t bufferToInt16(uint8_t *charBuf) {
  uint16_t val = *charBuf;
  val = (val << 8) | *(charBuf + 1);
  return val;
}

//////////////////////////////////////////////////////////////////////////////
/// @brief I2C Master:  This is an I2C to Serial Converter.
///                     Numbers are received from an I2C slave and displayed
///                     on the serial console.
///
//////////////////////////////////////////////////////////////////////////////
void setup() {
  Wire.begin();
  Serial.begin(115200);
}

void loop() {
  int idx = 0;
  Wire.requestFrom(I2C_SLAVE_ADDRESS, NUMBER_OF_BYTES);   // request NUMBER_OF_BYTES byte
                                                          // from slave device I2C_SLAVE_ADDRESS
  while (Wire.available())                                // slave may send less than requested
  {
    if (idx < NUMBER_OF_BYTES) {
      buffer[idx++] = Wire.read();   // receive a byte as character
    } else {
      break;
    }
  }

  float voltage = bufferToInt16(buffer) / 1000.0;
  Serial.println(voltage,3);
  delay(1000);
}

Code Slave (Attinyx5)

#include <Arduino.h>
#include <TinyWireS.h>   // https://github.com/rambo/TinyWire/tree/master/TinyWireS

constexpr uint8_t I2C_SLAVE_ADDR {0x30};

constexpr uint16_t VCC = 5151;   // Measured in milliVolts!
constexpr float REFxRESOLUTION {1100 * 1023.0};
constexpr float VCCxREF {VCC * 1100.0};
constexpr float INTERIM_RESULT {VCCxREF / REFxRESOLUTION};

void initADC0() {
  // Initialise ADC with REFS[2:0] is 0 = VCC as Ref,  MUX[3:0] 1100 = Vbg as Input,
  ADMUX = _BV(MUX3) | _BV(MUX2);
  ADCSRA |= _BV(ADEN);   // Enable
  delay(5);              // Wait until the reference has stabilized
  // After activating the ADC, a "dummy readout" is recommended.
  // In other words, a value is read and discarded to allow the ADC to "warm up"
  while ((ADCSRA & _BV(ADSC))) { ; }
  (void)ADCW;   // Discard dummy readout..
}

uint16_t readInternalRef11() {
  ADCSRA |= _BV(ADSC);                 // Start conversion
  while ((ADCSRA & _BV(ADSC))) { ; }   // measure
  return static_cast<uint16_t>( INTERIM_RESULT  * ADCW );
}

void dataRequest() {
  uint16_t val = readInternalRef11();
  TinyWireS.send((val >> 8));   // HIGH Byte
  TinyWireS.send(val);          // LOW Byte
}

void setup() {
  initADC0();   // Set ADC to interal reference voltage as input (Vbg)
  TinyWireS.begin(I2C_SLAVE_ADDR);
  TinyWireS.onRequest(dataRequest);
}

void loop() {}

Ist jetzt minimal, für die Übertragung eines 16 Bit Wertes.

Bei dem Ardiono UNO wären das die Pins A5 und A4 wier sieht das bei dem Attiny85 aus ?

Der Beispielcode wurde mit dem ATTinyCore von Spence Konde compiliert.

Okay danke, also Attiny Pin5 (SDA) zu A4 und Pin7 (SCL) zu A5 des UNO.

EDIT:
Welchen Widerstandswert sollte ich für die Pullup-Widerstände nehmen?

Versuche es mit 4K7.

Scheint nicht zu gehen:

D:\Migel\OneDrive\Desktops\Migels PC\Desktop\Attiny85_Read\Attiny85_Read.ino: In function 'void dataRequest()':
Attiny85_Read:30:13: error: 'class USI_TWI_S' has no member named 'send'; did you mean 'read'?
   TinyWireS.send((val >> 8));   // HIGH Byte
             ^~~~
             read
Attiny85_Read:31:13: error: 'class USI_TWI_S' has no member named 'send'; did you mean 'read'?
   TinyWireS.send(val);          // LOW Byte
             ^~~~
             read
Bibliothek TinyWireS-master in Version 1.0.0 im Ordner: D:\Migel\OneDrive\Dokumente\Arduino\libraries\TinyWireS-master  wird verwendet
exit status 1
'class USI_TWI_S' has no member named 'send'; did you mean 'read'?

Es gibt mehrere TinyWireS.
Bei den einen heißt es send, bei den anderen write.

Tipp:
Die jeweils zugehörige Doku lesen.

Beides ausprobiert, geht beides nicht

Das ist keine aussagekräftige Fehlermeldung!
Und die Doku hast du auch schon gelesen...
(das ging aber fix)

Welche würdest du empfehlen?

Bis zu dem Zeitpunkt wusste ich noch nicht mal das es mehrere unterschiedliche Libs gibt die alle gleich heißen.
Ich bin davon ausgegangen das der Beilspiel Sketch funktional ist, sorry

Wurscht!
Ich empfehle die Doku zu lesen!
Die Beispiele, welche dabei liegen anzusehen.

Habe ich gemacht, dort wurde das mit...

write

...gemacht. Hat auch Funktioniert, alerdings habe ich keine Ahnung ob das die Funktion des Sketches verändert.

EDIT:
Anhand der Beispielsketches scheint die Lib nur für Attiny84 zu sein

Im Übrigen scheint dies von diesem Thread auch nicht zu funktionieren. Der Adapter wurde anhand dieses Schaltbildes nachgebaut und das Flaschen damit funktioniert auch, aber NICHT das Auslesen am Ser Mon.
Es wurden die dort gezeigten Sketches verwendet und der Ser Mon wurde richtig eingestellt

Hast Du Dir den Quellcode mal angeschaut?


#include <TinyWireS.h>   // https://github.com/rambo/TinyWire/tree/master/TinyWireS

Der Sketch funktioniert. Ich habe ihn ausprobiert, bevor ich ihn gepostet habe und extra den Link zur verwendeten Lib als Kommentar mit hineingeschrieben, damit klar ist, welche verwendet wurde…