LED- Funk- Dimmer - Feinschliff von Profis gesucht

Hallo in die Runde,

ich habe etliche LED-Lampen gebaut und nun einen Sketch geschrieben, der universell für alle Lampen verwendet werden soll.
Eh ich jetzt mit der Leiter von Lampe zu Lampe hangel, würde ich Euch gern mal drauf schauen lassen.

Mein Stärke sehe ich bei der Kreativität. Meine Schwäche ist ganz klar ein stark eingeschränkter “Wortschatz” in den Sprachen Arduino, C/C++ - ich gehe also davon aus dass einiges zu umständlich oder gar falsch geschrieben ist.

Zur Hardware:

  • Teensy LC
  • Fotowiderstand für Umgebungshelligkeit
  • PIR für Bewegung
  • IR für Fernbedienung
  • nrf24 für Funk
  • 2- RGB- Kanäle + 2 weiss- Kanäle (anpassbar)

Funktion (grob umschrieben)

  • 3 verschiedene Modi (“Automatik”- Programme)
    → autarker Automatikmodus, bei geringer Helligkeit und Bewegung wird das Licht aktiviert
    → manuelle Farbwahl (wird nach 30min auf autarken Automatikmodus gesetzt)
    → alle Vorgaben kommen über Funk von einer Zentrale- die Zentrale bekommt die wichtigsten Zustände der Lampe übermittelt

Dimmen

  • Das Dimme sieht etwas umständlich aus- hat aber den Hintergrund, dass ich die Zeit vorgeben möchte, die zum Überblenden benötigt wird- also egal ob von ganz hell zu ganz dunkel oder von einer Farbe zur nächsten- wenn ich sage, das soll 1 sec dauern, werden die Zwischenschritte so berechnet, dass das nach 1sec. erledigt ist. Eines der Ziele ist, dass auch bei unterschiedlichen Differenzen der einzelnen Farben der Wechsel synchron abläuft und der Farbverlauf fließend ist.
    Das Überblenden selbst soll Augen-gerecht erfolgen, in der Praxis paßt das auch richtig gut.
    Es sind minimal- Werte definierbar, bei denen die LEDs schon aus sind- steuert man RGB-Streifen via MOSfets kann man das in der Regel auf 0 setzen, Bei Power-LEDs hängt es von den verwendeten KSQ und LEDs ab- da ist bei Werten über 0 schon alles aus. Die Min-Werte sind so zu wählen, dass die entsprechende Farbe/LED sicher aus ist, aber mit nur wenig Abstand, das macht das Überblenden noch flüßiger.
    Mit einer IR- Fernbedienung kann man einzelne Farben wählen- die gelten erstmal für alle Kanäle, reduziert man innerhalb 2,5 sec die Auswahl der Kanäle werden die übrigen wieder auf die vorher in den “Zwischenspeicher” geschriebenen Werte zurückgesetzt und nur der eine Kanal bekommt die neue Farbe.
    Bestimmte Aktion, wie der Wechsel des Programm- Modes oder die Aktivierung der Einschlaffunktion (langsames ausblenden) wird für 0,5 sec durch aufleuchten der LEDs in einer definierten Farbe bestätigt.

Um das ganze nicht ewig lang zu machen, habe ich die Werte weitestgehend in Arrays gepackt und arbeite mit for-Schleifen oder memcpy…

Für die Übersichtlichkeit habe ich einzelne Blöcke in verschiedene Reiter verteilt- das ganz paßt so dann auich nicht mehr in Code-tags, daher hab ich ein zip angehangen.

OK, ich hoffe die Funktion ist soweit verständlich umrissen.

Um Voraus schon mal vielen Dank für die sicher guten Ideen und Tipps die kommen werden.

Kueche_Decke_02-2019.zip (7.57 KB)

Soll ich dann besser doch den Inhalt der einzelnen Reiter in Code-tags hier einfügen?

MaHa76: Soll ich dann besser doch den Inhalt der einzelnen Reiter in Code-tags hier einfügen?

Zumindest für die Mobilisten (Tablet-User) ist das besser.

puh, paßt nicht… es gibt eine Beschränkung auf 9000 Zeichen… da müßte ich alles auf gute 10 Posts verteilen :frowning:

MaHa76: puh, paßt nicht... es gibt eine Beschränkung auf 9000 Zeichen.... da müßte ich alles auf gute 10 Posts verteilen :-(

Die Beschränkung gilt doch nicht für einen Post. Du kannst es doch in verschieden Code-Blöcke aufteilen.

OK, hier der Hauptteil:

“Kuechenlampe.ino”

#include <EEPROM.h>
#include "IRremote.h"
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"
#include "Variablen.h"

#define RF24_MOSI 11
#define RF24_MISO 12
#define RF24_SCLK 14

RF24 radio(17, 18); // (CE, CSN)

byte RaumID = 4;
byte LampenID = 1;

const byte PirPin1 = 19;
const byte irRxPin = 16; 
const byte HellPin = 21;

const byte AnzahlLEDs = 8;

// Küche: rot1, gruen1, blau1, rot2, gruen2, blau2, weiss1, weiss2

unsigned int Speicher[AnzahlLEDs] = {0,1,2,3,4,5,6,7};
const byte LEDPIN[AnzahlLEDs] = {20,22,23,3,4,6,9,10}; 

int Wertist[AnzahlLEDs];
int Wertsoll[AnzahlLEDs];
int WertsollAlt[AnzahlLEDs];
int Wertstart[AnzahlLEDs];
int WertMax[AnzahlLEDs] = {4096,4096,4096,4096,4096,4096,4096,4096};
int WertMin[AnzahlLEDs] = {385,425,305,385,425,305,0,0};
int WertAusgabe[AnzahlLEDs];
int WertAusgabeAlt[AnzahlLEDs];

int ZwischenSpeicher[AnzahlLEDs];

float Intervall[AnzahlLEDs];
float fade[AnzahlLEDs];
float fadegesamt[AnzahlLEDs];
unsigned long lastfade[AnzahlLEDs];

int led = 13;

IRrecv irrecv(irRxPin);
decode_results results;

unsigned long AblaufAutomatikZeit = 120000;
unsigned long AblaufAutomatikweissZeit = 110000;
unsigned long SensorUpdateIntervall = 1200000;
unsigned long ZurueckAutomatikZeit = 1800000;

unsigned long Verzoegerung = 30000;

void setup()
{

  Sensor[0] = RaumID;
  Sensor[1] = LampenID;
  
  irrecv.enableIRIn();
  
  Serial.begin(9600);
  Serial.println("Kueche");
  
  for (int i = 0; i < AnzahlLEDs; i++ )
      { pinMode(LEDPIN[i],  OUTPUT); }
      
  pinMode(led, OUTPUT);  
  pinMode(PirPin1, INPUT);
  pinMode(HellPin, INPUT);
  
  for (int i = 0; i < AnzahlLEDs; i++ )
      { Wertsoll[i] = 16 * EEPROM.read(Speicher[i]); }
      
  analogWriteResolution(12); 
  
  for (int i = 0; i < AnzahlLEDs; i++ )
      { analogWriteFrequency(LEDPIN[i], 11718.75*2); }
      
  delay(10);
  
  //AblaufLicht = millis();    
  SPI.begin();                                    // Start the SPI buss
  SPI.setClockDivider( SPI_CLOCK_DIV8 );         // Set SPI clock to 4.5MHz, similar to 16M Arduino

  SPI.setSCK(14); 
  radio.begin();
  radio.openWritingPipe(addresses[0]);  
  radio.openReadingPipe(1,addresses[0]);

  radio.setRetries(15,15);        
  radio.setPALevel(RF24_PA_MAX);       
  radio.setDataRate(RF24_1MBPS); 
  radio.startListening(); 
  radio.printDetails();
}

void loop()
{
if (irrecv.decode(&results)) 
   {
     translateIR();
     irrecv.resume();
     IRProgramm();
     Serial.println(" Signal von IR empfangen ");
   }  
     
if ( ( IRStatus != 3 && IRStatus != 4 && IRStatus != 28 && IRStatus != 32 && IRStatus != 36 ) ) //&& Automatik != 0 )
   { AblaufAutomatikProg = millis(); Automatik = 0; }

if ( Tastehalten == 1 )
    { IRStatus = IRStatus; }
               
if ( millis() - AblaufAutomatikProg > ZurueckAutomatikZeit )
    { Automatik = 1; }

if ( memcmp(WertAusgabe,WertAusgabeAlt,AnzahlLEDs) != 0 )
    { 
      SendeTimer = millis();
      memcpy(WertAusgabeAlt,WertAusgabe,AnzahlLEDs);
    }  

if ( millis() - SendeTimer > SendeTimerZeit )    
    { Senden(); }
         
if (radio.available()) 
   {
      radio.read( &Status, sizeof(Status) );
      { Empfangen(); }
   }   
   

if ( Automatik != AutomatikAlt )
   { 
     if ( Automatik == 0 ) { Ablaufrot = millis(); } 
     if ( Automatik == 1 ) { Ablaufgruen = millis(); }
     if ( Automatik == 2 ) { Ablaufgelb = millis(); } 
   }
     AutomatikAlt = Automatik;   

BestaetigeAktionen();

if ( millis() - ZuordnungRGB1 < SpeicherZuordnungRGB1 )
    { 
      memcpy(Wertsoll+3,ZwischenSpeicher+3,7);
    }
    
if ( millis() - ZuordnungRGB2 < SpeicherZuordnungRGB2 )
    { 
      memcpy(Wertsoll,ZwischenSpeicher,3);
      memcpy(Wertsoll+6,ZwischenSpeicher+6,2);
    }
    
if ( millis() - ZuordnungWeiss1 < SpeicherZuordnungWeiss1 )
    { 
      memcpy(Wertsoll,ZwischenSpeicher,7);
    }  
    
if ( millis() - ZuordnungWeiss2 < SpeicherZuordnungWeiss2 )
    { 
      memcpy(Wertsoll,ZwischenSpeicher,6);
      Wertsoll[7] = ZwischenSpeicher[7];
    }  
   
if ( hellgesamtsoll != hellgesamtsollalt && hellgesamtsoll > 0.8 ) { Ablaufzuhell = millis(); }

if ( millis() - Ablaufzuhell > AblaufzuhellZeit )  { hellgesamtsoll = 0.75; }    

if ( millis() - UpdateSensor > 20 )
  { 
    UpdateSensor = millis();
    if ( HellTemp > HellAussen ) { HellAussen++ ; }
    if ( HellTemp < HellAussen ) { HellAussen-- ; } 
  }

if ( millis() - SensorUpdate > SensorUpdateIntervall ) 
   { Wertsoll[6] = 0; SensorUpdate = millis(); }

Bewegung1 = digitalRead(PirPin1);

if ( Wertist[6] < 10 && Wertist[7] < 10 ) { HellTemp = analogRead(HellPin); }
  
if ( Bewegung1 == 1 )
   { AblaufAutomatik = millis();
     AblaufAutomatikweiss = millis();
     
    if ( Automatik == 1 )  
       {
        if ( HellAussen <= 550 )
            { //Serial.println("an");
              for (int i = 0; i < AnzahlLEDs; i++ )
                  { Wertsoll[i] = 16 * EEPROM.read(Speicher[i]); }
              fade1in = 0.2;
              fadeweissin = 0.1;
              hellgesamtsoll = 0.8; 
              weissgesamtsoll = 1.0;
             //Serial.println("hell");
             } 
             
        if ( HellAussen <= 700 && HellAussen > 550)        
            {    
              for (int i = 0; i < AnzahlLEDs; i++ )
                  { Wertsoll[i] = 16 * EEPROM.read(Speicher[i]); }
              Wertsoll[6] = WertMax[6];
              Wertsoll[7] = WertMax[7];
              fade1in = 0.2;
              fadeweissin = 0.1;
              hellgesamtsoll = 0.8; 
              weissgesamtsoll = 1.0;
             //Serial.println("nicht so hell");
             }  
             
        if ( HellAussen <= 920 && HellAussen > 700)        
            {    
              for (int i = 0; i < AnzahlLEDs; i++ )
                  { Wertsoll[i] = 16 * EEPROM.read(Speicher[i]); }
              Wertsoll[6] = 0;
              Wertsoll[7] = 0;
              fade1in = 0.2;
              fadeweissin = 0.1;
              hellgesamtsoll = 0.8; 
              weissgesamtsoll = 1.0;
             //Serial.println("dunkler");
             } 
             
        if ( HellAussen > 920)        
            {    
              for (int i = 0; i < AnzahlLEDs; i++ )
                  { Wertsoll[i] = 0; }
              fade1in = 0.2;
              fadeweissin = 0.1;
              hellgesamtsoll = 0.8; 
              weissgesamtsoll = 1.0;
             //Serial.println("dunkel");
             } 
       }    
   }       
             
 if ( millis() - AblaufAutomatik > AblaufAutomatikZeit )
    {    
     for (int i = 0; i < AnzahlLEDs; i++ )
        { Wertsoll[i] = WertMin[i]/hellgesamtsoll; }
     fade1in = 0.5;
     }  
   
 if ( millis() - AblaufAutomatikweiss > AblaufAutomatikweissZeit )
    {
      Wertsoll[6] = 0;
      Wertsoll[7] = 0;// weissmin/weissgesamtsoll;
      fade1in = 0.9;
     }
     
if ( memcmp(Wertsoll,WertsollAlt,AnzahlLEDs) != 0 )
    { 
      memcpy( Wertstart,Wertist,AnzahlLEDs);
    }  
    memcpy(WertsollAlt,Wertsoll,AnzahlLEDs);
  
for (int i = 0; i < AnzahlLEDs; i++ )
     { 
      fadegesamt[i] = 1000000 * fade1in;
      fadegesamt[6] = 1 * fade1in;
      fadegesamt[7] = 1 * fade1in;
      Intervall[i] = ((WertMax[i] - Wertist[i]) * fadegesamt[i] * 2) / ((Wertsoll[i] - Wertstart[i] + 1) * (Wertsoll[i] - Wertstart[i] + 1));
     } 

for (int i = 0; i < AnzahlLEDs; i++ )
     { 
      if (micros() - lastfade[i] > Intervall[i]) 
          {
             if (Wertsoll[i] > Wertist[i]) { Wertist[i]++; } 
             if (Wertsoll[i] < Wertist[i]) { Wertist[i]--; } 
             lastfade[i] = micros();
          }  
     }        

for (int i = 0; i < AnzahlLEDs; i++ )
     { 
        analogWrite(LEDPIN[i],  WertAusgabe[i]);
        WertAusgabe[i] = Wertist[i] * hellgesamtsoll;
     }   
}

und hier die Variablen:

byte addresses[][6] = {"1Node", "2Node", "3Node", "4Node", "5Node", "6Node"}; 

int Sensor[16];
int Status[16];

unsigned long SendeTimer;
unsigned long SendeTimerZeit = 50;

byte IRRaum;
byte IRStatus;
byte IRStatusAlt;
int HellAussen;
int HellTemp;

int Taste = 1; int Tastealt;
byte Farbe;
byte Hell;
byte Satt;
byte Tastehalten = 0;

float fade1in = 0.1;
float fadeweissin = 0.5;
float fade1out = 5;
float hellgesamtsoll = 0.9;
float weissgesamtsoll = 1.0;
float hellgesamtsollalt;
byte LichtAn;
byte LichtAnAlt;
                     
byte Bewegung1 = 0;
byte Bewegung1alt;

byte Automatik = 1;
byte AutomatikAlt;

unsigned long Ablaufrot;
unsigned long AblaufrotZeit = 500;
unsigned long Ablaufgruen;
unsigned long AblaufgruenZeit = 500;
unsigned long Ablaufgelb;
unsigned long AblaufgelbZeit = 500;
unsigned long Ablaufblau;
unsigned long AblaufblauZeit = 500;
unsigned long Ablaufzuhell;
unsigned long AblaufZuordnungRGB1 = 500;
unsigned long SpeicherZuordnungRGB1 = 2500;
unsigned long ZuordnungRGB1;
unsigned long AblaufZuordnungRGB2 = 500;
unsigned long SpeicherZuordnungRGB2 = 2500;
unsigned long ZuordnungRGB2;
unsigned long AblaufZuordnungRGB3 = 500;
unsigned long SpeicherZuordnungRGB3 = 2500;
unsigned long ZuordnungRGB3;
unsigned long AblaufZuordnungWeiss1 = 500;
unsigned long SpeicherZuordnungWeiss1 = 2500;
unsigned long ZuordnungWeiss1;
unsigned long AblaufZuordnungWeiss2 = 500;
unsigned long SpeicherZuordnungWeiss2 = 2500;
unsigned long ZuordnungWeiss2;
unsigned long AblaufzuhellZeit = 600000; // max 10min über 80% Helligkeit

unsigned long AblaufLicht;
unsigned long UpdateSensor;
unsigned long UpdateDiagnose;
unsigned long SensorUpdate;
unsigned long AblaufAutomatikweiss;

unsigned long AblaufAutomatik;
unsigned long AblaufAutomatikProg;

3 kleiner Blöcke:

void BestaetigeAktionen()
{if ( millis() - Ablaufrot < AblaufrotZeit ) 
    { 
      for ( int i = 0; i < AnzahlLEDs; i++ )
        { WertAusgabe[i] = 0; }
      WertAusgabe[0] = 2000; WertAusgabe[3] = 2000; 
    }
    
if ( millis() - Ablaufgruen < AblaufgruenZeit ) 
    { 
      for ( int i = 0; i < AnzahlLEDs; i++ )
        { WertAusgabe[i] = 0; }
      WertAusgabe[1] = 2000; WertAusgabe[4] = 2000; 
    }
    
if ( millis() - Ablaufgelb < AblaufgelbZeit ) 
    { 
      for ( int i = 0; i < AnzahlLEDs; i++ )
        { WertAusgabe[i] = 0; }
      WertAusgabe[0] = 2000; WertAusgabe[1] = 2000; 
      WertAusgabe[3] = 2000; WertAusgabe[4] = 2000; 
    }
    
if ( millis() - Ablaufblau < AblaufblauZeit )
    { 
      for ( int i = 0; i < AnzahlLEDs; i++ )
        { WertAusgabe[i] = 0; }
      WertAusgabe[2] = 2000; WertAusgabe[5] = 2000; 
    }

if ( millis() - ZuordnungRGB1 < AblaufZuordnungRGB1 )
    { 
      for ( int i = 0; i < AnzahlLEDs; i++ )
        { WertAusgabe[i] = 0; }
      WertAusgabe[1] = 2000; 
    }

if ( millis() - ZuordnungRGB2 < AblaufZuordnungRGB2 )
    { 
      for ( int i = 0; i < AnzahlLEDs; i++ )
        { WertAusgabe[i] = 0; }
      WertAusgabe[4] = 2000; 
    }

if ( millis() - ZuordnungWeiss1 < AblaufZuordnungWeiss1 )
    { 
      for ( int i = 0; i < AnzahlLEDs; i++ )
        { WertAusgabe[i] = 0; }
      WertAusgabe[6] = 2000; 
    }

if ( millis() - ZuordnungWeiss2 < AblaufZuordnungWeiss2 )
    { 
      for ( int i = 0; i < AnzahlLEDs; i++ )
        { WertAusgabe[i] = 0; }
      WertAusgabe[7] = 2000; 
    }
}
void Empfangen()
{
// 0 = RaumID, 1 = LampenID, 2-4 = Farbwerte1, 5-7 Farbwerte2 bzw. weiss, 8-10 Fadewerte  
if ( Status[0] == RaumID && Status[1] == LampenID )
   { if ( Automatik == 2 ) 
        {
          memcpy(Wertsoll,Status+2,3); // Speicher die Werte 2-4 aus Status in 0-2 von Wertsoll
          memcpy(Wertsoll+3,Status+2,3); // Speicher die Werte 2-4 aus Status in 3-5 von Wertsoll
          memcpy(Wertsoll+6,Status+5,2); // Speicher die Werte 5-6 aus Status in 6-7 von Wertsoll
          fade1in = Status[7];
          fadeweissin = Status[8];
          fade1out = Status[9]; 
         }
   }      
}
void Senden()
{
  memcpy(Sensor+5,WertAusgabe,8); // Übertrage die Werte 0-7 aus WertAusgabe in 4-12 in Sensor
  Sensor[2] = Bewegung1;
  Sensor[3] = HellTemp;
  Sensor[4] = 0;
  Sensor[5] = 0;
  radio.stopListening();
  radio.write(Sensor, sizeof(Sensor));
  radio.startListening();
}

Und nun der letzte, größte und vielleicht auch komplizierteste Part- das Setzen von Werten über eine IR- Fernbedienung- Edit: der ist zu groß… also hier Teil 1:

void translateIR()
{
  Serial.write(' ');
  switch (results.value)
  {
    case 0xFF3AC5:
      IRStatus = 1;
      Tastehalten = 0;
      Serial.println(F("heller"));
      break;

    case 0xFFBA45:
      IRStatus = 2;
      Tastehalten = 0;
      Serial.println(F("dunkler"));
      break;

    case 0xFF827D:
      IRStatus = 3;
      Tastehalten = 0;
      Serial.println(F("speichern"));
      break;

    case 0xFF02FD:
      IRStatus = 4;
      Tastehalten = 0;
      Serial.println(F("an/aus"));
      break;

    case 0xFF1AE5:
      IRStatus = 5;
      Tastehalten = 0;
      Serial.println(F("rot"));
      break;

    case 0xFF9A65:
      IRStatus = 6;
      Tastehalten = 0;
      Serial.println(F("gruen"));
      break;

    case 0xFFA25D:
      IRStatus = 7;
      Tastehalten = 0;
      Serial.println(F("blau"));
      break;

    case 0xFF22DD:
      IRStatus = 8;
      Tastehalten = 0;
      Serial.println(F("weiss"));
      break;

    case 0xFF2AD5:
      IRStatus = 9;
      Tastehalten = 0;
      Serial.println(F("rot-orange"));
      break;

    case 0xFFAA55:
      IRStatus = 10;
      Tastehalten = 0;
      Serial.println(F("tuerkis"));
      break;

    case 0xFF926D:
      IRStatus = 11;
      Tastehalten = 0;
      Serial.println(F("hellblau"));
      break;

    case 0xFF12ED:
      IRStatus = 12;
      Tastehalten = 0;
      Serial.println(F("beige"));
      break;

    case 0xFF0AF5:
      IRStatus = 13;
      Tastehalten = 0;
      Serial.println(F("gelb"));
      break;

    case 0xFF8A75:
      IRStatus = 14;
      Tastehalten = 0;
      Serial.println(F("hellgruen"));
      break;

    case 0xFFB24D:
      IRStatus = 15;
      Tastehalten = 0;
      Serial.println(F("hellblau"));
      break;

    case 0xFF32CD:
      IRStatus = 16;
      Tastehalten = 0;
      Serial.println(F("warmweis"));
      break;

    case 0xFF38C7:
      IRStatus = 17;
      Tastehalten = 0;
      Serial.println(F("dunkelgelb"));
      break;

    case 0xFFB847:
      IRStatus = 18;
      Tastehalten = 0;
      Serial.println(F("blassgruen"));
      break;

    case 0xFF7887:
      IRStatus = 19;
      Tastehalten = 0;
      Serial.println(F("blassblau"));
      break;

    case 0xFFF807:
      IRStatus = 20;
      Tastehalten = 0;
      Serial.println(F("kaltweis"));
      break;

    case 0xFF18E7:
      IRStatus = 21;
      Tastehalten = 0;
      Serial.println(F("gelblich"));
      break;

    case 0xFF9867:
      IRStatus = 22;
      Tastehalten = 0;
      Serial.println(F("blau-gruen"));
      break;

    case 0xFF58A7:
      IRStatus = 23;
      Tastehalten = 0;
      Serial.println(F("violett"));
      break;

    case 0xFFD827:
      IRStatus = 24;
      Tastehalten = 0;
      Serial.println(F("blau-weis"));
      break;

    case 0xFF28D7:
      IRStatus = 25;
      Tastehalten = 0;
      Serial.println(F("rot+"));
      break;

    case 0xFFA857:
      IRStatus = 26;
      Tastehalten = 0;
      Serial.println(F("gruen+"));
      break;

    case 0xFF6897:
      IRStatus = 27;
      Tastehalten = 0;
      Serial.println(F("blau+"));
      break;

    case 0xFFE817:
      IRStatus = 28;
      Tastehalten = 0;
      Serial.println(F("quick"));
      break;

    case 0xFF08F7:
      IRStatus = 29;
      Tastehalten = 0;
      Serial.println(F("rot-"));
      break;

    case 0xFF8877:
      IRStatus = 30;
      Tastehalten = 0;
      Serial.println(F("gruen-"));
      break;

    case 0xFF48B7:
      IRStatus = 31;
      Tastehalten = 0;
      Serial.println(F(" blau-"));
      break;

    case 0xFFC837:
      IRStatus = 32;
      Tastehalten = 0;
      Serial.println(F("slow"));
      break;

    case 0xFF30CF:
      IRStatus = 33;
      Tastehalten = 0;
      Serial.println(F("DIY1"));
      break;

    case 0xFFB04F:
      IRStatus = 34;
      Tastehalten = 0;
      Serial.println(F("DIY2"));
      break;

    case 0xFF708F:
      IRStatus = 35;
      Tastehalten = 0;
      Serial.println(F("DIY3"));
      break;

    case 0xFFF00F:
      IRStatus = 36;
      Tastehalten = 0;
      Serial.println(F("auto"));
      break;

    case 0xFF10EF:
      IRStatus = 37;
      Tastehalten = 0;
      Serial.println(F("DIY4"));
      break;

    case 0xFF906F:
      IRStatus = 38;
      Tastehalten = 0;
      Serial.println(F("DIY5"));
      break;

    case 0xFF50AF:
      IRStatus = 39;
      Tastehalten = 0;
      Serial.println(F("DIY6"));
      break;

    case 0xFFD02F:
      IRStatus = 40;
      Tastehalten = 0;
      Serial.println(F("flash"));
      break;

    case 0xFF20DF:
      IRStatus = 41;
      Tastehalten = 0;
      Serial.println(F("Jump3"));
      break;

    case 0xFFA05F:
      IRStatus = 42;
      Tastehalten = 0;
      Serial.println(F("Jump7"));
      break;

    case 0xFF609F:
      IRStatus = 43;
      Tastehalten = 0;
      Serial.println(F("Fade3"));
      break;

    case 0xFFE01F:
      IRStatus = 44;
      Tastehalten = 0;
      Serial.println(F("Fade7"));
      break;

    case 0xFFFFFFFF:
      Tastehalten = 1;
      Serial.println(F("Taste halten"));
      break;
  }
}

und Teil 2 - Edit immer noch zu lang… :frowning: :

void IRProgramm()
{   
  if (IRStatus == 1) // alles heller
  {
    if (Taste == 1 && Taste != Tastealt)
       { if ( hellgesamtsoll < 0.99 )
            { hellgesamtsoll = hellgesamtsoll * 1.01; }
        if ( weissgesamtsoll < 0.99 )
            { weissgesamtsoll = weissgesamtsoll * 1.01; }
         Taste = 0; Tastealt = 0;
       fade1in = 0.1;
       fadeweissin = 0.05;}}

  else if (IRStatus == 2) // alles dunkler
  {
    if (Taste == 1 && Taste != Tastealt )
       { if ( hellgesamtsoll > 0.01 )
            { hellgesamtsoll = hellgesamtsoll * 0.99; }
         if ( weissgesamtsoll > 0.01 )
            { weissgesamtsoll = weissgesamtsoll * 0.99; }
         Taste = 0; Tastealt = 0;
       fade1in = 0.1;
       fadeweissin = 0.05;}}
 
  else if (IRStatus == 3)  // Effekt 1
  { 
    for (int i = 0; i < AnzahlLEDs; i++ )
        { 
         EEPROM.write(Speicher[i], byte(Wertsoll[i]/16)); 
        }
  }      
   
  else if (IRStatus == 4) // alles aus
     { IRStatus = 0; 
       for (int i = 0; i < AnzahlLEDs; i++ )
           {
            if ( Wertsoll[i] > WertMin[i] )
                { EEPROM.write(Speicher[i], byte(Wertsoll[i]/16)); 
                  Wertsoll[i] = WertMin[i]; }
            else
                { Wertsoll[i] = 16 * EEPROM.read(Speicher[i]); 
                  fade1in = 0.5; }
           }
      }      
      
  else if (IRStatus == 5) // rot
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*1; 
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*1;}

  else if (IRStatus == 9) // orange-rot
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.95; 
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.45; }

  else if (IRStatus == 13) // orange
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.8; 
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.6; }

  else if (IRStatus == 17) // orange-gelb
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.75; 
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.65;
    Wertsoll[6] = WertMin[6]+(WertMax[6]-WertMin[6])*0.15; 
    Wertsoll[7] = WertMin[7]+(WertMax[7]-WertMin[7])*0.15; }

  else if (IRStatus == 21) // gelb
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.65; 
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.75;
    Wertsoll[6] = WertMin[6]+(WertMax[6]-WertMin[6])*0.25; 
    Wertsoll[7] = WertMin[7]+(WertMax[7]-WertMin[7])*0.25; }

  else if (IRStatus == 6) // grün
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*1; 
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*1;}

  else if (IRStatus == 10) // grün-blau
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*0.95; 
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.2;
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*0.95; 
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.2;}

  else if (IRStatus == 14) // grün-türkis
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*0.9; 
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.4;
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*0.9; 
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.4;}
  
  else if (IRStatus == 18) // türkis
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*0.6; 
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.6;
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*0.6; 
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.6;
    Wertsoll[6] = WertMin[6]+(WertMax[6]-WertMin[6])*0.1; 
    Wertsoll[7] = WertMin[7]+(WertMax[7]-WertMin[7])*0.1;}

  else if (IRStatus == 22) // türkis-blau
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*0.6; 
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.7;
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*0.6; 
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.7; }

  else if (IRStatus == 7) // blau
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*1; 
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*1;}

  else if (IRStatus == 11) //blau-rot
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.4; 
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.9;
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.4; 
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.9; }

  else if (IRStatus == 15) // violett
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.5; 
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.8;
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.5; 
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.8; }

  else if (IRStatus == 19) // magenta
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.5; 
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.7;
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.5; 
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.7;
    Wertsoll[6] = WertMin[6]+(WertMax[6]-WertMin[6])*0.05; 
    Wertsoll[7] = WertMin[7]+(WertMax[7]-WertMin[7])*0.05; }

    IRStatusAlt = IRStatus;
}

Die Aufteilung der Daten in den Arrays zum Senden und Empfangen ist noch nicht final- das kann ignoriert werden… das muss ich noch neu gliedern, so dass es zu allen Lampe die ich habe paßt. Ich habe Lampen mit bis zu 3RGB- Kanälen und Lampen mit bis zu 10 verschiedenen weiss-Kanälen… am End will ich den Sketch nur mit minimalen Anpassungen, wie Adresse und Zahl der belegten Kanäle für alle Lampen einsetzen- eventl. kommt noch einen Anlernfunktion dazu- wo dann die Lampe von der Zentrale einmal durchgespielt wird uns mit einem Farbsensor die Zuordnung der Kanäle selbstständig abgeglichen wird, inkl. Farbkorrektur - ähnlich wie beim Einmessen eines A/V Receivers :slight_smile:

So, nun noch Teil 3, den bitte bei Teil 2 ganz hinten, vor der letzten schliessenden Klammer einfügen:

  else if (IRStatus == 23) // magenta-rot
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.6; 
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.5;
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.6; 
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.5;}
   
  else if (IRStatus == 8) // weiß
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    //memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.8; 
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*0.8;
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.1;
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.8; 
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*0.8;
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.1;
    Wertsoll[6] = WertMin[6]+(WertMax[6]-WertMin[6])*1; 
    Wertsoll[7] = WertMin[7]+(WertMax[7]-WertMin[7])*1; }

  else if (IRStatus == 12) // warmweiß
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.9; 
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*0.8;
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.07;
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.9; 
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*0.8;
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.07;
    Wertsoll[6] = WertMin[6]+(WertMax[6]-WertMin[6])*1; 
    Wertsoll[7] = WertMin[7]+(WertMax[7]-WertMin[7])*1; }

  else if (IRStatus == 16) // beige
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.8; 
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*0.7;
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.07;
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.8; 
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*0.7;
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.07;
    Wertsoll[6] = WertMin[6]+(WertMax[6]-WertMin[6])*0.8; 
    Wertsoll[7] = WertMin[7]+(WertMax[7]-WertMin[7])*0.8; }

  else if (IRStatus == 20) // dunkelbeige
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.2; 
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*0.17;
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.02;
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.2; 
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*0.17;
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.02;
    Wertsoll[6] = WertMin[6]+(WertMax[6]-WertMin[6])*0.4; 
    Wertsoll[7] = WertMin[7]+(WertMax[7]-WertMin[7])*0.4; }

  else if (IRStatus == 24) // beige-gelb
  { memcpy(ZwischenSpeicher,Wertsoll,AnzahlLEDs);
    memcpy(Wertsoll,WertMin,AnzahlLEDs);
    Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.15; 
    Wertsoll[1] = WertMin[1]+(WertMax[1]-WertMin[1])*0.13;
    Wertsoll[2] = WertMin[2]+(WertMax[2]-WertMin[2])*0.01;
    Wertsoll[3] = WertMin[3]+(WertMax[3]-WertMin[3])*0.15; 
    Wertsoll[4] = WertMin[4]+(WertMax[4]-WertMin[4])*0.13;
    Wertsoll[5] = WertMin[5]+(WertMax[5]-WertMin[5])*0.01;
    Wertsoll[6] = WertMin[6]+(WertMax[6]-WertMin[6])*0.2; 
    Wertsoll[7] = WertMin[7]+(WertMax[7]-WertMin[7])*0.2; }

    
  else if (IRStatus == 25) // rot+
  {
    if (Taste == 1 && Taste != Tastealt)
       { if ( Wertsoll[0] < WertMax[0] ) 
            { Wertsoll[0] = Wertsoll[0] * 1.01; 
              if (Wertsoll[1] > WertMin[1]+(WertMax[1]-WertMin[1])*0.3)
                 {Wertsoll[1] = Wertsoll[1] * 0.99;}
              if (Wertsoll[2] > WertMin[2]+(WertMax[2]-WertMin[2])*0.3)
                 {Wertsoll[2] = Wertsoll[2] * 0.99;} 
         if ( Wertsoll[3] < WertMax[3] ) 
            { Wertsoll[3] = Wertsoll[3] * 1.01; 
              if (Wertsoll[4] > WertMin[4]+(WertMax[4]-WertMin[4])*0.3)
                 {Wertsoll[4] = Wertsoll[4] * 0.99;}
              if (Wertsoll[5] > WertMin[5]+(WertMax[5]-WertMin[5])*0.3)
                 {Wertsoll[5] = Wertsoll[5] * 0.99;} }}
        Taste = 0; Tastealt = 0;}}

  else if (IRStatus == 26) // gruen+
  {
    if (Taste == 1 && Taste != Tastealt)
       { if ( Wertsoll[1] < WertMax[1] ) 
            { Wertsoll[1] = Wertsoll[1] * 1.01; 
              if (Wertsoll[0] > WertMin[0]+(WertMax[0]-WertMin[0])*0.3)
                 {Wertsoll[0] = Wertsoll[0] * 0.99;}
              if (Wertsoll[2] > WertMin[2]+(WertMax[2]-WertMin[2])*0.3)
                 {Wertsoll[2] = Wertsoll[2] * 0.99;} 
         if ( Wertsoll[4] < WertMax[4] ) 
            { Wertsoll[4] = Wertsoll[4] * 1.01; 
              if (Wertsoll[3] > WertMin[3]+(WertMax[3]-WertMin[3])*0.3)
                 {Wertsoll[3] = Wertsoll[3] * 0.99;}
              if (Wertsoll[5] > WertMin[5]+(WertMax[5]-WertMin[5])*0.3)
                 {Wertsoll[5] = Wertsoll[5] * 0.99;} }}
        Taste = 0; Tastealt = 0;}}

  else if (IRStatus == 27) // blau+
  {
    if (Taste == 1 && Taste != Tastealt)
       { if ( Wertsoll[2] < WertMax[2] ) 
            { Wertsoll[2] = Wertsoll[2] * 1.01; 
              if (Wertsoll[1] > WertMin[1]+(WertMax[1]-WertMin[1])*0.3)
                 {Wertsoll[1] = Wertsoll[1] * 0.99;}
              if (Wertsoll[0] > WertMin[0]+(WertMax[0]-WertMin[0])*0.3)
                 {Wertsoll[0] = Wertsoll[0] * 0.99;} 
         if ( Wertsoll[5] < WertMax[5] ) 
            { Wertsoll[5] = Wertsoll[5] * 1.01; 
              if (Wertsoll[4] > WertMin[4]+(WertMax[4]-WertMin[4])*0.3)
                 {Wertsoll[4] = Wertsoll[4] * 0.99;}
              if (Wertsoll[3] > WertMin[3]+(WertMax[3]-WertMin[3])*0.3)
                 {Wertsoll[3] = Wertsoll[3] * 0.99;} }}
        Taste = 0; Tastealt = 0;}}

  else if (IRStatus == 28) // schneller
  {
    if (Taste == 1 && Taste != Tastealt && fade1in > 0.01)
    {fade1in = fade1in * 0.9;
     Taste = 0; Tastealt = 0;}}

  else if (IRStatus == 29) // rot-
  {
    if (Taste == 1 && Taste != Tastealt)
       { if ( Wertsoll[0] > WertMin[0] ) { Wertsoll[0] = Wertsoll[0] * 0.99; }
         if ( Wertsoll[3] > WertMin[3] ) { Wertsoll[3] = Wertsoll[3] * 0.99; }
        Taste = 0; Tastealt = 0;} }

  else if (IRStatus == 30) // gruen-
  {
    if (Taste == 1 && Taste != Tastealt)
       { if ( Wertsoll[1] > WertMin[1] ) { Wertsoll[1] = Wertsoll[1] * 0.99; }
         if ( Wertsoll[4] > WertMin[4] ) { Wertsoll[4] = Wertsoll[4] * 0.99; }
        Taste = 0; Tastealt = 0;}}

  else if (IRStatus == 31) // blau-
  {
    if (Taste == 1 && Taste != Tastealt)
       { if ( Wertsoll[2] > WertMin[2] ) { Wertsoll[2] = Wertsoll[2] * 0.99; }
         if ( Wertsoll[5] > WertMin[5] ) { Wertsoll[5] = Wertsoll[5] * 0.99; }
        Taste = 0; Tastealt = 0;}}

  else if (IRStatus == 32) // langsamer
  {
    if (Taste == 1 && Taste != Tastealt && fade1in < 50)
    {fade1in = fade1in * 1.1;
     Taste = 0; Tastealt = 0;}}

  else if (IRStatus == 33) 
  { SpeicherZuordnungRGB1 = millis(); }

  else if (IRStatus == 34) 
  { SpeicherZuordnungRGB2 = millis(); }
  
  else if (IRStatus == 35) 
  { SpeicherZuordnungRGB3 = millis(); 
    SpeicherZuordnungWeiss1 = millis(); 
    SpeicherZuordnungWeiss2 = millis(); }
  
  else if (IRStatus == 36 && IRStatusAlt != 36) 
  { Automatik++; //IRStatus = 0;
    if (Automatik > 2) { Automatik = 0; }
  }  

  else if (IRStatus == 37) 
  { //EEPROM.write(Speicherrot, ZwischenSpeicherRot); 
    //EEPROM.write(Speichergruen, ZwischenSpeicherGruen);
    //EEPROM.write(Speicherblau, ZwischenSpeicherBlau);
    Ablaufblau = millis(); 
    memcpy(Wertsoll,WertMin,AnzahlLEDs); fade1in = 50; }

  else if (IRStatus == 38)
  { //EEPROM.write(Speicherrot, ZwischenSpeicherRot); 
    //EEPROM.write(Speichergruen, ZwischenSpeicherGruen);
    //EEPROM.write(Speicherblau, ZwischenSpeicherBlau);
    Ablaufblau = millis(); 
    memcpy(Wertsoll,WertMin,AnzahlLEDs); fade1in = 300; }

  else if (IRStatus == 39) 
  { //EEPROM.write(Speicherrot, ZwischenSpeicherRot); 
    //EEPROM.write(Speichergruen, ZwischenSpeicherGruen);
    //EEPROM.write(Speicherblau, ZwischenSpeicherBlau);
    Ablaufblau = millis(); 
    memcpy(Wertsoll,WertMin,AnzahlLEDs); fade1in = 1600; }

Keine Ideen? Oder ist es schon perfekt ? :o

bin kein Profi, aber was mir so auffällt:

STRG-T drücken in allen tabs und neu abspeichern
Serial.print mit Fixtexten mit dem F-Makro versehen

statt
for (int i = 0; i < AnzahlLEDs; i++ )
hier reicht meist ein
for (uint8_t i = 0; i < AnzahlLEDs; i++ )

einfach mal alle (int i = suchen und prüfen ob es wirklich ein int sein muss (wird i mal negativ?)

bei den meisten Fällen kannst aber auch ein for(auto … machen

dann deine if-ketten:
if ( Automatik == 0 ) {
Ablaufrot = millis();
}
if ( Automatik == 1 ) {
Ablaufgruen = millis();
}
if ( Automatik == 2 ) {
Ablaufgelb = millis();
}

umbauen auf case oder zumindest den zweiten und dritten if mit else if machen.
Alle weiteren If durchsuchen, welche sich mit else if erweitern lassen

Muss das wirklich ein Int sein?
unsigned int Speicher[AnzahlLEDs] = {0, 1, 2, 3, 4, 5, 6, 7};

warum kein const für
int led = 13;
unsigned long AblaufAutomatikZeit = 120000;
unsigned long AblaufAutomatikweissZeit = 110000;
unsigned long SensorUpdateIntervall = 1200000;
unsigned long ZurueckAutomatikZeit = 1800000;
unsigned long Verzoegerung = 30000;

und in den anderen tabs warum long, warum nicht const?
unsigned long SpeicherZuordnungRGB2 = 2500;

am besten kontrollierst mal JEDE Variablendefintion ob du die richtige Größe gewählt hast. Dabei auch kritisch hinterfragen, ob sich der Wert zur Laufzeit ändern muss, dann mach ein const daraus.

am besten speicherst dir mal ab, wie viel Ram/Flash du aktuell verbrauchst, und dann nach den ganzen Änderungen noch einmal. Dann siehst du wenigstens warum es sich gelohnt hat, den Code aufzuräumen :wink:

viel zu tun, ein Update (als Zip) schau ich mir vieleicht noch mal an…

MaHa76: Keine Ideen? Oder ist es schon perfekt ? :o

Wenn es tut was es soll, ist es in gewisser Weise perfekt, oder?

MaHa76: Und nun der letzte, größte und vielleicht auch komplizierteste Part- das Setzen von Werten über eine IR- Fernbedienung- Edit: der ist zu groß... also hier Teil 1:

Ersetze diesen switch Marathon durch Arrays oder einen Array aus Strukturen in PROGMEM.

Die Zusammenbastelei von den Farben erscheint mir auch unübersichtlich und CP-artig.

  Wertsoll[0] = WertMin[0]+(WertMax[0]-WertMin[0])*0.9;

könnte auch wie folgt aussehen (Faktor als 1/100 um floats zu vermeiden)

  adjust(0, 90);

man könnte auch so etwas machen

  adjust(ersterWert, anzahlWerte, arrayVonAdjustWerten);

Wozu soll das gut sein? Der letzte Wert ist sogar falsch.

#define RF24_MOSI 11
#define RF24_MISO 12
#define RF24_SCLK 14
byte Sensor[16];
byte Status[16];

Als Paketdefinition würde ich unbedingt eine struc oder class nutzen, ich wäre viel zu faul mir die Bedeutungen der Indices zu merken, für die du nicht einmal ein enum benutzt.

In zwei Jahren weisst auch du nicht mehr was auf der Position 7 stand.

Erstmal danke an noiasca! Die Hinweise nehme ich auf jeden Fall mal auf!

@Whandall - danke auch für Deine Hinweise- da mache ich mich auch ran... aber da hab ich noch Fragen.

Bzgl. Progmem brauch ich noch Hilfe, bzw. ich verstehe was Du meinst, hab mich damit aber noch nicht befaßt und werde mich da jetzt einlesen.

Was das "Zusammenbasteln der Farben" angeht- ich kann ja nicht mit den Absolutwerten rechnen, wenn ich jetzt 90% blau haben will- ich muss ja erstmal die Differenz zwischen dem Max-Wert und dem Min-Wert nehmen und davon dann die 90% errechnen, um diese dann auf den Min-Wert aufschlagen zu können. Der Min-Wert ist der Wert wo die jeweilige Farbe definitiv aus ist, was je nach LED und KSQ eben auch deutlich über "0" liegen kann. Der Max-Wert kann auch kleiner sein als 4096, wenn ich z.b. eine Farbkorrektur vornehme.

Kann ich das selbe auch mit "adjust" erreichen?

Warum sind meine Werte für den RF24 falsch?

Edit: Ich sehe, dass die Zeile verloren gegangen ist, wo diese Werte zugeordnet werden. Aber wahrscheinlich kann ich die (hier) wirklich weglassen, dass es ja dem Hardware-SPI am Teensy entspricht- ich hab aber auch Module in Betrieb, wo ich alternative SPI PINs nutze, da muss ich es mit rein nehmen.

Aber was RF24 angeht bist Du definitiv der Profi- da hast Du mir ja erst das Laufen beigebracht- daher hat Dein Wort da sehr viel Gewicht!

Die Kommunikation ändert sich nicht, egal ob du einen Byte Array oder eine struct benutzt.

Stimmst du meiner Interpretation des Sendepakets zu? Wozu sind die 4 unbenutzten Bytes gut?

struct SendePaket {
  byte raum;
  byte lampe;
  byte bewegung;
  byte helligkeit;
  byte _frei_0;
  byte werte[8]; 
  byte _frei_1;
  byte _frei_2;
  byte _frei_3;
};

Damit würde dir die doppelte Benutzung von Sensor[5] eher auffallen als in deinem Kode

  memcpy(Sensor + 5, WertAusgabe, 8); // Übertrage die Werte 0-7 aus WertAusgabe in 4-12 in Sensor
  Sensor[2] = Bewegung1;
  Sensor[3] = HellTemp;
  Sensor[4] = 0;
  Sensor[5] = 0;

Das ist ne sehr gute Idee! Und das setze ich auch mal um (ist ein neues Thema für mich- das meinte ich mit “eingeschränkter Wortschatz” :slight_smile: )

Die freien Bytes werden noch belegt. Die Zentrale soll den kompletten Status der Lampe(n) bekommen- inkl. Helligkeit, Automatikstatus, Helligkeiten, eventl. auch Raumtemperatur und so. Ich hab da nur noch die Herausforderung eine Liste der Daten aller Lampen (die verschieden ausgerüstet sind) zu erstellen und das auf einen Nenner zu bringen, damit die Zentrale ein einheitliches Datenpaket von allen Lampen bekommt.

Das adjust ist ein Schritt die Lesbarkeit zu erhöhen und zu verhindern dass man sich bei den Indexkonstanten vertippt.

Ein Verzicht auf floats und Benutzen von 1/100 Einheiten macht deinen Kode kleiner und schneller.

void adjust(byte index, uint16_t adjProzent) {
  Wertsoll[index] = WertMin[index] + (1L * (WertMax[index] - WertMin[index]) * adjProzent) / 100;
}

WertMax und WertMin erscheinen mir konstant, WertBereich könnte man als Array halten, statt ihn jedesmal neu zu berechnen. Im Moment nimmt die Berechnung mehr Platz weg als ein PROGMEM Array und ist langsamer.

OK- der Ansatz ist gut- gefällt mir!

(wobei das Thema Tempo nicht dramatisch wäre, da die Berechnung nur dann ausgeführt wird, wenn man über die Fernbedienung eine neue Farbe auswählt).

Da der Sketch eventl. auch mal auf einen nano (dann nur in 8bit Auflösung-leider) zum Einsatz kommen könnte, ist alles gut, was das Ding schneller macht oder schnell hält. :-)