Finite state machine

[Hanneman Profiel Privébericht]

Zo bereik ik wel mijn doel
dankzij jouw tip!

if (millis() > delayCtr) {
analogWrite(REDLEDPIN, brightness); // && LDR01Value01
analogWrite(GREENLEDPIN, brightness);// && LDR02Value02
analogWrite(BLUELEDPIN, brightness); // && LDR03Value03
// change the brightness for next time through the loop:
brightness = brightness + fadeAmount;
// reverse the direction of the fading at the ends of the fade:
if (brightness == 0 || brightness == 255) {
fadeAmount = -fadeAmount ;
delayCtr = millis() + VERTRAGING;
} else {
delayCtr = 0L; // stop de vertraging. Zolang deze niet gezet wordt,
// zal het bovenstaande niet meer uitgevoerd worden
}
}

[Hanneman Profiel Privébericht]

Nu wil ik alleen nog heel graag weten hoe het kan dat ik met die LDR's niet de maximale brightness van de LEDS kan bereiken....

Heeft 1 van jullie daar een idee over?

[Hanneman Profiel Privébericht]

Misschien gaat dat ook nog wel lukken.
Ik heb het Blink gedeelte met millis kunnen doen en de snelheid van het stroboscope effect regelbaar gemaakt. Welke van de drie leds aan zijn kan je ook kiezen.
Deze leds waren ook niet optimaal fel. Ik heb brightness ingesteld op 255 en in plaats van ledstate == high, voor ledstate = brightness gekozen en nu branden ze wel voluit.
Misschien kan ik zoiets ook met de LDRs doen.

[nicoverduin Profiel PrivéberichtWebsite]

Nu wil ik alleen nog heel graag weten hoe het kan dat ik met die LDR's niet de maximale brightness van de LEDS kan bereiken....

Heeft 1 van jullie daar een idee over?

Je moet eerst meten wat de spanning is bij de LDR bij minimum licht en maximum licht. Daarna kan je een mapping doen:

Code: Alles selecteren

brightness = map(LDR_waarde, minimale_LDR_waarde, maxiimale_LDR_waarde, 0, 255);


[shooter Profiel Privébericht]

nico dat && werkt niet moet zijn < dan blijft led aan tot getal groter is dan ledval
testen kan door analogWrite(REDLEDPIN, 200); te schrijven, en dan pas aanpassen aan analogWrite(REDLEDPIN, ledVal);
volgende stap is om dan de verschillende values te laten verlopen.
dan heb je nog een probleem omdat sinus ook negatief kan worden, dus je moet scale gebruiken van -1 to 1 en uit van 0 tot 255

[nicoverduin Profiel PrivéberichtWebsite]

nico dat && werkt niet moet zijn < dan blijft led aan tot getal groter is dan ledval
testen kan door analogWrite(REDLEDPIN, 200); te schrijven, en dan pas aanpassen aan analogWrite(REDLEDPIN, ledVal);
volgende stap is om dan de verschillende values te laten verlopen.
dan heb je nog een probleem omdat sinus ook negatief kan worden, dus je moet scale gebruiken van -1 to 1 en uit van 0 tot 255

Welke &&? Ik heb helemaal geen && gebruikt. dat heeft hij innu zijn commentaar staan. Doe ik niets mee. Die andere formules heb ik gewoon gelaten asis.
Verder loopt die sinus van 0-180 graden en wordt dus nooit -1.

[Hanneman Profiel Privébericht]

Hey mannen, het is gelukt!

De eerste versie werkt.
Nu proberen meer geavanceerdere dingen ermee te doen, zodat ik ook daar weer van kan leren.

Dit is hem dan:
http://youtu.be/vkcp0T6neSA

Even offtopic: deze tutorialserie vind ik erg goed! http://www.youtube.com/watch?v=fCxzA9_kg6s
Misschien kunnen jullie die tutorials weer doorgeven aan andere beginners...

En de code:

//Library codes
#include <LiquidCrystal.h>

// PIN definitions LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// PIN definitions LEDS
#define REDLEDPIN 9
#define GREENLEDPIN 10
#define BLUELEDPIN 6

// PIN definitions Buttons
#define REDBUTTON 7
#define GREENBUTTON 13
#define BLUEBUTTON 8

// PIN definitions LDRs
#define pot1 0
#define pot2 1
#define pot3 2

// PIN definition POT voor Stroboscope
#define strobo 3

// FSM states
#define STATE_RED 0
#define STATE_GREEN 1
#define STATE_BLUE 2
#define blinking 3
#define customleds 4
#define randommode 5

//
// variables
//

// Finite state Machines
int fsm_state; // Switch variable
int fsm_state2; // Switch variable


//buttonvariables
int buttonState = 0; //button
int buttonState2 = 0; //button
int buttonState3 = 0; //button

// Variable for Strobo
int knobvalue1;
int knobvalue2;
int knobvalue3;
int ledState = LOW;
// How much time should the light stay on between delay times (in Micro Seconds)?
/* Big number = more blur, more perceived brightness
* Small number = less blur, less perceived brightness */
long on_time = 500;
// How much should we multiply the incoming value by?
/* Big number = less precision, more range
* Small number = more precision, less range */
long analog_value_multiplier = 1; // 15 Seems to work well for fast fans =)
// What should the minimum delay be (in Micro Seconds)?
// This sets the bottom delay range of the strobe, as a delay of 0 doesn't actually flash =P
// The strobe starts with this is the "fastest" mode, and goes slower from there, adding to the delay
long minimum_delay = 5; // 500 (half a millisecond) is a great superfast start
// Initialize the number to hold our strobe delay. Isn't used till we get to the main loop
long strobe_delay = 1000;


// Debouncing buttons
long lastDebounceTime = 0; // the last time the output pin was toggled
long debounceDelay = 50; // the debounce time; increase if the output flickers

// Random mode
float RGB1[3];
float RGB2[3];
float INC[3];
int red, green, blue;
#define VERTRAGINGkort 50 // Kleurverandering snelheid Aanpassen
#define VERTRAGINGlang 10 // Aanpassen om de snelheid te bepalen

//Fade Mode
int brightness = 0; // how bright the LED is
int fadeAmount = 0; // how many points to fade the LED by
unsigned long delayCtr = 0L;
#define VERTRAGING 1000 // 100 milliseconden voor de vertraging

//timers
unsigned long currentMillis = millis();
long previousMillis = 0;
long interval = 1000;

void setup() {

// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print("Mood light");
lcd.setCursor(0, 1);
lcd.print("Push a button");


Serial.begin(9600); //Begin serial communcation

pinMode(REDLEDPIN, OUTPUT);
pinMode(GREENLEDPIN, OUTPUT);
pinMode(BLUELEDPIN, OUTPUT);
pinMode(REDBUTTON, INPUT);
pinMode(GREENBUTTON, INPUT);
pinMode(BLUEBUTTON, INPUT);

digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);

}

void loop() {
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0, 1);

// FSM states
switch(fsm_state) {

case STATE_RED:

buttonState = digitalRead(REDBUTTON);
if (buttonState == HIGH) {
digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);
fsm_state2 = blinking;
}
else
{
fsm_state = STATE_GREEN;
}
break;

case STATE_GREEN:

buttonState2 = digitalRead(GREENBUTTON);
if (buttonState2 == HIGH) {
digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);
fsm_state2 = customleds;
}
else
{
fsm_state = STATE_BLUE;
}
break;

case STATE_BLUE:

buttonState3 = digitalRead(BLUEBUTTON);
if (buttonState3 == HIGH) {
digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);
fsm_state2 = randommode;
}
else
{
fsm_state = STATE_RED;
}
break;
}
switch(fsm_state2){

case blinking:

buttonState2 = digitalRead(GREENBUTTON);
if (buttonState2 == HIGH) {
digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);
fsm_state2 = customleds;
}
else
{
fsm_state = STATE_RED;
}
buttonState3 = digitalRead(BLUEBUTTON);
if (buttonState3 == HIGH) {
digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);
fsm_state2 = randommode;
}
else
{
fsm_state = STATE_BLUE;
}

lcd.println("Strobe Mode ");

strobe_delay = minimum_delay + analogRead(strobo) * analog_value_multiplier;

currentMillis = millis();

if(currentMillis - previousMillis > strobe_delay) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW)
brightness = 255;
ledState = brightness;
delayMicroseconds(on_time);
}
else
{
ledState = LOW;
}

knobvalue1 = analogRead(pot1);
knobvalue2 = analogRead(pot2);
knobvalue3 = analogRead(pot3);



if (knobvalue1 <155) {
analogWrite(REDLEDPIN, LOW);
}
else
{
if (millis() > delayCtr) {
analogWrite(REDLEDPIN, ledState);
}
}
if (knobvalue2 <155) {
analogWrite(GREENLEDPIN, LOW);
}
else
{
if (millis() > delayCtr) {
analogWrite(GREENLEDPIN, ledState);
}
}
if (knobvalue3 <155) {
analogWrite(BLUELEDPIN, LOW);
}
else
{
if (millis() > delayCtr) {
analogWrite(BLUELEDPIN, ledState);
}
}

if (strobe_delay > 10000){

delay((strobe_delay - on_time) / 1000);

}else{
delayMicroseconds(strobe_delay - on_time);
}

break;

case customleds:

buttonState = digitalRead(REDBUTTON);
if (buttonState == HIGH) {
digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);
fsm_state2 = blinking;
}
else
{
fsm_state = STATE_GREEN;
}

buttonState3 = digitalRead(BLUEBUTTON);
if (buttonState3 == HIGH) {
digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);
fsm_state2 = randommode;
}
else
{
fsm_state = STATE_RED;
}

lcd.println("Custom Mode ");

knobvalue1 = analogRead(pot1);
knobvalue2 = analogRead(pot2);
knobvalue3 = analogRead(pot3);

analogWrite(REDLEDPIN, knobvalue1);
analogWrite(GREENLEDPIN, knobvalue2);
analogWrite(BLUELEDPIN, knobvalue3);

break;

case randommode:

buttonState = digitalRead(REDBUTTON);
if (buttonState == HIGH) {
digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);
fsm_state2 = blinking;
}
else
{
fsm_state = STATE_GREEN;
}

buttonState2 = digitalRead(GREENBUTTON);
if (buttonState2 == HIGH) {
digitalWrite(REDLEDPIN, LOW);
digitalWrite(GREENLEDPIN, LOW);
digitalWrite(BLUELEDPIN, LOW);
fsm_state2 = customleds;
}
else
{
fsm_state = STATE_RED;
}
lcd.println("Random Mode ");

randomSeed(analogRead(5));
if (millis() > delayCtr) {
delayCtr = millis() + VERTRAGINGlang;
for (int x=0; x<3; x++) {
INC[x] = (RGB1[x] - RGB2[x]) / 256; }
for (int x=0; x<256; x++) {
red = int(RGB1[0]);
green = int(RGB1[1]);
blue = int(RGB1[2]);
analogWrite (REDLEDPIN, red);
analogWrite (GREENLEDPIN, green);
analogWrite (BLUELEDPIN, blue);
if (millis() > delayCtr) {
delayCtr = millis() + VERTRAGINGkort;
RGB1[0] -= INC[0];
RGB1[1] -= INC[1];
RGB1[2] -= INC[2];
}
for (int x=0; x<3; x++) {
RGB2[x] = random(556)-300;
RGB2[x] = constrain(RGB2[x], 0, 255);

}
}
}

break;

}

}

[nicoverduin Profiel PrivéberichtWebsite]

Als je nu de code tussen de code tags zet (zie volledige reactiepagina) dan is de code ook leesbaar. Nu ziet het er niet uit en is absoluut niet uitnodigend voor anderen om het te lezen.

[Hanneman Profiel Privébericht]

zoiets

Code: Alles selecteren

/**
 * @file   Mood_light.ino
 * @author    Hannes Beem
 * @date     14-05-2014
 *
 * @mainpage Mood_light
 * Moodlight met 3 Pushbuttons, drie leds in RGB kleuren en een menu op een LCD 16x2 Display
 *
 *
 * @par Version Control
 * \n $Revision$
 * \n $Author$
 * \n $Date$
 *
 * @par License info
 *
 * Druk op 1 van de knoppen om een modus te kiezen. Stroboscoop, Random (willekeurig) of Custom (zelf de kleur bepalen door aan de potmeters te draaien).
 *
 * Copyright (C) 2014  Hannes Beem
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Program : Mood_light  Copyright (C) 2014  Hannes Beem
 * This is free software, and you are welcome to redistribute it.
 *
 */

#ifdef __IN_ECLIPSE__               // required if developing in ECLIPSE
// Do not remove the include below
#include "Mood_light.h"
#endif
//
// Libraries
//
#include <LiquidCrystal.h> // Library voor de 16x2 LCD Display
//
// finite state machine state definitions
//
#define STATE_RED   0
#define STATE_GREEN 1
#define STATE_BLUE  2
#define blinking    3
#define customleds  4
#define randommode  5
//
// pin definitions
//
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);    // LCD Display Pins D2, D3, D4, D5, D11, D12
#define pot1       0               // Potmeter aan de Analoge ingang A0
#define pot2       1               // Potmeter aan de Analoge ingang A1
#define pot3       2               // Potmeter aan de Analoge ingang A2
#define strobo       3               // Potmeter aan de Analoge ingang A3
#define REDBUTTON 7                // Pushbutton voor knop aan Pin D 7
#define BLUEBUTTON 8               // Pushbutton voor knop aan Pin D 8
#define GREENBUTTON 13               // Pushbutton voor knop aan Pin D13
#define BLUELEDPIN 6                // Blauwe Led aan Pin D 6
#define REDLEDPIN 9                  // Rode Led aan Pin D 9
#define GREENLEDPIN 10               // Groene Led aan Pin D 10
//
// global variables
//
int fsm_state;                      // Switch variable
int fsm_state2;                   // Switch variable
int buttonState     = 0;             // Button State
int buttonState2    = 0;             // Button State
int buttonState3    = 0;             // Button State
int knobvalue1;                     // Waarde Potmeter 1
int knobvalue2;                     // Waarde Potmeter 2
int knobvalue3;                     // Waarde Potmeter 3
//
// variables voor het stroboscoop effect
//
int ledState       = LOW;
int brightness       = 0;             // De lichtsterkte van de LEDS
long on_time       = 500;
long minimum_delay    = 5;
long strobe_delay    = 1000;
long analog_value_multiplier = 1;
//
// variables voor Debouncing
//
long lastDebounceTime    =  0;          // Laatste keer dat de output Pin Aan gegaan is
long debounceDelay       = 50;          // Debounce tijd; Vergroten als de output wisselende resultaten geeft
//
// variables voor de Random mode
//
float RGB1[3];
float RGB2[3];
float INC[3];
int red, green, blue;
#define VERTRAGINGkort 50             // Kleurverandering snelheid Aanpassen
#define VERTRAGINGlang 10             // Aanpassen om de snelheid te bepalen
//
// timers
//
unsigned long currentMillis = millis();
long previousMillis = 0;
long interval = 1000;
unsigned long delayCtr = 0L;
/**
 * @name setup()
 * initialize the program
 */
void setup()
{
//
// LCD Display
//
lcd.begin(16, 2);                   // 16 kolommen en 2 rijen op de LCD Display
lcd.print("Mood light");             // Geeft tekst weer op de 1e rij van de LCD Display
lcd.setCursor(0, 1);               // Zet de cursor op de 1 kolom van de 2e rij op de LCD Display
lcd.print("Push a button");          // Geeft text weer op de 2e rij van de LCD Display
//
// open Seriele poort
//
Serial.begin(9600);                  // Baud snelheid is 9600
//
// outputs
//
pinMode(REDLEDPIN,       OUTPUT);
pinMode(GREENLEDPIN,    OUTPUT);
pinMode(BLUELEDPIN,    OUTPUT);
//
// inputs
//
pinMode(REDBUTTON,       INPUT);
pinMode(GREENBUTTON,    INPUT);
pinMode(BLUEBUTTON,      INPUT);
//
// leds uit
//
digitalWrite(REDLEDPIN,    LOW);
digitalWrite(GREENLEDPIN,   LOW);
digitalWrite(BLUELEDPIN,    LOW);
}
/**
 * @name loop()
 * main loop of program and runs endlessly
 */
void loop()
{
lcd.setCursor(0, 1);                // zet de cursor op de eerste kolom op de 2e rij
//
// finite state machine 1
//
switch(fsm_state) {
//
// state RED
//
case STATE_RED:
//
// knop voor stroboscoop modus
//
buttonState = digitalRead(REDBUTTON);
if (buttonState == HIGH) {
//
// zet alle leds uit
//
digitalWrite(REDLEDPIN,       LOW);
digitalWrite(GREENLEDPIN,    LOW);
digitalWrite(BLUELEDPIN,     LOW);
//
// ga naar state blinking (de stroboscoop modus) als de knop ingedrukt is
//
fsm_state2 = blinking;
}
else
{
//
// als de knop niet wordt ingedrukt... ga door naar state GREEN
//
fsm_state = STATE_GREEN;
}
//
// beeindig state RED
//
break;
//
// state GREEN
//
case STATE_GREEN:
//
// knop voor custom modus
//
buttonState2 = digitalRead(GREENBUTTON);
if (buttonState2 == HIGH) {
//
// zet alle leds uit
//
digitalWrite(REDLEDPIN,    LOW);
digitalWrite(GREENLEDPIN,    LOW);
digitalWrite(BLUELEDPIN,    LOW);
//
// ga naar state customleds (de custom modus) als de knop ingedrukt is
//
fsm_state2 = customleds;
}
else
{
//
// als de knop niet wordt ingedrukt... ga door naar state BLUE
//
fsm_state = STATE_BLUE;
}
//
// beeindig state RED
//
break;
//
// state BLUE
//
case STATE_BLUE:
//
// knop voor random modus
//
buttonState3 = digitalRead(BLUEBUTTON);
if (buttonState3 == HIGH) {
//
// zet alle leds uit
//
digitalWrite(REDLEDPIN,    LOW);
digitalWrite(GREENLEDPIN,   LOW);
digitalWrite(BLUELEDPIN,   LOW);
//
// ga naar state randommode (de random modus) als de knop ingedrukt is
//
fsm_state2 = randommode;
}
else
{
//
// als de knop niet wordt ingedrukt... ga terug naar state RED
//
fsm_state = STATE_RED;
}
//
// beeindig state BLUE
//
break;
}
//
// einde finite state machine 1 start finite state machine 2
//
switch(fsm_state2){
//
// state blinking
//
case blinking:
//
// knop voor custom modus
//
buttonState2 = digitalRead(GREENBUTTON);
if (buttonState2 == HIGH) {
//
// zet alle leds uit
//
digitalWrite(REDLEDPIN,    LOW);
digitalWrite(GREENLEDPIN,    LOW);
digitalWrite(BLUELEDPIN,    LOW);
//
// ga naar state customleds (de custom modus) als de knop ingedrukt is
//
fsm_state2 = customleds;
}
else
{
//
// als de knop niet wordt ingedrukt... ga terug naar state RED
//
fsm_state = STATE_RED;
}
buttonState3 = digitalRead(BLUEBUTTON);
if (buttonState3 == HIGH) {
//
// zet alle leds uit
//
digitalWrite(REDLEDPIN,    LOW);
digitalWrite(GREENLEDPIN,   LOW);
digitalWrite(BLUELEDPIN,   LOW);
//
// ga naar state randommode (de random modus) als de knop ingedrukt is
//
fsm_state2 = randommode;
}
else
{
//
// als de knop niet wordt ingedrukt... ga terug naar state BLUE
//
fsm_state = STATE_BLUE;
}
//
// Geef Strobe mode weer op de LCD Display
//
lcd.println("Strobe Mode ");
//
// koppel de tijdsduur tussen het aangaan van de leds aan de analoge ingang strobo
//
strobe_delay = minimum_delay + analogRead(strobo) * analog_value_multiplier; // strobe_delay is nu afhankelijk van de waarde van de potmeter
//
// roep de huidige tijd in millis aan
//
currentMillis = millis();
//
// als de tijdsduur strobe_delay verstreken is dan
//
if(currentMillis - previousMillis > strobe_delay) {
//
// sla de laatste keer dat de leds aan geweest zijn op
//
previousMillis = currentMillis;
//
// als de leds uit zijn, zet ze aan en anders om
//
if (ledState == LOW)
//
// zet de leds op maximale lichtsterkte
//
brightness = 255;
ledState = brightness;
//
// vertraging zodat de Leds niet te snel weer doven
//
delayMicroseconds(on_time);
}
else
{
//
// als de leds niet aangezet worden, blijven ze uit
//
ledState = LOW;
}
//
// koppel een variabele aan hetgeen dat uitgelezen wordt van de analoge ingangen met de in totaal 3 potmeters
//
knobvalue1 = analogRead(pot1);
knobvalue2 = analogRead(pot2);
knobvalue3 = analogRead(pot3);
//
// als de waarde van variabele knobvalue1 lager is dan 155, zet de rode led uit
//
if (knobvalue1 <155) {
analogWrite(REDLEDPIN, LOW);
}
else
{
//
// als de waarde hoger is dan 155 pas de vertraging toe en zet daarna de rode led aan
//
if (millis() > delayCtr) {
analogWrite(REDLEDPIN, ledState);
   }
}
//
// als de waarde van variabele knobvalue2 lager is dan 155, zet de groene led uit
//
if (knobvalue2 <155) {
analogWrite(GREENLEDPIN, LOW);
}
else
{
//
// als de waarde hoger is dan 155 pas de vertraging toe en zet daarna de groene led aan
//
if (millis() > delayCtr) {
analogWrite(GREENLEDPIN, ledState);
   }
}
//
// als de waarde van variabele knobvalue3 lager is dan 155, zet de blauwe led uit
//
if (knobvalue3 <155) {
analogWrite(BLUELEDPIN, LOW);
}
else
{
//
// als de waarde hoger is dan 155 pas de vertraging toe en zet daarna de blauwe led aan
//
if (millis() > delayCtr) {
analogWrite(BLUELEDPIN, ledState);
   }
}
//
// begrenzen van de vertraging voordat de leds weer doven
//
if (strobe_delay > 10000){
delay((strobe_delay - on_time) / 1000);
}
else
{
delayMicroseconds(strobe_delay - on_time);
}
//
// einde stroboscoop modus
//
break;
//
// state customleds
//
case customleds:
//
// knop voor stroboscoop modus
//
buttonState = digitalRead(REDBUTTON);
if (buttonState == HIGH) {
//
// zet alle leds uit
//
digitalWrite(REDLEDPIN,    LOW);
digitalWrite(GREENLEDPIN,    LOW);
digitalWrite(BLUELEDPIN,   LOW);
//
// ga naar state blinking (de stroboscoop modus) als de knop ingedrukt is
//
fsm_state2 = blinking;
}
else
{
//
// als de knop niet wordt ingedrukt... ga terug naar state GREEN
//
fsm_state = STATE_GREEN;
}
//
// knop voor random modus
//
buttonState3 = digitalRead(BLUEBUTTON);
if (buttonState3 == HIGH) {
//
// zet alle leds uit
//
digitalWrite(REDLEDPIN,    LOW);
digitalWrite(GREENLEDPIN,    LOW);
digitalWrite(BLUELEDPIN,   LOW);
//
// ga naar state randommode (de random modus) als de knop ingedrukt is
//
fsm_state2 = randommode;
}
else
{
//
// als de knop niet wordt ingedrukt... ga terug naar state RED
//
fsm_state = STATE_RED;
}
//
// Geef custom mode weer op de LCD Display
//
lcd.println("Custom Mode ");
//
// koppel een variabele aan hetgeen dat uitgelezen wordt van de analoge ingangen met de in totaal 3 potmeters
//
knobvalue1 = analogRead(pot1);
knobvalue2 = analogRead(pot2);
knobvalue3 = analogRead(pot3);
//
// leds branden zo fel als je instelt met de potmeters en maken zo de kleur
//
analogWrite(REDLEDPIN,       knobvalue1);
analogWrite(GREENLEDPIN,    knobvalue2);
analogWrite(BLUELEDPIN,    knobvalue3);
//
// einde custom modus
//
break;
//
// state randommode
//
case randommode:
//
// knop voor stroboscoop modus
//
buttonState = digitalRead(REDBUTTON);
if (buttonState == HIGH) {
//
// zet alle leds uit
//
digitalWrite(REDLEDPIN,      LOW);
digitalWrite(GREENLEDPIN,   LOW);
digitalWrite(BLUELEDPIN,    LOW);
//
// ga naar state blinking (de stroboscoop modus) als de knop ingedrukt is
//
fsm_state2 = blinking;
}
else
{
//
// als de knop niet wordt ingedrukt... ga terug naar state GREEN
//
fsm_state = STATE_GREEN;
}
//
// knop voor custom modus
//
buttonState2 = digitalRead(GREENBUTTON);
if (buttonState2 == HIGH) {
//
// zet alle leds uit
//
digitalWrite(REDLEDPIN,    LOW);
digitalWrite(GREENLEDPIN,   LOW);
digitalWrite(BLUELEDPIN,    LOW);
//
// ga naar state customleds (de custom modus) als de knop ingedrukt is
//
fsm_state2 = customleds;
}
else
{
//
// als de knop niet wordt ingedrukt... ga terug naar state RED
//
fsm_state = STATE_RED;
}
//
// Geef random mode weer op de LCD Display
//
lcd.println("Random Mode ");
//
// omdat er niets is aangesloten op analoge pin 5 komen er willekeurige waarden binnen.
// daar maakt deze modus gebruik van en maakt met de RGB leds willekeurig kleuren.
// verder begrijp ik niet veel van onderstaande code dit bewerkstelligt.
//
randomSeed(analogRead(5));
//
// stel een vertraging in
//
if (millis() > delayCtr) {
//
// vertraginglang (zie de duur bovenin) bepaalt mede hoe snel de kleur veranderd
//
delayCtr = millis() + VERTRAGINGlang;
for (int x=0; x<3; x++) {
INC[x] = (RGB1[x] - RGB2[x]) / 256; }
for (int x=0; x<256; x++) {
red = int(RGB1[0]);
green = int(RGB1[1]);
blue = int(RGB1[2]);
analogWrite (REDLEDPIN,    red);
analogWrite (GREENLEDPIN,    green);
analogWrite (BLUELEDPIN,    blue);
//
// stel een vertraging in
//
if (millis() > delayCtr) {
//
// vertraginglang (zie de duur bovenin) bepaalt mede hoe snel de kleur veranderd
//
delayCtr = millis() + VERTRAGINGkort;
RGB1[0] -= INC[0];
RGB1[1] -= INC[1];
RGB1[2] -= INC[2];
}
for (int x=0; x<3; x++) {
RGB2[x] = random(556)-300;
RGB2[x] = constrain(RGB2[x], 0, 255);
      }
   }
}
//
// einde random mode
//
break;
   }
}


[nicoverduin Profiel PrivéberichtWebsite]

Als je de geformatteerde code erin stop krijg je het ff mooier :

Code: Alles selecteren

/**
 * @file   Mood_light.ino
 * @author    Hannes Beem
 * @date     14-05-2014
 *
 * @mainpage Mood_light
 * Moodlight met 3 Pushbuttons, drie leds in RGB kleuren en een menu op een LCD 16x2 Display
 *
 *
 * @par Version Control
 * \n $Revision$
 * \n $Author$
 * \n $Date$
 *
 * @par License info
 *
 * Druk op 1 van de knoppen om een modus te kiezen. Stroboscoop, Random (willekeurig) of Custom (zelf de kleur bepalen door aan de potmeters te draaien).
 *
 * Copyright (C) 2014  Hannes Beem
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Program : Mood_light  Copyright (C) 2014  Hannes Beem
 * This is free software, and you are welcome to redistribute it.
 *
 */

#ifdef __IN_ECLIPSE__               // required if developing in ECLIPSE
// Do not remove the include below
#include "Mood_light.h"
#endif
//
// Libraries
//
#include <LiquidCrystal.h> // Library voor de 16x2 LCD Display
//
// finite state machine state definitions
//
#define STATE_RED   0
#define STATE_GREEN 1
#define STATE_BLUE  2
#define blinking    3
#define customleds  4
#define randommode  5
//
// pin definitions
//
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // LCD Display Pins D2, D3, D4, D5, D11, D12
#define pot1       0               // Potmeter aan de Analoge ingang A0
#define pot2       1               // Potmeter aan de Analoge ingang A1
#define pot3       2               // Potmeter aan de Analoge ingang A2
#define strobo       3               // Potmeter aan de Analoge ingang A3
#define REDBUTTON 7                // Pushbutton voor knop aan Pin D 7
#define BLUEBUTTON 8               // Pushbutton voor knop aan Pin D 8
#define GREENBUTTON 13               // Pushbutton voor knop aan Pin D13
#define BLUELEDPIN 6                // Blauwe Led aan Pin D 6
#define REDLEDPIN 9                  // Rode Led aan Pin D 9
#define GREENLEDPIN 10               // Groene Led aan Pin D 10
//
// global variables
//
int fsm_state;                      // Switch variable
int fsm_state2;                   // Switch variable
int buttonState = 0;             // Button State
int buttonState2 = 0;             // Button State
int buttonState3 = 0;             // Button State
int knobvalue1;                     // Waarde Potmeter 1
int knobvalue2;                     // Waarde Potmeter 2
int knobvalue3;                     // Waarde Potmeter 3
//
// variables voor het stroboscoop effect
//
int ledState = LOW;
int brightness = 0;             // De lichtsterkte van de LEDS
long on_time = 500;
long minimum_delay = 5;
long strobe_delay = 1000;
long analog_value_multiplier = 1;
//
// variables voor Debouncing
//
long lastDebounceTime = 0;       // Laatste keer dat de output Pin Aan gegaan is
long debounceDelay = 50; // Debounce tijd; Vergroten als de output wisselende resultaten geeft
//
// variables voor de Random mode
//
float RGB1[3];
float RGB2[3];
float INC[3];
int red, green, blue;
#define VERTRAGINGkort 50             // Kleurverandering snelheid Aanpassen
#define VERTRAGINGlang 10             // Aanpassen om de snelheid te bepalen
//
// timers
//
unsigned long currentMillis = millis();
long previousMillis = 0;
long interval = 1000;
unsigned long delayCtr = 0L;
/**
 * @name setup()
 * initialize the program
 */
void setup() {
   //
   // LCD Display
   //
   lcd.begin(16, 2);                  // 16 kolommen en 2 rijen op de LCD Display
   lcd.print("Mood light");   // Geeft tekst weer op de 1e rij van de LCD Display
   lcd.setCursor(0, 1); // Zet de cursor op de 1 kolom van de 2e rij op de LCD Display
   lcd.print("Push a button"); // Geeft text weer op de 2e rij van de LCD Display
   //
   // open Seriele poort
   //
   Serial.begin(9600);                  // Baud snelheid is 9600
   //
   // outputs
   //
   pinMode(REDLEDPIN, OUTPUT);
   pinMode(GREENLEDPIN, OUTPUT);
   pinMode(BLUELEDPIN, OUTPUT);
   //
   // inputs
   //
   pinMode(REDBUTTON, INPUT);
   pinMode(GREENBUTTON, INPUT);
   pinMode(BLUEBUTTON, INPUT);
   //
   // leds uit
   //
   digitalWrite(REDLEDPIN, LOW);
   digitalWrite(GREENLEDPIN, LOW);
   digitalWrite(BLUELEDPIN, LOW);
}
/**
 * @name loop()
 * main loop of program and runs endlessly
 */
void loop() {
   lcd.setCursor(0, 1);          // zet de cursor op de eerste kolom op de 2e rij
   //
   // finite state machine 1
   //
   switch (fsm_state) {
   //
   // state RED
   //
   case STATE_RED:
      //
      // knop voor stroboscoop modus
      //
      buttonState = digitalRead(REDBUTTON);
      if (buttonState == HIGH) {
         //
         // zet alle leds uit
         //
         digitalWrite(REDLEDPIN, LOW);
         digitalWrite(GREENLEDPIN, LOW);
         digitalWrite(BLUELEDPIN, LOW);
         //
         // ga naar state blinking (de stroboscoop modus) als de knop ingedrukt is
         //
         fsm_state2 = blinking;
      } else {
         //
         // als de knop niet wordt ingedrukt... ga door naar state GREEN
         //
         fsm_state = STATE_GREEN;
      }
      //
      // beeindig state RED
      //
      break;
      //
      // state GREEN
      //
   case STATE_GREEN:
      //
      // knop voor custom modus
      //
      buttonState2 = digitalRead(GREENBUTTON);
      if (buttonState2 == HIGH) {
         //
         // zet alle leds uit
         //
         digitalWrite(REDLEDPIN, LOW);
         digitalWrite(GREENLEDPIN, LOW);
         digitalWrite(BLUELEDPIN, LOW);
         //
         // ga naar state customleds (de custom modus) als de knop ingedrukt is
         //
         fsm_state2 = customleds;
      } else {
         //
         // als de knop niet wordt ingedrukt... ga door naar state BLUE
         //
         fsm_state = STATE_BLUE;
      }
      //
      // beeindig state RED
      //
      break;
      //
      // state BLUE
      //
   case STATE_BLUE:
      //
      // knop voor random modus
      //
      buttonState3 = digitalRead(BLUEBUTTON);
      if (buttonState3 == HIGH) {
         //
         // zet alle leds uit
         //
         digitalWrite(REDLEDPIN, LOW);
         digitalWrite(GREENLEDPIN, LOW);
         digitalWrite(BLUELEDPIN, LOW);
         //
         // ga naar state randommode (de random modus) als de knop ingedrukt is
         //
         fsm_state2 = randommode;
      } else {
         //
         // als de knop niet wordt ingedrukt... ga terug naar state RED
         //
         fsm_state = STATE_RED;
      }
      //
      // beeindig state BLUE
      //
      break;
   }
   //
   // einde finite state machine 1 start finite state machine 2
   //
   switch (fsm_state2) {
   //
   // state blinking
   //
   case blinking:
      //
      // knop voor custom modus
      //
      buttonState2 = digitalRead(GREENBUTTON);
      if (buttonState2 == HIGH) {
         //
         // zet alle leds uit
         //
         digitalWrite(REDLEDPIN, LOW);
         digitalWrite(GREENLEDPIN, LOW);
         digitalWrite(BLUELEDPIN, LOW);
         //
         // ga naar state customleds (de custom modus) als de knop ingedrukt is
         //
         fsm_state2 = customleds;
      } else {
         //
         // als de knop niet wordt ingedrukt... ga terug naar state RED
         //
         fsm_state = STATE_RED;
      }
      buttonState3 = digitalRead(BLUEBUTTON);
      if (buttonState3 == HIGH) {
         //
         // zet alle leds uit
         //
         digitalWrite(REDLEDPIN, LOW);
         digitalWrite(GREENLEDPIN, LOW);
         digitalWrite(BLUELEDPIN, LOW);
         //
         // ga naar state randommode (de random modus) als de knop ingedrukt is
         //
         fsm_state2 = randommode;
      } else {
         //
         // als de knop niet wordt ingedrukt... ga terug naar state BLUE
         //
         fsm_state = STATE_BLUE;
      }
      //
      // Geef Strobe mode weer op de LCD Display
      //
      lcd.println("Strobe Mode ");
      //
      // koppel de tijdsduur tussen het aangaan van de leds aan de analoge ingang strobo
      //
      strobe_delay = minimum_delay + analogRead(strobo) * analog_value_multiplier; // strobe_delay is nu afhankelijk van de waarde van de potmeter
      //
      // roep de huidige tijd in millis aan
      //
      currentMillis = millis();
      //
      // als de tijdsduur strobe_delay verstreken is dan
      //
      if (currentMillis - previousMillis > strobe_delay) {
         //
         // sla de laatste keer dat de leds aan geweest zijn op
         //
         previousMillis = currentMillis;
         //
         // als de leds uit zijn, zet ze aan en anders om
         //
         if (ledState == LOW)
            //
            // zet de leds op maximale lichtsterkte
            //
            brightness = 255;
         ledState = brightness;
         //
         // vertraging zodat de Leds niet te snel weer doven
         //
         delayMicroseconds(on_time);
      } else {
         //
         // als de leds niet aangezet worden, blijven ze uit
         //
         ledState = LOW;
      }
      //
      // koppel een variabele aan hetgeen dat uitgelezen wordt van de analoge ingangen met de in totaal 3 potmeters
      //
      knobvalue1 = analogRead(pot1);
      knobvalue2 = analogRead(pot2);
      knobvalue3 = analogRead(pot3);
      //
      // als de waarde van variabele knobvalue1 lager is dan 155, zet de rode led uit
      //
      if (knobvalue1 < 155) {
         analogWrite(REDLEDPIN, LOW);
      } else {
         //
         // als de waarde hoger is dan 155 pas de vertraging toe en zet daarna de rode led aan
         //
         if (millis() > delayCtr) {
            analogWrite(REDLEDPIN, ledState);
         }
      }
      //
      // als de waarde van variabele knobvalue2 lager is dan 155, zet de groene led uit
      //
      if (knobvalue2 < 155) {
         analogWrite(GREENLEDPIN, LOW);
      } else {
         //
         // als de waarde hoger is dan 155 pas de vertraging toe en zet daarna de groene led aan
         //
         if (millis() > delayCtr) {
            analogWrite(GREENLEDPIN, ledState);
         }
      }
      //
      // als de waarde van variabele knobvalue3 lager is dan 155, zet de blauwe led uit
      //
      if (knobvalue3 < 155) {
         analogWrite(BLUELEDPIN, LOW);
      } else {
         //
         // als de waarde hoger is dan 155 pas de vertraging toe en zet daarna de blauwe led aan
         //
         if (millis() > delayCtr) {
            analogWrite(BLUELEDPIN, ledState);
         }
      }
      //
      // begrenzen van de vertraging voordat de leds weer doven
      //
      if (strobe_delay > 10000) {
         delay((strobe_delay - on_time) / 1000);
      } else {
         delayMicroseconds(strobe_delay - on_time);
      }
      //
      // einde stroboscoop modus
      //
      break;
      //
      // state customleds
      //
   case customleds:
      //
      // knop voor stroboscoop modus
      //
      buttonState = digitalRead(REDBUTTON);
      if (buttonState == HIGH) {
         //
         // zet alle leds uit
         //
         digitalWrite(REDLEDPIN, LOW);
         digitalWrite(GREENLEDPIN, LOW);
         digitalWrite(BLUELEDPIN, LOW);
         //
         // ga naar state blinking (de stroboscoop modus) als de knop ingedrukt is
         //
         fsm_state2 = blinking;
      } else {
         //
         // als de knop niet wordt ingedrukt... ga terug naar state GREEN
         //
         fsm_state = STATE_GREEN;
      }
      //
      // knop voor random modus
      //
      buttonState3 = digitalRead(BLUEBUTTON);
      if (buttonState3 == HIGH) {
         //
         // zet alle leds uit
         //
         digitalWrite(REDLEDPIN, LOW);
         digitalWrite(GREENLEDPIN, LOW);
         digitalWrite(BLUELEDPIN, LOW);
         //
         // ga naar state randommode (de random modus) als de knop ingedrukt is
         //
         fsm_state2 = randommode;
      } else {
         //
         // als de knop niet wordt ingedrukt... ga terug naar state RED
         //
         fsm_state = STATE_RED;
      }
      //
      // Geef custom mode weer op de LCD Display
      //
      lcd.println("Custom Mode ");
      //
      // koppel een variabele aan hetgeen dat uitgelezen wordt van de analoge ingangen met de in totaal 3 potmeters
      //
      knobvalue1 = analogRead(pot1);
      knobvalue2 = analogRead(pot2);
      knobvalue3 = analogRead(pot3);
      //
      // leds branden zo fel als je instelt met de potmeters en maken zo de kleur
      //
      analogWrite(REDLEDPIN, knobvalue1);
      analogWrite(GREENLEDPIN, knobvalue2);
      analogWrite(BLUELEDPIN, knobvalue3);
      //
      // einde custom modus
      //
      break;
      //
      // state randommode
      //
   case randommode:
      //
      // knop voor stroboscoop modus
      //
      buttonState = digitalRead(REDBUTTON);
      if (buttonState == HIGH) {
         //
         // zet alle leds uit
         //
         digitalWrite(REDLEDPIN, LOW);
         digitalWrite(GREENLEDPIN, LOW);
         digitalWrite(BLUELEDPIN, LOW);
         //
         // ga naar state blinking (de stroboscoop modus) als de knop ingedrukt is
         //
         fsm_state2 = blinking;
      } else {
         //
         // als de knop niet wordt ingedrukt... ga terug naar state GREEN
         //
         fsm_state = STATE_GREEN;
      }
      //
      // knop voor custom modus
      //
      buttonState2 = digitalRead(GREENBUTTON);
      if (buttonState2 == HIGH) {
         //
         // zet alle leds uit
         //
         digitalWrite(REDLEDPIN, LOW);
         digitalWrite(GREENLEDPIN, LOW);
         digitalWrite(BLUELEDPIN, LOW);
         //
         // ga naar state customleds (de custom modus) als de knop ingedrukt is
         //
         fsm_state2 = customleds;
      } else {
         //
         // als de knop niet wordt ingedrukt... ga terug naar state RED
         //
         fsm_state = STATE_RED;
      }
      //
      // Geef random mode weer op de LCD Display
      //
      lcd.println("Random Mode ");
      //
      // omdat er niets is aangesloten op analoge pin 5 komen er willekeurige waarden binnen.
      // daar maakt deze modus gebruik van en maakt met de RGB leds willekeurig kleuren.
      // verder begrijp ik niet veel van onderstaande code dit bewerkstelligt.
      //
      randomSeed(analogRead(5));
      //
      // stel een vertraging in
      //
      if (millis() > delayCtr) {
         //
         // vertraginglang (zie de duur bovenin) bepaalt mede hoe snel de kleur veranderd
         //
         delayCtr = millis() + VERTRAGINGlang;
         for (int x = 0; x < 3; x++) {
            INC[x] = (RGB1[x] - RGB2[x]) / 256;
         }
         for (int x = 0; x < 256; x++) {
            red = int(RGB1[0]);
            green = int(RGB1[1]);
            blue = int(RGB1[2]);
            analogWrite(REDLEDPIN, red);
            analogWrite(GREENLEDPIN, green);
            analogWrite(BLUELEDPIN, blue);
            //
            // stel een vertraging in
            //
            if (millis() > delayCtr) {
               //
               // vertraginglang (zie de duur bovenin) bepaalt mede hoe snel de kleur veranderd
               //
               delayCtr = millis() + VERTRAGINGkort;
               RGB1[0] -= INC[0];
               RGB1[1] -= INC[1];
               RGB1[2] -= INC[2];
            }
            for (int x = 0; x < 3; x++) {
               RGB2[x] = random(556) - 300;
               RGB2[x] = constrain(RGB2[x], 0, 255);
            }
         }
      }
      //
      // einde random mode
      //
      break;
   }
}