Ampelsteuerung

[Tobias K. (tobias_k622)]

Hallo zusammen,

bin neu hier und auch neu in der uC-Programmierung. Ich möchte gerne 
eine Ampelsteuerung umsetzten, habe aber folgenden Fehler: Die LEDs 
beginnen schon zu blinken, owbohl die erste Verzweigung false liefert. 
Warum ist das so? Der Code befindet sich im Anhang.
Vielleicht könnte mir einer helfen.

mfg Tobias

[Helmut -. (dc3yc)]

Weil es anscheinend für den falschen Prozessor compiliert wurde?

[Tobias K. (tobias_k622)]

Wie könnte ich das umstellen?

[Grobi (Gast)]

Quatsch, die geschweiften Klammern passen nicht.

[Tobias K. (tobias_k622)]

Nein die geschweiften Klammern sind nicht falsch gesetzt. Beim normal 
Betrieb geht das Programm immer in die Verzweigungen, die jedoch FALSE 
sind. Komischerweise beim Debuggen nicht. An was kann das liegen?

[None (Gast)]

Für

// Ampel: 1 Ampel 1 & 1 Ampel 2

// Configuration variables
const byte LEDOff = HIGH;                   // If LED are switeched against Vcc, then LEDOff = HIGH
const byte LEDOn = LOW;       
const byte Off = LEDOff;                   
const byte On = LEDOn;     

const int GapTime = 200;                   // delay time, one light on
const byte LEDcount = 6;                   // no of LEDs

byte CurrentLED = 0;                       // current LED, horizontal loop through array
byte CurrentLEDState = Off;                // current LED State
byte CurrentPhase = 0;                     // vertical loop through array
int  CurrentDelay = 0;                     // Delay in current phase

int Counter = 1;                           // loop counter

byte LEDMode = 1;                          // op modes - 0: All off   1: Normal Operation   2: LED yellow flash (night mode)
byte CurrentLEDMode = 1;                   // Current LED output mode
byte NewLEDMode = 1;                       // New LED output mode after inout read
byte ChangedLEDMode = 1;                   // Flag: mode changed

const byte LEDAmpel [6] = {9,10,11,12,13,14}; // LED pins Ampel1 R-Y-G Ampel2 R-Y-G

const byte InputOnOff = 1;                 // Input pin for on/off
const byte InputNight = 0;                 // Input pin for day/night

byte ReadingOnOff = HIGH;                   // Reading value from input OnOff
byte ReadingNight = HIGH;                   // Reading value from input OnOff
const byte InputOn = LOW;                   // Input Reading for ON
const byte InputOff = HIGH;                 // Input Reading for OFF

const byte TimeStretch = 3;                 // overall delay stretch factor
byte TimeStretchable = 0;                   // Phase delay to be stretched?
int StretchedDelay = 0;                     // computed stretched delay

//**************************************************
//*                                                *
//* Mode as Array in Flash                         *
//*                                                *
//**************************************************
const byte NoOfModes = 3;                   // how many modes: arry dim 1
const byte Folge_Laenge[NoOfModes] = {1, 8, 2}; // how many lines per mode
const byte Folge_Max_Laenge = 9;            // how long is maximum mode: array dim 2

const byte LED_Folge[NoOfModes] [Folge_Max_Laenge] [8] PROGMEM = // {A1R,A1Y,A2G,A2R,A2G,DELAY in ticks of 0.1 sec ,Stretchable): array dim 3 
{ 
  //Mode 0: Aus
  {
    {Off, Off, Off, Off, Off, Off, 20, 0},  // 1.) Alles aus
  },

  // Mode 1: Normal
  {
    {On,  Off, Off,    On,  Off, Off, 30, 0},  // 0.)beide Ampeln sind rot
    {On,  On,  Off,    On,  Off, Off, 15, 0},  // 1.)Ampel 1 geht auf rot/gelb
    {Off, Off, On,     On,  Off, Off, 30, 1},  // 2.)Ampel 1 geht auf grün
    {Off, On,  Off,    On,  Off, Off, 20, 0},  // 3.)Ampel 1 geht auf gelb
    {On,  Off, Off,    On,  Off, Off, 30, 0},  // 4.)beide Ampeln sind rot
    {On,  Off, Off,    On,  On,  Off, 10, 0},  // 5.)Ampel 2 geht auf rot/gelb
    {On,  Off, Off,    Off, Off, On,  30, 1},  // 6.)Ampel 2 geht auf grün
    {On,  Off, Off,    Off, On,  Off, 20, 0},  // 7.)Ampel 2 geht auf gelb
  },
  // Mode 2: Blinken Gelb
  {
    {Off, On,  Off, Off, On,  Off, 5, 0},  // 0.) Beide Ampeln leuchten gelb
    {Off, Off, Off, Off, Off, Off, 5, 0},  // 1.) Alles aus
  },
};


//**************************************************
//*                                                *
//* Function to read inputs and flag if a change   *
//* in mode has happened. Is called out of delay   *
//*                                                *
//**************************************************
void ReadInput()
{
  ReadingOnOff = digitalRead(InputOnOff);  // read first input
  ReadingNight = digitalRead(InputNight);  // read second input
  
  NewLEDMode = 1;                          // normal op
  if(ReadingNight == InputOn)              // if night mode
  {
     NewLEDMode = 2;                       // then switch to mode 2
   }
  if(ReadingOnOff == InputOn)              // if all off
  {
    NewLEDMode = 0;                        // then switch to mode 0
  }  
  
  ChangedLEDMode = 1;                                    // set change flag
  if (CurrentLEDMode == NewLEDMode) ChangedLEDMode = 0;  // has mode changed? if not clear flag
  CurrentLEDMode = NewLEDMode;                           // overwrite current mode with new mode
} 

//**************************************************
//*                                                *
//* Delay routine, calls ReadInput() to see if     *
//* something changed and bails out if so          *
//*                                                *
//**************************************************

void breakbleDelay(int lengthDelay, int myTimeStretchable)
{
  if(myTimeStretchable ==1) StretchedDelay = 100 * lengthDelay * TimeStretch; else StretchedDelay = 100 * lengthDelay;  // if interval stretchable, then scale & stretch, else only scale
  for(int Counter = 0; Counter < StretchedDelay; Counter++)
  {
    delay(1);                                           // wait a millsec
    ReadInput();                                        // read inputs
    if(ChangedLEDMode == 1) break;                      // if something changed then break out of delay
  }
}

//**************************************************
//*                                                *
//* Set up input and output pins.                  *
//* IMPORTANT:Switch off pullup for inputs         *
//* if not, communication floats                   *
//*                                                *
//**************************************************
void setup() 
{
  for(CurrentLED = 0 ; CurrentLED <= LEDcount ; CurrentLED +=1) // cycle through LEDs
  {
    pinMode(LEDAmpel[CurrentLED], OUTPUT);                      // initialize the digital pin as an output.    
    digitalWrite(LEDAmpel[CurrentLED], LEDOn);                  // switch on all LEDs (shows cycle at powerup)
    delay(GapTime);
    digitalWrite(LEDAmpel[CurrentLED], LEDOff);                 // switch off all LEDs
  }
  pinMode(InputOnOff, INPUT);                                   // initialize the digital pin as an input: Set Mode 0; override
  pinMode(InputNight, INPUT);                                   // initialize the digital pin as an output
  digitalWrite(InputOnOff, LOW);                                // Switch off pullup - IMPORTANT: if not, communication floats
  digitalWrite(InputNight, LOW);                                // Switch off pullup - IMPORTANT: if not, communication floats
} // end setup

//**************************************************
//*                                                *
//*  Main loop                                      *
//*                                                *
//*                                                *
//**************************************************
void loop()
{
  for(CurrentPhase = 0; CurrentPhase < Folge_Laenge[CurrentLEDMode]; CurrentPhase++)               // cycle through phases of current mode
  {
    CurrentDelay = pgm_read_word_near(&LED_Folge[CurrentLEDMode][CurrentPhase][LEDcount]);         // read delay time from flas
    TimeStretchable = pgm_read_word_near(&LED_Folge[CurrentLEDMode][CurrentPhase][LEDcount +1]);   // read stretchable flag from flash
    for(CurrentLED = 0 ; CurrentLED < LEDcount ; CurrentLED +=1)                                   // cycle through LEDs for current phase
    {
      CurrentLEDState = pgm_read_word_near(&LED_Folge[CurrentLEDMode][CurrentPhase][CurrentLED]);  // read LED state for cuurent mode/phase/LED from flash 
      digitalWrite(LEDAmpel[CurrentLED], CurrentLEDState);                                         // set LED output accordingly
    }
    breakbleDelay(CurrentDelay, TimeStretchable);                                                  // wait defined time and break on input
    if(ChangedLEDMode == 1) break;                                                                 // if input changed, then start afresh in new mode 
  }  
} // end main loop