Hilfe bei FlimmerPin im Belebtes Haus auf ATtiny

Hallo an alle und ein glückliches 2017, Zuerst entschuldigen Sie bitte mein Deutsch, wenn es nicht 100% ist, aber ich bin nicht fließend in der deutschen Sprache Obwohl ich sehr gut verstehe und ein wenig spreche, wenn ich schreibe, habe ich Angst, dass ich benutzen muss Der Google-Übersetzer, ok, also jetzt für meine Frage.?, In der ursprünglichen "Herbie Livley Haus ATtiny Arduino Skizze" auf Pin 1 gibt es eine Flickering zufällige LED, die flackert bei verschiedenen Intensitäten zu simulieren, das Flackern eines TV, während auf Pins 0,2,3,4 und 5 gibt es LEDs, die nach dem Zufallsprinzip ein- und ausschalten, um das Ein- und Ausschalten unterschiedlicher Lichter im Haus zu simulieren, wie im folgenden Code zu sehen ist, wie für das flackernde Led an Pin 1 Simuliert das TV Ich möchte diesen Effekt mit 2 weitere flackernde LEDs, die auch flackern zufällig Intensitäten der insgesamt drei LEDs flackert zufällig zu verbessern, um die Wirkung eines Farbfernsehers zu schaffen Ich möchte, dass dies zu tun Ich Probabley für den Moment zu verbessern Haben zu lösen 2 der Hausleuchten, aber dies für den Moment ist kein Problem.,

/*  Simulation "belebtes Haus für die Modellbahn" */
/*  Version "Flimmern nur wenn die Pin-2 LED an ist */
byte pwmFlimmerPin=1; // PWM Pin für das "analoge" Flimmern
long flimmerStart,flimmerEnd; // Anfangs- und Endzeiten für das Flimmern
// LED Pins für das normale Blinken deklarieren
byte leds[]   ={   5,    4,   3,   2,   0};
// LED Blinktakt in Millisekunden für diese Pins
long ledtakt[]={6000, 8800, 13000, 20000, 20400};
// Variablen zum Merken von millis()-Zeiten beim Schalten/Blinken
long ledtime[sizeof(leds)];

void setup() {
//  Serial.begin(9600);
  // Alle verwendeten Pins auf OUTPUT setzen
  pinMode(pwmFlimmerPin, OUTPUT);  
  for (int i=0;i<sizeof(leds);i++)
    pinMode(leds[i], OUTPUT);
}

boolean milliSekundenTakt(int dauer, long &alterWert) {
// Parameter "dauer": Dauer einer Blinkphase (an bzw. aus)
// Parameter "alterWert": Variable zum Speichern des millis() Timers
// Rückgabewert: true wenn die Zeit bis zum nächsten Umschalten abgelaufen ist, sonst false
  if (millis() - alterWert < dauer) return false;
  while (millis() - alterWert >= dauer) alterWert+=dauer;
  return true;  
}

void blinkenImTakt() {
  
// Alle gleichmäßig blinkenden LEDs in ihrem eigenen Takt blinken lassen  
  for (int i=0;i<sizeof(leds);i++) // alle LEDs in einer Schleife durchgehen
  {
    if (milliSekundenTakt(ledtakt[i],ledtime[i])) // Takt für diese LED abgelaufen?
    {
      digitalWrite(leds[i],!digitalRead(leds[i]));  // wenn ja ==> Umschalten
      if (leds[i]==0 && digitalRead(leds[i])) // Pin-13 LED wurde gerade eingeschaltet
      {
       flimmerStart=millis()+2000; // Anfangszeit für das Flimmern setzen
       flimmerEnd =millis()+15000;  // Endzeit für das Flimmern setzen
      }  
//      Serial.print("Pin ");Serial.print(leds[i]);Serial.print(" = ");Serial.println(digitalRead(leds[i]));
    }
  }
}

void flimmernPwmPin() {
// Die flimmernde LED im Zufallsmodus flimmern lassen
  static long alterWert;
  static int flimmerDauer=200;
  static byte flimmerHelligkeit;
  if (milliSekundenTakt(flimmerDauer,alterWert)) // Takt abgelaufen?
  {
    flimmerDauer=1+random(200); // neue Flimmerdauer als Zufallswert
    if (millis()>flimmerStart && millis()<flimmerEnd)
      flimmerHelligkeit=random(256); // neue Flimmerhelligkeit als Zufallswert
    else  
      flimmerHelligkeit=0; // Flimmern aus wenn falsche Zeit zum Flimmern
    analogWrite(pwmFlimmerPin, flimmerHelligkeit); 
  }  
}

void loop() {
  blinkenImTakt();
  flimmernPwmPin();
}

Ich verstehe, dass dieser Effekt durch die Variable flimmernPwmPin erzeugt wird, dass die Blende der Flimmerzeit durch die FlimmerStart und FlimmerEnd Variablen definiert wird und die Intensität des Flimmerns mit der flimmerDauer Variable definiert ist und obwohl ich verschiedene Modifikationen des Arduino versucht habe Sketch "einschließlich der Erstellung einer flimmernPwmPin2, FlimmerStart2 und FlimmerEnd2 und FlimmerDauer2 Variablen und Wiederholung der Subroutine mit den benötigten Variationen haben absolut kein Glück hatte .. !!! Hoffen, dass jemand kann und sind bereit, mir mit der Skizze Modifikationen benötigt und wieder ein sehr, aber sehr gutes neues Jahr alle zu helfen.

PS Ich lasse die ursprüngliche Frage auf Englisch, also wenn mein Deutsch ist so schlecht, dass Sie vielleicht nicht verstehen, es zumindest in Englisch vielleicht werden Sie in der Lage, es zu verstehen ... :slight_smile: :slight_smile: :slight_smile:

Hello to all and a happy 2017 , Firstly, please excuse my German, if it is not 100%, but I am not fluent in the German language Although I understand very well, and speak a little, when writing I am afraid I must use the google translator, ok, so now for my question.?, In the original "Herbie's Livley house ATtiny arduino sketch" on pin 1 there is a Flickering random led which flickers at diffrent intensitys to simulate the flickering of a TV, while on pins 0,2,3,4 and 5 there are leds which turn on and off randomly to simulate the turning on and off of diffrent lights in the house, as can be seen in the following code, as for the flickering Led on pin 1 which simulates the TV I would like to enhance this effect incorporating 2 more flickering leds which also flicker at random intensitys the total of the three leds flickering randomly so as to create the effect of a color TV I understand that to do this I Probabley for the moment have to loose 2 of the house lights but this for the moment is not a problem.,

/*  Simulation "belebtes Haus für die Modellbahn" */
/*  Version "Flimmern nur wenn die Pin-2 LED an ist */
byte pwmFlimmerPin=1; // PWM Pin für das "analoge" Flimmern
long flimmerStart,flimmerEnd; // Anfangs- und Endzeiten für das Flimmern
// LED Pins für das normale Blinken deklarieren
byte leds[]   ={   5,    4,   3,   2,   0};
// LED Blinktakt in Millisekunden für diese Pins
long ledtakt[]={6000, 8800, 13000, 20000, 20400};
// Variablen zum Merken von millis()-Zeiten beim Schalten/Blinken
long ledtime[sizeof(leds)];

void setup() {
//  Serial.begin(9600);
  // Alle verwendeten Pins auf OUTPUT setzen
  pinMode(pwmFlimmerPin, OUTPUT);  
  for (int i=0;i<sizeof(leds);i++)
    pinMode(leds[i], OUTPUT);
}

boolean milliSekundenTakt(int dauer, long &alterWert) {
// Parameter "dauer": Dauer einer Blinkphase (an bzw. aus)
// Parameter "alterWert": Variable zum Speichern des millis() Timers
// Rückgabewert: true wenn die Zeit bis zum nächsten Umschalten abgelaufen ist, sonst false
  if (millis() - alterWert < dauer) return false;
  while (millis() - alterWert >= dauer) alterWert+=dauer;
  return true;  
}

void blinkenImTakt() {
  
// Alle gleichmäßig blinkenden LEDs in ihrem eigenen Takt blinken lassen  
  for (int i=0;i<sizeof(leds);i++) // alle LEDs in einer Schleife durchgehen
  {
    if (milliSekundenTakt(ledtakt[i],ledtime[i])) // Takt für diese LED abgelaufen?
    {
      digitalWrite(leds[i],!digitalRead(leds[i]));  // wenn ja ==> Umschalten
      if (leds[i]==0 && digitalRead(leds[i])) // Pin-13 LED wurde gerade eingeschaltet
      {
       flimmerStart=millis()+2000; // Anfangszeit für das Flimmern setzen
       flimmerEnd =millis()+15000;  // Endzeit für das Flimmern setzen
      }  
//      Serial.print("Pin ");Serial.print(leds[i]);Serial.print(" = ");Serial.println(digitalRead(leds[i]));
    }
  }
}

void flimmernPwmPin() {
// Die flimmernde LED im Zufallsmodus flimmern lassen
  static long alterWert;
  static int flimmerDauer=200;
  static byte flimmerHelligkeit;
  if (milliSekundenTakt(flimmerDauer,alterWert)) // Takt abgelaufen?
  {
    flimmerDauer=1+random(200); // neue Flimmerdauer als Zufallswert
    if (millis()>flimmerStart && millis()<flimmerEnd)
      flimmerHelligkeit=random(256); // neue Flimmerhelligkeit als Zufallswert
    else  
      flimmerHelligkeit=0; // Flimmern aus wenn falsche Zeit zum Flimmern
    analogWrite(pwmFlimmerPin, flimmerHelligkeit); 
  }  
}

void loop() {
  blinkenImTakt();
  flimmernPwmPin();
}

I Understand that this effect is produced by the flimmernPwmPin variable, that the legth of the flickering time is defined by the FlimmerStart And FlimmerEnd Variables and the intensity of the flickering is defined with the flimmerDauer variable and although I have tried diffrent modifications to the "Arduino Sketch" including creating a flimmernPwmPin2, FlimmerStart2 and FlimmerEnd2 and FlimmerDauer2 Variables and repeating the subroutine with the needed variations have had absoloutley no luck..!!! Hoping that someone can and are willing to help me with the sketch modifications needed and again a very, but very good new year all.

Happy New Year!

Von welchem ATtiny sprichst Du? Nicht alle Ausgänge können für PWM verwendet werden, das mußt Du berücksichtigen.

hi,

wir hatten doch mal ein komplettes haus mit ablaufsteuerung der jeweiligen "zimmer-einschaltzeiten" plus TV-gerät hier im deutschen forum. samt abschließendem video...

hat noch jemand den link auf den thread?

gruß stefan

Eisebaer:
hi,

wir hatten doch mal ein komplettes haus mit ablaufsteuerung der jeweiligen "zimmer-einschaltzeiten" plus TV-gerät hier im deutschen forum. samt abschließendem video...

hat noch jemand den link auf den thread?

gruß stefan

Das ist dieser Thread

Den Code dafür habe ich als Sketch in Antwort #19 gepostet. Und Herbie als damaliger Starter des Themas hat das Haus gebaut und davon ein Youtube-Video gemacht und es online verfügbar gemacht. Das hat mich damals sehr gefreut, denn so viel Feedback erhalte ich normalerweise nicht, wenn ichjemandem ein Beispielprogramm programmiere und poste.

Wenn ich da so rein schaue :

long flimmerStart,flimmerEnd; // müsste hier nicht ein unsigned long hin
// LED Pins für das normale Blinken deklarieren
byte leds[] ={ 5, 4, 3, 2, 0};
// LED Blinktakt in Millisekunden für diese Pins
long ledtakt[]={6000, 8800, 13000, 20000, 20400};
// Variablen zum Merken von millis()-Zeiten beim Schalten/Blinken
long ledtime[sizeof(leds)]; // müsste hier nicht auch ein unsigned long hin

Da hier ja millis() Werte gespeichert werden sind das ja auch unsigned long. Okay es wird ja schon wohl kaum merh als 25 Tage an Stück laufen aber wenn dann richtig oder?
Der Code ist ja schon aus dem Thread so wie das hier sehe.
Welchen Attiny nutzt du? Es gibt einige Varianten die von der Arduino Seite her unterstüztt werden da brauchen wir noch eine Angabe. Wie schon erwähnt kann nicht jeder Pin PWM.

Gurß
DerDani

volvodani:
Wie schon erwähnt kann jeder Pin PWM.

Nö, nicht jeder Pin kann PWM!

Oh mann ich habe es auch so gemeint......

Korrigiert<

Gruß
DerDani

volvodani:
Oh mann ich habe es auch so gemeint......

Dachte ich mir :slight_smile:

volvodani:
Da hier ja millis() Werte gespeichert werden sind das ja auch unsigned long. Okay es wird ja schon wohl kaum merh als 25 Tage an Stück laufen aber wenn dann richtig oder?

Das hat jurs geschrieben, als ich noch mit der Trommel um den Weihnachtsbaum lief und er in seiner Sturm und Drangperiode war. Da waren 25 Tage doch eine Ewigkeit und "wenn, dann richtig" eine Beleidigung.

Der inzwischen gereifte Kuhjunge hat sich den Sketch aus dem anderen Thema von #19 genommen und für den UNO erweitert, so daß auch der Fernseher auf der Modellanlage nun vom SW- ins Farbzeitalter wechseln kann:

/*  Simulation "belebtes Haus für die Modellbahn" by jurs */
/*  Version "Flimmern nur wenn die Pin-13 LED an ist */
/*  getestet mit UNO */
const byte pwmFlimmerPin[] = {3, 5, 10};  // PWM Pin für das "analoge" Flimmern
uint32_t flimmerStart, flimmerEnd;        // Anfangs- und Endzeiten für das Flimmern
const byte leds[] = {8, 9, 11, 12, 13};   // LED Pins für das normale Blinken deklarieren
const uint32_t ledtakt[] = {1500, 2200, 3333, 5000, 9100};  // LED Blinktakt in Millisekunden für diese Pins
uint32_t ledtime[sizeof(leds)];   // Variablen zum Merken von millis()-Zeiten beim Schalten/Blinken

void setup() {
  //  Serial.begin(9600);
  // Alle verwendeten Pins auf OUTPUT setzen
  for (byte i = 0; i < sizeof(leds); i++) {
    pinMode(leds[i], OUTPUT);
  }
}

void blinkenImTakt() {

  // Alle gleichmäßig blinkenden LEDs in ihrem eigenen Takt blinken lassen
  for (byte i = 0; i < sizeof(leds); i++) // alle LEDs in einer Schleife durchgehen
  {
    if (millis() - ledtime[i] >= ledtakt[i]) // Takt für diese LED abgelaufen?
    {
      ledtime[i] = millis();
      digitalWrite(leds[i], !digitalRead(leds[i])); // wenn ja ==> Umschalten
      if (leds[i] == 13 && digitalRead(leds[i])) // Pin-13 LED wurde gerade eingeschaltet
      {
        flimmerStart = millis() + 2000; // Anfangszeit für das Flimmern setzen
        flimmerEnd = millis() + 8000; // Endzeit für das Flimmern setzen
      }
      //      Serial.print("Pin ");Serial.print(leds[i]);Serial.print(" = ");Serial.println(digitalRead(leds[i]));
    }
  }
}

void flimmernPwmPins() {
  // Die flimmernde LED im Zufallsmodus flimmern lassen
  static uint32_t alterWert[sizeof(pwmFlimmerPin)];
  static uint32_t flimmerDauer[sizeof(pwmFlimmerPin)] = {200, 200, 200};
  static byte flimmerHelligkeit[sizeof(pwmFlimmerPin)];
  for (byte i = 0; i < sizeof(pwmFlimmerPin); i++) {
    if (millis() - alterWert[i] >= flimmerDauer[i]) // Takt abgelaufen?
    {
      alterWert[i] = millis();
      flimmerDauer[i] = 1 + random(200); // neue Flimmerdauer als Zufallswert
      if (millis() > flimmerStart && millis() < flimmerEnd)
        flimmerHelligkeit[i] = random(256); // neue Flimmerhelligkeit als Zufallswert
      else
        flimmerHelligkeit[i] = 0; // Flimmern aus wenn falsche Zeit zum Flimmern
      analogWrite(pwmFlimmerPin[i], flimmerHelligkeit[i]);
    }
  }
}

void loop() {
  blinkenImTakt();
  flimmernPwmPins();
}

Hallo an alle Danke für die schnellen Antworten, soweit Ihre Fragen gehen als Herbie hat in seiner ursprünglichen Programmierung Ich bin mit einem attiny45 und attiny85, die zwar zunächst verstehen kann, erlaubt nur 2 PWM-Pins auf Pin 5 und 6 Ich glaube, dieses Problem Ich denke, kann in einer von 2 verschiedenen Arten überwunden werden, entweder wie in diesem Link:

http://www.technoblogy.com/show?LE0

beschrieben oder wie beschrieben mit einem Shift Register IC, wie hier beschrieben

hatte ich wahrscheinlich gedacht, für das schieberegister opcion zu gehen, da es einfacher zu handhaben scheint als das kodierte beispiel, obwohl ich offen für ideen bin Sonst hat sie.

P.S. Stefan (Icebergs) der Code, den ich spiele mit ist der ursprüngliche Code aus, dass Link und ist der Code in # 1 geschrieben

Für den 85 gibt es einen Sketch für 3 PWM.

// For Attiny85
// Author: Nick Gammon
// Date: 29 November 2012

void setup()
{
  pinMode (0, OUTPUT);  // pin 5  // OC0A
  pinMode (1, OUTPUT);  // pin 6  // OC0B
  pinMode (4, OUTPUT);  // pin 3  // OC1B
 
  // Timer 0, A side
  TCCR0A = _BV (WGM00) | _BV (WGM01) | _BV (COM0A1); // fast PWM, clear OC0A on compare
  TCCR0B = _BV (CS00);           // fast PWM, top at 0xFF, no prescaler
  OCR0A = 127;                   // duty cycle (50%)

  // Timer 0, B side
  TCCR0A |= _BV (COM0B1);        // clear OC0B on compare
  OCR0B = 63;                    // duty cycle (25%)

  // Timer 1
  TCCR1 = _BV (CS10);           // no prescaler
  GTCCR = _BV (COM1B1) | _BV (PWM1B);  //  clear OC1B on compare
  OCR1B = 31;                   // duty cycle (25%)
  OCR1C = 127;                  // frequency
  }  // end of setup

void loop() { }

Gruß Tommy

Jurs,

Nach diesem Morgen mit herbert gesprochen, ich, dass du 'erklärte, wo die Haupt Hilfe bei diesem Projekt wieder in seiner Tage erhalten haben, so bin gefragt, ob Sie wieder helfen kann, um das Projekt zu erweitern, habe ich natürlich den Code in # 19 lesen auf dem Original der Link aber wie mit dem Projekt das Original ist dieser große nur eine LED auf der einen Stift zu flackern, aber was ich tun will und kann nicht scheinen, zum Laufen zu bringen ist Flimmern 3 zufällig Pins, können sagen, grün, rot und weiß auf drei Pins zu zufälligen Zeiten und zufällige Helligkeit, um zu simulieren, lässt das Flackern eines Films auf einem Farb-TV sagen.
Deinnkening alle im Voraus wieder dort mit diesem Projekt Hilfe.

Sorry, aber Nachdem ich merke, nur den Code von Agmue geschrieben gesehen, dass Sie bereits esta Code Farb-TV Era genommen haben, hier hast du es für Arduino ein Ich glaube, ich frage mich, wenn Sie denken, es wäre möglich, den Code zu Incorporate Gegeben von Tommy56 die drei PWM-Pins auf dem ATtiny85 zu bekommen oder denken Sie, es leichter sein wird, dass ein Schieberegister mit

natürlich Obwohl dieser Beitrag Jurs als Hauptprogrammierer von esta Code angesprochen wird, wenn jemand Zusammen mit Herbie sonst irgendwelche Gedanken haben wird mehr als erfreut, sie zu hören.

Hallo, wenn möglich, würde ich lieber zusätzlich Deinen originalen englischen Text lesen, der Übersetzer liefert nur eine mäßig gute Qualität.

ocnalops:
... obwohl ich offen für ideen bin ...

Ich habe mit ATtiny45/85/4313 angefangen, der UNO diente nur zum Programmieren der ATtinys.

Leider sind die ATtinys zumindest in D zu teuer geworden. Daher nutze ich jetzt die mit 1,79€ preiswerteren ProMinis. Zum Programmieren nutze ich ein CP2102 Modul. Die Programmierung geht wie beim UNO und Du hast keine Probleme mit zuwenig PWM-Ausgängen.

Anstelle der Schieberegister nutze ich jetzt MCP23017 mit der Bibliothek Adafruit-MCP23017.

Noch zum ATtiny45/85: Bei drei PWM bleiben nur zwei Pins übrig, ein Schieberegister benötigt aber auch drei.

So flimmert es auch auf dem ATtiny an drei Pins:

/*  Simulation "belebtes Haus für die Modellbahn" by jurs */
/*  Version "Flimmern nur wenn die Pin-13 LED an ist */
/*  getestet mit ATtiny85 */
volatile uint8_t* Port[] = {&OCR0A, &OCR0B, &OCR1B};
const byte pwmFlimmerPin[] = {0, 1, 4};  // PWM Pin für das "analoge" Flimmern
uint32_t flimmerStart, flimmerEnd;        // Anfangs- und Endzeiten für das Flimmern
const byte leds[] = {2, 3};   // LED Pins für das normale Blinken deklarieren
const uint32_t ledtakt[] = {9000, 2200};  // LED Blinktakt in Millisekunden für diese Pins
uint32_t ledtime[sizeof(leds)];   // Variablen zum Merken von millis()-Zeiten beim Schalten/Blinken

void setup() {
  //  Serial.begin(9600);
  for (byte i = 0; i < sizeof(pwmFlimmerPin); i++) {
    pinMode (pwmFlimmerPin[i], OUTPUT);
  }
  for (byte i = 0; i < sizeof(leds); i++) {
    pinMode (leds[i], OUTPUT);
  }
  // Configure counter/timer0 for fast PWM on PB0 and PB1
  TCCR0A = 3 << COM0A0 | 3 << COM0B0 | 3 << WGM00;
  TCCR0B = 0 << WGM02 | 3 << CS00; // Optional; already set
  // Configure counter/timer1 for fast PWM on PB4
  GTCCR = 1 << PWM1B | 3 << COM1B0;
  TCCR1 = 3 << COM1A0 | 7 << CS10;
}

void blinkenImTakt() {

  // Alle gleichmäßig blinkenden LEDs in ihrem eigenen Takt blinken lassen
  for (byte i = 0; i < sizeof(leds); i++) // alle LEDs in einer Schleife durchgehen
  {
    if (millis() - ledtime[i] >= ledtakt[i]) // Takt für diese LED abgelaufen?
    {
      ledtime[i] = millis();
      digitalWrite(leds[i], !digitalRead(leds[i])); // wenn ja ==> Umschalten
      if (leds[i] == leds[0] && digitalRead(leds[i])) // Pin-0 LED wurde gerade eingeschaltet
      {
        flimmerStart = millis() + 2000; // Anfangszeit für das Flimmern setzen
        flimmerEnd = millis() + 8000; // Endzeit für das Flimmern setzen
      }
      //      Serial.print("Pin ");Serial.print(leds[i]);Serial.print(" = ");Serial.println(digitalRead(leds[i]));
    }
  }
}

void flimmernPwmPins() {
  // Die flimmernde LED im Zufallsmodus flimmern lassen
  static uint32_t alterWert[sizeof(pwmFlimmerPin)];
  static uint32_t flimmerDauer[sizeof(pwmFlimmerPin)] = {200, 200, 200};
  static byte flimmerHelligkeit[sizeof(pwmFlimmerPin)];
  for (byte i = 0; i < sizeof(pwmFlimmerPin); i++) {
    if (millis() - alterWert[i] >= flimmerDauer[i]) // Takt abgelaufen?
    {
      alterWert[i] = millis();
      flimmerDauer[i] = 1 + random(200); // neue Flimmerdauer als Zufallswert
      if (millis() > flimmerStart && millis() < flimmerEnd)
        flimmerHelligkeit[i] = random(256); // neue Flimmerhelligkeit als Zufallswert
      else
        flimmerHelligkeit[i] = 0; // Flimmern aus wenn falsche Zeit zum Flimmern
      *Port[i] = 255 - flimmerHelligkeit[i];
    }
  }
}

void loop() {
  blinkenImTakt();
  flimmernPwmPins();
}

Hallo Wieder Agmue natürlich traurig über das, das ist das Problem mit dem Google Übersetzer, dass es manchmal eine Art Chaos macht Hier finden Sie den Originaltext.

Jurs,

After Having talked this morning to Herbert, He explained to me that you where the main help he recieved back in the days that this project was concived, so I am asking if you can help again to enhance the project, I naturally have Read the Code in # 19 on the original link but as with the project the original this is great just to get one LED on one pin to flicker, but what I want to do and can not seem to get to work is flicker 3 Leds at random on three pins, Lets say green, red and white on three pins at random times and random brightness to simulate, lets Imagine the flicker of a movie on a color TV.
Again Thanking all in advance for there help with this project.

Sorry, I Have Just noticed the post with code written by Agmue and I Think that you've already taken this code to the color TV Era, here you have it for Arduino I think.? ,I wonder if you think it would be possible to get the code Given by Tommy56 incorporated so as to get the the three PWM pins on the ATtiny85 or do you think it will be easier to do it with a shift register.

Of course Although this post is addressed to Jurs as one of the main programmers of this code together with Herbie, of course anyone else with ideas I Will be more than pleased to hear from them.

soweit der Preis des ATtiny betroffen ist, kann ich immer noch zu einem guten Preis kaufen und ich kann natürlich auch weiterhin programing mit meinem Arduino Uno und nicht eine andere programer wie für eine Verschiebung kaufen müssen sich registrieren möchte ich die 74HC595 zu verwenden, wie beschrieben in der Link ..

Nochmals vielen Dank für all Ihre Hilfe

Jetzt in Inglés im Fall der Google-Übersetzer wieder Macht ein Durcheinander von Dingen.

Hi Again Agmue of course sorry about that, that is the problem with the google translater it sometimes makes that sort of mess please find here the original text.

Jurs,

After Having talked this morning to Herbert, He explained to me that you where the main help he recieved back in the days that this project was concived, so I am asking if you can help again to enhance the project, I naturally have Read the Code in # 19 on the original link but as with the project the original this is great just to get one LED on one pin to flicker, but what I want to do and can not seem to get to work is flicker 3 Leds at random on three pins, Lets say green, red and white on three pins at random times and random brightness to simulate, lets Imagine the flicker of a movie on a color TV.
Again Thanking all in advance for there help with this project.

Sorry, I Have Just noticed the post with code written by Agmue and I Think that you've already taken this code to the color TV Era, here you have it for Arduino I think.? ,I wonder if you think it would be possible to get the code Given by Tommy56 incorporated so as to get the the three PWM pins on the ATtiny85 or do you think it will be easier to do it with a shift register.

Of course Although this post is addressed to Jurs as one of the main programmers of this code together with Herbie, of course anyone else with ideas I Will be more than pleased to hear from them.

As far as the price of the attiny is concerned I can still buy at a good price and I can of course continue programing with my arduino uno and dont have to buy another programer as for a shift register I wish to use the 74HC595 as described in the link..

again thanks for all of your help.

Hallo wieder Agmue,

hat, so kommen gerade vom Mittagessen kann ich sehen, dass Sie sehr beschäftigt gewesen sein 'und habe den Code geschrieben, um das Flackern Effekt auf 3 Pins auf dem atttiny45 erhalten / 85 tommy56 Code Einbindung, esta verlassen normalen 2 Pins frei für die Ein / aus-Lichter, heute Abend werde ich diesen Code oben bekommen definatley und läuft auf meinem breadborad, so dass nun für die nächste Hürde wäre es möglich, die Verschiebung zu integrieren, um die Schaltung zu registrieren 74CH595 die Standard-Ein- / aus-Lichter zu erweitern oder wäre es besser in einem 2 ATtiny setzen nur die Lichter überprüfen und das andere lassen sie einfach den Fernseher zu überprüfen, in dem Fall, dass es möglich ist, bis zu wie viele Lichter, die wir mit ATtiny85 eins und eins 74CH595 steuern kann ..?

Ich danke Ihnen natürlich wieder für Ihre wertvolle Hilfe.

Jetzt in Inglés im Fall der Google-Übersetzer wieder Macht ein Durcheinander von Dingen.

Hi again Agmue,

So having just got back from lunch I can see that you have been very busy and have posted the code to get the flickering effect on 3 pins on the atttiny45/85 incorporating tommy56's code, this leaving 2 pins free for the normal on/off lights, tonight I will definatley get this code up and running on my breadborad, so now for the next hurdle would it be possible to incorporate the shift register 74CH595 to the circuit to expand the normal on/off lights or would it be better to put in a 2 attiny just to control the lights and leave the other one just to control the TV, in the case that it is possible up to how many lights can we control with one attiny85 and one 74CH595..?

Of course again thanking you for your precious help.

Now in english in case the google translater again makes a mess of things.

Möglicherweise reicht es ja, das Fernsehen ohne PWM Flackern zu lassen, das geht auch mit Schiftregister ganz flott:

/*  Simulation "belebtes Haus für die Modellbahn" by jurs */
/*  Version "Flimmern nur wenn die Pin-3 LED an ist */
/*  getestet mit ATtiny85 */
// ATMEL ATTINY85 / ARDUINO
//
//                  +-\/-+
// Ain0 (D 5) PB5  1|    |8  Vcc
// Ain3 (D 3) PB3  2|    |7  PB2 (D 2)  Ain1
// Ain2 (D 4) PB4  3|    |6  PB1 (D 1) pwm1
//            GND  4|    |5  PB0 (D 0) pwm0
//                  +----+

unsigned int dataPin = 0;   // Pin D0 verbunden mit DS von 74HC595 Pin14 SI
unsigned int clockPin = 1;  // Pin D1 verbunden mit SH_CP von 74HC595 Pin11 SCK
unsigned int latchPin = 2;  // Pin D2 verbunden mit ST_CP von 74HC595 Pin12 RCK

const byte pwmFlimmerPins[] = {0, 1, 2}; // PWM Pin für das "analoge" Flimmern
uint32_t flimmerStart, flimmerEnd;      // Anfangs- und Endzeiten für das Flimmern
const byte leds[] = {3, 4, 5, 6, 7};    // LED Pins für das normale Blinken deklarieren
const uint32_t ledtakt[] = {9000, 1500, 2200, 3333, 5000};  // LED Blinktakt in Millisekunden für diese Pins
uint32_t ledtime[sizeof(leds)];   // Variablen zum Merken von millis()-Zeiten beim Schalten/Blinken
byte muster;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}

void blinkenImTakt() {
  // Alle gleichmäßig blinkenden LEDs in ihrem eigenen Takt blinken lassen
  for (byte i = 0; i < sizeof(leds); i++) // alle LEDs in einer Schleife durchgehen
  {
    if (millis() - ledtime[i] >= ledtakt[i]) // Takt für diese LED abgelaufen?
    {
      ledtime[i] = millis();
      digitalWrite(leds[i], !digitalRead(leds[i])); // wenn ja ==> Umschalten
      if (bitRead(muster, leds[i])) {
        bitWrite(muster, leds[i], LOW);
      } else {
        bitWrite(muster, leds[i], HIGH);
      }
      if (leds[i] == leds[0] && bitRead(muster, leds[i])) // Pin-0 LED wurde gerade eingeschaltet
      {
        flimmerStart = millis() + 2000; // Anfangszeit für das Flimmern setzen
        flimmerEnd = millis() + 8000; // Endzeit für das Flimmern setzen
      }
    }
  }
}

void flimmernPwmPins() {
  // Die flimmernde LED im Zufallsmodus flimmern lassen
  static uint32_t alterWert[sizeof(pwmFlimmerPins)];
  static uint32_t flimmerDauer[sizeof(pwmFlimmerPins)] = {21, 11, 7};
  static byte flimmerHelligkeit[sizeof(pwmFlimmerPins)];
  for (byte i = 0; i < sizeof(pwmFlimmerPins); i++) {
    if (millis() - alterWert[i] >= flimmerDauer[i]) // Takt abgelaufen?
    {
      alterWert[i] = millis();
      flimmerDauer[i] = 1 + random(100); // neue Flimmerdauer als Zufallswert
      if (millis() > flimmerStart && millis() < flimmerEnd)
        flimmerHelligkeit[i] = random(256); // neue Flimmerhelligkeit als Zufallswert
      else
        flimmerHelligkeit[i] = 0; // Flimmern aus wenn falsche Zeit zum Flimmern
      bitWrite(muster, pwmFlimmerPins[i], flimmerHelligkeit[i] > 127);
    }
  }
}

void updateShiftRegister(byte bitfolge)
{
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, LSBFIRST, bitfolge);
  digitalWrite(latchPin, HIGH);
}

void loop() {
  blinkenImTakt();
  flimmernPwmPins();
  updateShiftRegister(muster);
}

Hallo wieder Agmue,

Wow, das ist erstaunlich, nur eine weitere Fragen mit dem Schieberegister , wie viele Lichter kann ich jederzeit überprüfen, mit einem ATtiny85 und ein 74CH595 Schieberegister natürlich zählen, die wir verwenden drei Stifte für die TV-Flicker und lastley but not least, können Sie bitte erklären, wie Sie das Schieberegister zu den ATtiny85 auf dem Steckbrett verdrahtet.

Ich danke Ihnen natürlich wieder für Ihre wertvolle Hilfe.

Jetzt in Inglés im Fall der Google-Übersetzer wieder Macht ein Durcheinander von Dingen.

Hi again Agmue,

Wow that is amazing just one more questions using the shift register how many lights can I control at any time with one attiny85 and one 74CH595 Shift register of course counting that we use three pins for the TV Flicker and lastley but not least can you please explain how you wired the shift register to the attiny85 on the Breadboard.

Of course again thanking you for your precious help.

Now in english in case the google translater again makes a mess of things.

hi ocnalops,
wenn du die 74HCT595 nutzt kannst du pro Pin maximal 20mA nutzten aber am gesamten Register maximal in Summe 70mA d.h. wenn alle Gleichzeit an sind also maximal 10mA pro Pin. Daten sind aus einem NXP Datenblatt.
Also man muss da ein bisschen drauf auchten. Man könnte mehrere LED in reihe Schalten.
Gruß
DerDani

ocnalops:
... können Sie bitte erklären, wie Sie das Schieberegister zu den ATtiny85 auf dem Steckbrett verdrahtet.

Ich habe Deinen Adafruit-Link aus #8 genommen. Die Änderungen gegenüber dem UNO sind am Anfang vom Sketch beschrieben.

ocnalops:
... wie viele Lichter ...

Zwei am ATtiny45/85, acht am Schieberegister. Du kannst aber mehrere Schieberegister in Reihe schalten.

Alternativen wären auch WS2812 und APA102. Neun WS2812 am ATtiny85 habe ich erfolgreich getestet.

Jetzt habe ich doch noch etwas PWM in 10 Schritten eingebaut:

/*  Simulation "belebtes Haus für die Modellbahn" by jurs */
/*  Version "Flimmern nur wenn die Pin-3 LED an ist */
/*  getestet mit ATtiny85 */
// ATMEL ATTINY85 / ARDUINO
//
//                  +-\/-+
// Ain0 (D 5) PB5  1|    |8  Vcc
// Ain3 (D 3) PB3  2|    |7  PB2 (D 2)  Ain1
// Ain2 (D 4) PB4  3|    |6  PB1 (D 1) pwm1
//            GND  4|    |5  PB0 (D 0) pwm0
//                  +----+

unsigned int dataPin = 0;   // Pin D0 verbunden mit DS von 74HC595 Pin14 SI
unsigned int clockPin = 1;  // Pin D1 verbunden mit SH_CP von 74HC595 Pin11 SCK
unsigned int latchPin = 2;  // Pin D2 verbunden mit ST_CP von 74HC595 Pin12 RCK

const byte pwmFlimmerPins[] = {0, 1, 2}; // PWM Pin für das "analoge" Flimmern
uint32_t flimmerStart, flimmerEnd;      // Anfangs- und Endzeiten für das Flimmern
const uint32_t flimmerZeit = 10;        // PWM-Zeit in ms
const byte leds[] = {3, 4, 5, 6, 7};    // LED Pins für das normale Blinken deklarieren
const uint32_t ledtakt[] = {9000, 1500, 2200, 3333, 5000};  // LED Blinktakt in Millisekunden für diese Pins
uint32_t ledtime[sizeof(leds)];   // Variablen zum Merken von millis()-Zeiten beim Schalten/Blinken
byte muster;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}

void blinkenImTakt() {
  // Alle gleichmäßig blinkenden LEDs in ihrem eigenen Takt blinken lassen
  for (byte i = 0; i < sizeof(leds); i++) // alle LEDs in einer Schleife durchgehen
  {
    if (millis() - ledtime[i] >= ledtakt[i]) // Takt für diese LED abgelaufen?
    {
      ledtime[i] = millis();
      digitalWrite(leds[i], !digitalRead(leds[i])); // wenn ja ==> Umschalten
      if (bitRead(muster, leds[i])) {
        bitWrite(muster, leds[i], LOW);
      } else {
        bitWrite(muster, leds[i], HIGH);
      }
      if (leds[i] == leds[0] && bitRead(muster, leds[i])) // Pin-0 LED wurde gerade eingeschaltet
      {
        flimmerStart = millis() + 2000; // Anfangszeit für das Flimmern setzen
        flimmerEnd = millis() + 8000; // Endzeit für das Flimmern setzen
      }
    }
  }
}

void flimmernPwmPins() {
  // Die flimmernde LED im Zufallsmodus flimmern lassen
  static uint32_t alterWert[sizeof(pwmFlimmerPins)];
  static uint32_t flimmerDauer[sizeof(pwmFlimmerPins)] = {5, 5, 5};
  static uint32_t fS[sizeof(pwmFlimmerPins)];
  static byte flimmerHelligkeit[sizeof(pwmFlimmerPins)];
  for (byte i = 0; i < sizeof(pwmFlimmerPins); i++) {
    if (millis() - alterWert[i] >= flimmerDauer[i]) // Takt abgelaufen?
    {
      alterWert[i] = millis();
      flimmerDauer[i] = 1 + random(100); // neue Flimmerdauer als Zufallswert
      if (millis() > flimmerStart && millis() < flimmerEnd)
        flimmerHelligkeit[i] = random(flimmerZeit); // neue Flimmerhelligkeit als Zufallswert
      else
        flimmerHelligkeit[i] = 0; // Flimmern aus wenn falsche Zeit zum Flimmern
    }
    if (flimmerHelligkeit[i]) {
      if (millis() - fS[i] >= flimmerHelligkeit[i]) {
        bitWrite(muster, pwmFlimmerPins[i], HIGH);
      } else {
        bitWrite(muster, pwmFlimmerPins[i], LOW);
      }
      if (millis() - fS[i] >= flimmerZeit) {
        fS[i] = millis();
      }
    } else {
      bitWrite(muster, pwmFlimmerPins[i], LOW);
      fS[i] = millis();
    }
  }
}

void updateShiftRegister(byte bitfolge)
{
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, LSBFIRST, bitfolge);
  digitalWrite(latchPin, HIGH);
}

void loop() {
  blinkenImTakt();
  flimmernPwmPins();
  updateShiftRegister(muster);
}

Agmue,

Ein tausend Dank für Ihre Hilfe, sah ich Ihren Beitrag, wenn Sie vor 2 Tagen, aber bin beschäftigt bei der Arbeit in diesen Tagen und bin versucht, Zeit zu finden, um die Schaltung zuerst auf meinem Brotbrett dann auf der attiny, werde ich zurück zu bekommen Sie, wenn ich alle korrekt arbeiten und wird wahrscheinlich fragen, für einige Auslegungen, was jede Zeile im Code tut, da ich nicht nur zu bauen und weggehen wollen, sondern auch von Ihnen lernen, die die Idee hinter diesem Foro scheint, natürlich, wenn Ich habe fertig mit dem Bau der Station werde ich certanley Post ein Video, so dass alle sehen können, es arbeitet in seinem Herbst Ruhm, nochmals danke für alle bis jetzt.

freundliche Grüße

Carlos

Nun wie üblich in Englisch nur für den Fall der Google Transalter macht ein Durcheinander von Dingen, die mehr als likley ist.

Agmue,

A Thousand thanks for your help, I saw your post when you posted 2 days ago but am busy at work these days and am trying to find time to set up the circuit first on my bread board then on the attiny, I will get back to you when I have all working correctley and will probably ask for some explications as to what every line in the code does, as I dont only want to build and runaway, but also learn from you which seems the idea behind this foro, of course when I have finished building the station I will certanley post a video so that all can see it working in its fall glory, again thanks for all untill now.

best regards

Carlos

Now as usual in english just in case the google transalter makes a mess of things which is more than likley.

Nur keine Eile :slight_smile: