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.
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.
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