viele Attinys an einem Serial

da der code jetzt bei mir läuft, gibts problem mit der serielen Schhnittstelle, manche erhalten die befehle sporadisch, andere wiederum einwandfrei, und das zufällig, ich denke mal es liegt an der methode wie ich es angeschlossen hab, mal anbei ein schaltbild, villeicht weis ja jemmand woran es liegt das die befehle nicht synchron ankommen, oder angenommen werden

Das ist eine Punkt-zu-Punkt Verbindung. Wenn du einen Bus brauchst gibt es I2C

Ein Sender/mehrere Empfänger geht vielleicht noch. Aber du kannst auf keinen Fall mehrere Sender zusammenschließen

da der code jetzt bei mir läuft,

Solltest Du Dich auf einen früheren thread beziehen, auf welchen?

In Deinem Schaltplan fehlt mindestens eine Verbindung von +5V zum Board.

Mach bitte Fotos vom realen Aufbau, den Schaltplan komplettieren und gib wenn möglich Code, den man nachlesen kann.

Serenifly war schneller. :wink:
Ich bin davon ausgegangen, das die tinys nur lauschen.
Dazu bräuchte es aber code....

my_xy_projekt:
Solltest Du Dich auf einen früheren thread beziehen, auf welchen?

In Deinem Schaltplan fehlt mindestens eine Verbindung von +5V zum Board.

Mach bitte Fotos vom realen Aufbau, den Schaltplan komplettieren und gib wenn möglich Code, den man nachlesen kann.

ja der Teensy bekommt ja seine spannung über usb, habs bewußt weggelassen
das war der frühere thread attiny85 mit tl866ii plus flashen - Deutsch - Arduino Forum

ja mit i2c würde es bestimmt gut gehen, aber da bin ich nicht fit drin

ja mit i2c würde es bestimmt gut gehen, aber da bin ich nicht fit drin

Das ist aber schade!
Denn I2C ist ein Bussystem.

Die Serielle ist kein Bus.

Bei dir arbeiten 4 Tx Pins (Ausgänge) gegeneinander

Frage:
Welcher gewinnt?
Wo rauchts zuerst?

wozu dienen die ATtiny? Warum schließt du die Ringe nicht direkt am Controller an?

noiasca:
wozu dienen die ATtiny? Warum schließt du die Ringe nicht direkt am Controller an?

ursprünglich hatte ich das auch vor,
die Ringe kommen in ein E30 rein der nur auf events mal zu sehen ist, es sollten einige animationen unamhängig voneinannder darauf laufen das man über ein nextion anwählen kann, aber das übersteigt meine Programmierkenntnisse die wirklich nicht gut sind, daher die idee mit den Attiny´s, ein controller pro Ring

aha. Und das Ansteuern von 6 tiny ist dann einfacher als 6 nicht blockiernde Animationen zu schreiben? na wennst meinst...

noiasca:
aha. Und das Ansteuern von 6 tiny ist dann einfacher als 6 nicht blockiernde Animationen zu schreiben? na wennst meinst...

vielleicht kannst mir ja dabei helfen das ganze auf allen 4 zum laufen zu bekommmen

#include "FastLED.h"
#include <EEPROM.h>
#define NUM_LEDS 24
CRGB leds[NUM_LEDS];
#define PIN1 20

const int addr = 0;

void setup()
{
  FastLED.addLeds<WS2811, PIN1, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  Serial.begin(9600);
}

void serialEvent()
{
  char effekt = Serial.read();
  if (isalpha(effekt)) EEPROM[addr] = effekt;
}

void loop() {

  switch ((char)EEPROM[addr]) {
    case 'a'  : {
        FadeInOut(255, 0, 0); // red
        break;
      }
      case 'b'  : {
          Sparkle(255, 255, 255, 40);
          break;
        }
      case 'c'  : {
          NewKITT(255, 0, 0, 8, 10, 50);
          break;
    }
  }
}

void FadeInOut(byte red, byte green, byte blue) {
  float r, g, b;

  for (int k = 100; k < 256; k = k + 1) {
    r = (k / 256.0) * red;
    g = (k / 256.0) * green;
    b = (k / 256.0) * blue;
    setAll(r, g, b);
    showStrip();
  }

  for (int k = 256; k >= 100; k = k - 0.01) {
    r = (k / 256.0) * red;
    g = (k / 256.0) * green;
    b = (k / 256.0) * blue;
    setAll(r, g, b);
    showStrip();
  }
}


void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
}

// used by NewKITT
void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = ((NUM_LEDS - EyeSize) / 2); i >= 0; i--) {
    setAll(0, 0, 0);

    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);

    setPixel(NUM_LEDS - i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(NUM_LEDS - i - j, red, green, blue);
    }
    setPixel(NUM_LEDS - i - EyeSize - 1, red / 10, green / 10, blue / 10);

    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void Sparkle(byte red, byte green, byte blue, int SpeedDelay) {
  int Pixel = random(NUM_LEDS);
  setPixel(Pixel, red, green, blue);
  showStrip();
  delay(SpeedDelay);
  setPixel(Pixel, 25, 0, 0);
}

// Set all LEDs to a given color and apply it (visible)
void setAll(byte red, byte green, byte blue) {
  for (int i = 0; i < NUM_LEDS; i++ ) {
    setPixel(i, red, green, blue);
  }
  showStrip();
}

void showStrip() {
#ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip.show();
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  FastLED.show();
#endif
}

void setPixel(int Pixel, byte red, byte green, byte blue) {
#ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip.setPixelColor(Pixel, strip.Color(red, green, blue));
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  leds[Pixel].r = red;
  leds[Pixel].g = green;
  leds[Pixel].b = blue;
#endif
}

beschreibe deinen Ablauf.

Was soll wann passieren.

combie:
Die Serielle ist kein Bus.

Doch.
Ein (1) TX und n RX gehen immer.

Ich gehe konform:
Die Serielle ist kein MultiMaster

Dem OP fehlt damit die Funktionalität festzustellen, ob der RX die Information aufgenommen hat.
Das er in die Lage versetzt wird, die Information vollständig von einem Master an n Slave zu übermittteln ist damit nicht ausgeschlossen.

Unbestritten: I2C ist und bleibt im vorliegenden Fall das Maß der Dinge.

noiasca:
beschreibe deinen Ablauf.

Was soll wann passieren.

also, wenn Spannung am Controller anliegt,, soll er die letze aufgerufene Animation laufen, die er per serial über den Nextion erhalten hat, Nextion ist aber in diesem Code noch nicht drin, wenn z.b. der Buchstabe A reinkommt, dann soll wie in dem Code mit der SwitchCase funtion, unterschiedliche Animationen an unterschiedlichen Ringen aktiviert werden

Doch.
Ein (1) TX und n RX gehen immer.

Dein "doch" unterschlägt die ganzen Tx und ist damit eine Lüge.

Es gibt eine Möglichkeit die serielle Schnittstelle für 5 Geräte zu verwenden. Die Programmierung ist aber ein bißchen kompliziert.

Mann schließt einfach die Schnittstellen in einem Ring zusammen. Also
TX des Teensy mit RX des ersten ATtiny
TX des ersten ATtiny mit dem RX des zweiten ATtiny
...
TX des letzten ATtiny mit dem RX des Teensy.

So ist immer nur ein TX mit einem RX verbunden.
Jeder ATtiny muß mittels einer Adresse angesprochen werden und die Daten die jeder ATtiny bekommt muß er weiterleiten.

I2C oder SPI ist einfacher weil schon implementiert.

Grüße Uwe

combie:
Dein "doch" unterschlägt die ganzen Tx und ist damit eine Lüge.

Das ist Unsinn.
"Lügen dienen dazu, einen Vorteil zu erlangen, zum Beispiel um einen Fehler oder eine verbotene Handlung zu verdecken und so Kritik oder Strafe zu entgehen."

Wo Tx unterschlagen wird, kann ich nicht erkennen. Oder was ist an 1 RX und n TX nicht zu verstehen?

Die Behauptung "Die serielle ist kein Bus" ist so nicht haltbar.

Die serielle ist kein bidirektionaler Bus, kein Multimaster Bus, kein diffentieller Bus, - alles richtig. Kein Bus ist falsch.

[edit]
Uwe war so nett. Danke.
[/edit]

bevor ihr euch hier noch Verprügelt, seh ich die einzige alternative das hier besagt i2c, da sollte ich mich mal einarbeiten, denn alles andere ist für mich leider zu hoch

Der Ring von uwe ist immer noch kein serieller Bus mit x TX an einer Leitung (das wäre die Definition eines Busses)

Gruß Tommy

uwefed:
Jeder ATtiny muß mittels einer Adresse angesprochen werden und die Daten die jeder ATtiny bekommt muß er weiterleiten.

Ich bin - in #2 - sogar noch davon ausgegangen, das der OP alle Slave nur lauschen lässt und die via One-Master/Multi-Slave erreichen möchte. (Das Zuhören ist nicht eingeschränkt.)

Nicht ohne Grund habe ich weitere Informationen angefragt. Und war mir vor allem über die tatsächliche Umsetzung nicht sicher, weil machbar aber aus dem Plot nicht ersichtlich.

I2C oder SPI ist einfacher weil schon implementiert.

Unbestritten.
Wäre auch meine erste Wahl, wenn fest verdrahtet.

Nicht ohne Grund habe ich weitere Informationen angefragt. Und war mir vor allem über die tatsächliche Umsetzung nicht sicher, weil machbar aber aus dem Plot nicht ersichtlich.

@ my_xy_projekt
Meiner Meinung ist das von Dir in #2 eingebettete Bild eindeutig. Die TX der 4 ATtiny sind zusammengeschaltet.
Grüße Uwe

also, jetzt hab ich mal was versucht, als Master hab ich beim Teensy

#include <Wire.h>

void setup() {
  Serial.begin(9600);
  Wire.begin(); 
}

void loop() {
  while ( Serial.available() ) {
    char c = Serial.read();

    if (c == 'a') {
      Wire.beginTransmission(1);
      Wire.beginTransmission(2);
      Wire.write('a');
      Wire.endTransmission();
    }
    else if (c == 'b') {
      Wire.beginTransmission(1);
      Wire.beginTransmission(2);
      Wire.write('b');
      Wire.endTransmission();
    }
  }
}

und beim Attiny als Slave

#include <Wire.h>
#include "FastLED.h"
#include <EEPROM.h>
#define NUM_LEDS 24
CRGB leds[NUM_LEDS];
#define LED 1

const int addr = 0;

void setup() {
  FastLED.addLeds<WS2811, LED, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  Wire.begin(1);
  Wire.onReceive(receiveEvent);
}

void receiveEvent(int howMany) {

  char effekt = Wire.read();
  if (isalpha(effekt)) EEPROM[addr] = effekt;
}

void loop() {
  switch ((char)EEPROM[addr]) {
    case 'a'  : {
        FadeInOut(255, 0, 0); // red
        break;
      }
    case 'b'  : {
        Sparkle(255, 255, 255, 40);
        break;
      }
    case 'c'  : {
        NewKITT(255, 0, 0, 8, 10, 50);
        break;
      }
  }
}


void FadeInOut(byte red, byte green, byte blue) {
  float r, g, b;

  for (int k = 100; k < 256; k = k + 1) {
    r = (k / 256.0) * red;
    g = (k / 256.0) * green;
    b = (k / 256.0) * blue;
    setAll(r, g, b);
    showStrip();
  }

  for (int k = 256; k >= 100; k = k - 0.01) {
    r = (k / 256.0) * red;
    g = (k / 256.0) * green;
    b = (k / 256.0) * blue;
    setAll(r, g, b);
    showStrip();
  }
}


void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
}

// used by NewKITT
void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = ((NUM_LEDS - EyeSize) / 2); i >= 0; i--) {
    setAll(0, 0, 0);

    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);

    setPixel(NUM_LEDS - i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(NUM_LEDS - i - j, red, green, blue);
    }
    setPixel(NUM_LEDS - i - EyeSize - 1, red / 10, green / 10, blue / 10);

    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void Sparkle(byte red, byte green, byte blue, int SpeedDelay) {
  int Pixel = random(NUM_LEDS);
  setPixel(Pixel, red, green, blue);
  showStrip();
  delay(SpeedDelay);
  setPixel(Pixel, 25, 0, 0);
}

void setAll(byte red, byte green, byte blue) {
  for (int i = 0; i < NUM_LEDS; i++ ) {
    setPixel(i, red, green, blue);
  }
  showStrip();
}

void showStrip() {
#ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip.show();
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  FastLED.show();
#endif
}

void setPixel(int Pixel, byte red, byte green, byte blue) {
#ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip.setPixelColor(Pixel, strip.Color(red, green, blue));
#endif
#ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  leds[Pixel].r = red;
  leds[Pixel].g = green;
  leds[Pixel].b = blue;
#endif
}

verträgt sich aber irgendwie mit dem attiny nicht, bekomm ein haufen fehler, scheinbar mag er das Wire nicht

edit:

habs gelöst, der Tiny brauch eine andere Wire Library, jetzt kann ich sogar noch weitere 124 Ringe anschließen, besten Dank mit dem tip i2C