Snowfall20 - Programm-Code Analyse zwecks Erweiterung

[frank2000]

Hallo

bin neu hier und auch relativ Anfänger in Sachen Arduino und dessen Programmierung. Mit C++ habe ich bisher noch nicht gearbeitet.
Elektronik-Kenntnisse sind vorhanden. Kenntnisse in programieren (Pascal, Basic (auch VB), ASM) auch.

Jetzt habe ich aber dennoch ein Problem:
Und zwar habe ich mir die Schaltung Snowfall20 (12 LED Charlieplexed Snowfall with AtTiny85) auf einem Steckbrett aufgebaut den ATtiny über das Arduino uno als ISP mit dem entsprechendem Code versehen - und funktioniert auch.
Allerdings ist mein Englisch nicht gerade berauschend, so daß ich in dem Thread wo es um dieses Projekt geht (auf der Arduino.cc-Seite) nicht so richtig mitkomme, da in englisch gehalten.
Da eben meine C++ kenntisse auch noch nicht die Welt sind, benötige ich etwas Hilfe:

Zum einem versteh ich "noch" nicht, wie der LED-Dimmeffekt programmtechnisch und an welcher stelle im Code realisiert ist.
und zum Zweiten. möchte ich gern die Matrix um 10 LED's erweitern, d.h. einen ATtiny 44 einsetzen wegen mehr I/O-Pins (für dann 30 LEDs werden 6 Pins benötigt), d.h. das Programm muß modifiziert werden, aber ich weiß noch nicht wie und wo.

Ich weiß nicht, ob ich den Programm-Code hier posten darf, deswegen habe ich jetzt nur mal angedeutet, wo die Idee her ist.

Grüße
Frank

[rkuehle]

Hallo Frank,

willkommen im Forum.
Ich würde sagen:Code einstellen ist immer gut. Wir haben ja bestimmt alle was davon. Aber bitte den Code mit dem "#" Symbol einfügen, sonst wird der Post so lang.

Grüße Ricardo

[frank2000]

Hallo Ricardo

ok
Hier mal der Source-Code:

Code:

#include <Entropy.h>
/*
Charlieplexing 20 LEDs using 5 ATTiny85 pins with fading by
varying the duty cycle of each LED in the 'tail'.

ATTiny85 connections
Leg  Function
1    Reset, no connection
2    D3 GREEN
3    D4 ORANGE
4    GND
5    D0 WHITE
6    D1 BLUE
7    D2 YELLOW
8    +5V

Tested on ATTiny85 running at 8MHz.
*/

// each block of 4 LEDs in the array is groupled by a common anode (+, long leg)
// for simplicity of wiring on breadboard, using a colour code

#define GREEN 0
#define ORANGE 1
#define WHITE 2
#define BLUE 3
#define YELLOW 4

// pin definitions {GREEN, ORANGE, WHITE, BLUE, YELLOW}

const int charliePin[5] = {
  3, 4, 0, 1, 2};

// Charlieplexed LED definitions (current flowing from-to pairs)

const int LED[20][2] = {
  {ORANGE, GREEN},                            // 0 (GREEN GROUP)
  {WHITE, GREEN},                             // 1
  {BLUE, GREEN},                              // 2
  {YELLOW, GREEN},                            // 3
  {GREEN, ORANGE},                            // 4 (ORANGE GROUP)
  {WHITE, ORANGE},                            // 5
  {BLUE, ORANGE},                             // 6
  {YELLOW, ORANGE},                           // 7
  {GREEN, WHITE},                             // 8 (WHITE GROUP)
  {ORANGE, WHITE},                            // 9
  {BLUE, WHITE},                              // 10
  {YELLOW, WHITE},                            // 11
  {GREEN, BLUE},                              // 12 (BLUE GROUP)
  {ORANGE, BLUE},                             // 13
  {WHITE, BLUE},                              // 14
  {YELLOW, BLUE},                             // 15
  {GREEN, YELLOW},                            // 16 (YELLOW GROUP)
  {ORANGE, YELLOW},                           // 17
  {WHITE, YELLOW},                            // 18
  {BLUE, YELLOW}                              // 19
};

// other

int current = 0;                              // LED in array with current focus
int previous = 0;                             // previous LED that was lit

void setup() {

  Entropy.Initialize();
  randomSeed(Entropy.random());
}

void loop() {
  unsigned long loopCount = 0;                          // used to determine duty cycle of each LED
  unsigned long timeNow = millis();                     //
  unsigned long displayTime = 90;                       // milliseconds to spend at each focus LED in descent
  while(millis()- timeNow < (displayTime)) {  // animation slows toward end
    loopCount++;

    // the "snowflake" gets full duty cycle.  When it gets to the end, hold it at the end until the tail collapses

    if (current > 19) charlieON(19);
    else charlieON(current);

    // each member of tail has reduced duty cycle, and never get to the final position

    if(!(loopCount % 3)) if(current-1 >=0 && current-1 < 19) charlieON(current-1);
    if(!(loopCount % 6)) if(current-2 >=0 && current-2 < 19) charlieON(current-2);
    if(!(loopCount % 9)) if(current-3 >=0 && current-3 < 19) charlieON(current-3);
    if(!(loopCount % 12)) if(current-4 >=0 && current-4 < 19) charlieON(current-4);
  }

  current++;

  if(current==23) {                          // start over

    // now fade out the snowflake in that final position #19

    for(int dutyCycle = 3; dutyCycle <= 15; dutyCycle += 3) {
      loopCount = 0;
      timeNow = millis();
      while(millis() - timeNow < (displayTime+current*2)) { // fade out as slow as animation has achieved by now
        loopCount++;
        if(!(loopCount % dutyCycle)) charlieON(19);
        else charlieOFF(19);
      }
    }
    current = 0;
    charlieOFF(19);                          // turn off the remaining (possibly) lit LED
    delay(100 + random(3000));               // and then rinse, repeat...after a short pause
  }
}

// --------------------------------------------------------------------------------
// turns on LED #thisLED.  Turns off all LEDs if the value passed is out of range

void charlieON(int thisLED) {

  // turn off previous (reduces overhead, only switch 2 pins rather than 5)

  digitalWrite(charliePin[LED[previous][1]], LOW);   // ensure internal pull-ups aren't engaged on INPUT mode
  pinMode(charliePin[LED[previous][0]], INPUT);
  pinMode(charliePin[LED[previous][1]], INPUT);

  // turn on the one that's in focus

  if(thisLED >= 0 && thisLED <= 19) {
    pinMode(charliePin[LED[thisLED][0]], OUTPUT);
    pinMode(charliePin[LED[thisLED][1]], OUTPUT);
    digitalWrite(charliePin[LED[thisLED][0]], LOW);
    digitalWrite(charliePin[LED[thisLED][1]], HIGH);
  }
  previous = thisLED;
}

// --------------------------------------------------------------------------------
// turns off LED #thisLED.  

void charlieOFF(int thisLED) {
  digitalWrite(charliePin[LED[thisLED][1]], LOW);   // ensure internal pull-ups aren't engaged on INPUT mode
  pinMode(charliePin[LED[thisLED][0]], INPUT);
  pinMode(charliePin[LED[thisLED][1]], INPUT);
}

dazu jetzt noch ein Video, damit man erkennt, worum es hier geht:





dort ist zu sehen: 2 Varianten des Snowfall-Effekts. Einmal mehr oder weniger diskret (2x4017, 1xNE556, div. R,C und D)
und einmal mit einem µC (ATtiny45) und 5xR
Die zweite Variante hat mich davon überzeugt mich doch noch mit µC zu beschäftigen.
Hatte nämlich bisher mit der ersten Variante das Problem, wie bekomme ich den ganzen Kram in ein Tube und das dann zum Schluß 10 mal (10 Tubes wollte ich bauen). Ist zwar machbar (SMD) aber doch recht aufwändig zu routen. Mit dem µC ist das aber nun kein Problem mehr. Aber jetzt will ich mehr ..... mehr LED's für längere Tubes (50cm).
Das was es zu kaufen gibt, taugt entweder nichts (lauflichteffekt oder nur 4 Schritte) oder ist sau teuer und dann eben doch bloß "gekauft"

Grüße
Frank

[rkuehle]

Hallo Frank,

im Code werden 4 Gruppen a 5 Leds benutzt. Wie möchtest du die 10 zusätzlichen LEDs benutzen. Zwei neue Gruppen, oder eher 8 LEDs umd die vorhandenen Gruppen jeweils um zwei Leds zu erweitern?
Da der Code stark mit Variablen arbeitet deren Namen sich aus den Farben ableiten, wäre es auch gut zu wissen welche Farben du noch zutun möchtest.
Welche Pins kann man denn am ATtiny 44 zusätzlich benutzen wenn neue Gruppen aufgemacht werden sollen?

Grüße Ricardo

[frank2000]

naja, im Prinzip ist der Aufbau ja so:



sprich: es handelt sich um eine Matrix. (Oh, ich sehe gerade, die R sind an der falschen Seite der LED's, aber ist auch egal bei Reihenschaltung). Das ganze soll um die gestrichelt gezeichnetten Verbindungen erweitert werden. Bisher waren es 5 Zeilen und 5 Spalten. Nun soll jeweils noch eine Zeile und eine Spalte dazu kommen, so daß zum Schluß 30 statt bisher 20 LED's angesteuert werden können (dh. 10 LED's mehr). Dazu wird ein zusätzlicher I/O-Pin benötigt, das ist dann der Pin "6"

Die Gleichung dazu: NLED=NPin * (Npin-1) -> 30 = 6 * (6-1)

Farben sind eigentlich unerheblich, weil nur zur Orientierung gedacht und dann eben auch als Variablen-Namen benutzt.

Der ATtiny45 hat 5 I/O-Pins, da geht kein 6. Pin, während der ATtiny44 10 I/O-Pins hat. Würde bedeuten: rein theoretisch währen damit 90 LED's anzusteuern. Aber ich will's ja mal nicht übertreiben und beschränke mich auf 30.

Aber ich glaube, ich habe jetzt mittlerweile eine blasse Ahnung, wie ich das modifizieren kann, zumindest erstmal den Definitionsteil:

Code:

#define GREEN 0
#define ORANGE 1
#define WHITE 2
#define BLUE 3
#define YELLOW 4
#define FARBE 5

// pin definitions {GREEN, ORANGE, WHITE, BLUE, YELLOW, FARBE}

const int charliePin[6] = {
  3, 7, 0, 1, 2, 8};

// Charlieplexed LED definitions (current flowing from-to pairs)

const int LED[30][2] = {
  {ORANGE, GREEN},                            // 0 (GREEN GROUP)
  {WHITE, GREEN},                             // 1
  {BLUE, GREEN},                              // 2
  {YELLOW, GREEN},                            // 3
  {FARBE, GREEN}                              // 4
  {GREEN, ORANGE},                            // 5 (ORANGE GROUP)
  {WHITE, ORANGE},                            // 6
  {BLUE, ORANGE},                             // 7
  {YELLOW, ORANGE},                           // 8
  {FARBE, ORANGE}                             // 9
  {GREEN, WHITE},                             // 10 (WHITE GROUP)
  {ORANGE, WHITE},                            // 11
  {BLUE, WHITE},                              // 12
  {YELLOW, WHITE},                            // 13
  {FARBE, WHITE}                              // 14
  {GREEN, BLUE},                              // 15 (BLUE GROUP)
  {ORANGE, BLUE},                             // 16
  {WHITE, BLUE},                              // 17
  {YELLOW, BLUE},                             // 18
  {FARBE, BLUE}                                // 19
  {GREEN, YELLOW},                            // 20 (YELLOW GROUP)
  {ORANGE, YELLOW},                           // 21
  {WHITE, YELLOW},                            // 22
  {BLUE, YELLOW}                              // 23
  {FARBE, YELLOW}                           // 24
  {GREEN, FARBE}                             // 25 (FARBE GROUP)
  {ORANGE, FARBE}                          // 26
  {WHITE, FARBE}                            // 27
  {BLUE, FARBE}                               // 28
  {YELLOW, FARBE}                         // 29

};

wo ich jetzt noch ein Problem mit habe ist der Part mit den Modulo Operationen:

Code:

// each member of tail has reduced duty cycle, and never get to the final position

    if(!(loopCount % 3)) if(current-1 >=0 && current-1 < 19) charlieON(current-1);
    if(!(loopCount % 6)) if(current-2 >=0 && current-2 < 19) charlieON(current-2);
    if(!(loopCount % 9)) if(current-3 >=0 && current-3 < 19) charlieON(current-3);
    if(!(loopCount % 12)) if(current-4 >=0 && current-4 < 19) charlieON(current-4);

Das kapier ich nicht ganz: wieso ist der Teiler "3" und ein Vielfaches davon?

[frank2000]

Also hab's jetzt selbst hinbekommen. Habe aber festgestellt, daß die Library Entrophy.h mit dem ATtiny44 nicht funktioniert. Führt bei diesem zu massiven Fehlfunktionen. Liegt aber wohl am zu kleinem RAM, hab ich mir jetzt sagen lassen

Grüße

[frank2000]

hier mal 10 Tubes 50cm mit 30 LED virtuell an einen Baum gehangen:




hier der Schaltplan:



und der code:

Code:

#define GREEN 0
#define ORANGE 1
#define WHITE 2
#define BLUE 3
#define YELLOW 4
#define BLACK 5

const byte charliePin[6] = {                                        // pin definitions {GREEN, ORANGE, WHITE, BLUE, YELLOW, BLACK}
  1, 2, 3, 7, 8, 9};

const byte LED[30][2] = {                                           // Charlieplexed LED definitions (current flowing from-to pairs)

  {ORANGE, GREEN},                                                  // 0 (GREEN GROUP)
  {WHITE, GREEN},                                                   // 1
  {BLUE, GREEN},                                                    // 2
  {YELLOW, GREEN},                                                  // 3
  {BLACK, GREEN},                                                   // 4
  {GREEN, ORANGE},                                                  // 5 (ORANGE GROUP)
  {WHITE, ORANGE},                                                  // 6
  {BLUE, ORANGE},                                                   // 7
  {YELLOW, ORANGE},                                                 // 8
  {BLACK, ORANGE},                                                  // 9
  {GREEN, WHITE},                                                   // 10 (WHITE GROUP)
  {ORANGE, WHITE},                                                  // 11
  {BLUE, WHITE},                                                    // 12
  {YELLOW, WHITE},                                                  // 13
  {BLACK, WHITE},                                                   // 14
  {GREEN, BLUE},                                                    // 15 (BLUE GROUP)
  {ORANGE, BLUE},                                                   // 16
  {WHITE, BLUE},                                                    // 17
  {YELLOW, BLUE},                                                   // 18
  {BLACK, BLUE},                                                    // 19
  {GREEN, YELLOW},                                                  // 20 (YELLOW GROUP)
  {ORANGE, YELLOW},                                                 // 21
  {WHITE, YELLOW},                                                  // 22
  {BLUE, YELLOW},                                                   // 23
  {BLACK, YELLOW},                                                  // 24
  {GREEN, BLACK},                                                   // 25 (BLACK GROUP)
  {ORANGE, BLACK},                                                  // 26
  {WHITE, BLACK},                                                   // 27
  {BLUE, BLACK},                                                    // 28
  {YELLOW, BLACK}                                                   // 29
};

byte current = 0;                                                   // LED in array with current focus
byte previous = 0;                                                  // previous LED that was lit
byte fallTime =0;                                                   // Snowfall speed

void setup() {
  randomSeed(analogRead(0));
}

void loop() {
  int loopCount = 0;                                                // used to determine duty cycle of each LED
  unsigned long timeNow = millis();                    
  int displayTime = fallTime;                                  // milliseconds to spend at each focus LED in descent
  while(millis()- timeNow < (displayTime+current)) {              // animation slows toward end
    loopCount++;
    if (current > 29) charlieON(29);
    else charlieON(current);
    if(!(loopCount % 4)) if(current-1 >=0 && current-1 < 29) charlieON(current-1);
    if(!(loopCount % 8)) if(current-2 >=0 && current-2 < 29) charlieON(current-2);
    if(!(loopCount % 12)) if(current-3 >=0 && current-3 < 29) charlieON(current-3);
    if(!(loopCount % 16)) if(current-4 >=0 && current-4 < 29) charlieON(current-4);
    if(!(loopCount % 20)) if(current-5 >=0 && current-5 < 29) charlieON(current-5);
  }
  current++;
  if(current==35) {
        for(int dutyCycle = 3; dutyCycle <= 15; dutyCycle += 3) {
      loopCount = 0;
      timeNow = millis();
      while(millis() - timeNow < (displayTime+current*2)) {         // fade out as slow as animation has achieved by now
        loopCount++;
        if(!(loopCount % dutyCycle)) charlieON(29);
        else charlieOFF(29);
      }
    }
    current = 0;
    charlieOFF(29);                                                 // turn off the remaining (possibly) lit LED
    delay(4000+random(5000));                                       // and then rinse, repeat...after a short pause
    fallTime = random(40);
    }
}
// --------------------------------------------------------------------------------
void charlieON(int thisLED) {                                       // turn off previous (reduces overhead, only switch 2 pins rather than 6)
    
  digitalWrite(charliePin[LED[previous][1]], LOW);                  // ensure internal pull-ups aren't engaged on INPUT mode
  pinMode(charliePin[LED[previous][0]], INPUT);
  pinMode(charliePin[LED[previous][1]], INPUT);
  
  if(thisLED >= 0 && thisLED <= 29) {                               // turn on the one that's in focus
  
    pinMode(charliePin[LED[thisLED][0]], OUTPUT);
    pinMode(charliePin[LED[thisLED][1]], OUTPUT);
    digitalWrite(charliePin[LED[thisLED][0]], LOW);
    digitalWrite(charliePin[LED[thisLED][1]], HIGH);
  }
  previous = thisLED;
}
// --------------------------------------------------------------------------------
void charlieOFF(int thisLED) {                                      // turns off LED #thisLED.

  digitalWrite(charliePin[LED[thisLED][1]], LOW);                   // ensure internal pull-ups aren't engaged on INPUT mode
  pinMode(charliePin[LED[thisLED][0]], INPUT);
  pinMode(charliePin[LED[thisLED][1]], INPUT);
}

habe, wie im code zu sehen, die normale random-funktion benutzt, die geht dann auch mit dem ATtiny44

[frank2000]

hier mal ein kurzes Video (6 tubes fertig):