wachten op input (arduino uno en dmx512 board)

Hallo,

ik ben bezig met een project voor carnaval. we hebben een arduino uno en een dmx512 board om onze led dmx lampen aan te sturen.

het is de bedoeling dat de led lampen eerst de kleur rood geven en wanneer ik met de plc een signaal geef naar de arduino dat de kleur veranderd in de kleur blauw.

ik heb hier een programma voor gevonden op internet die ongeveer doet wat wij willen.

ik zal eerst uitleggen wat het nu doet en wat ik graag zou willen dat het programma gaat doen.
onderaan vind u het complete programma.

// The color fading pattern

int RedList[]    = {255,   10,  0,     0,  };
int GreenList[] = {0,      0,    0,     0,  };
int BlueList[]   = {0,      0,    255,  255,};

dit is het patroon wat het programma volgt, eerst word rood op 255 gezet en vervolgens word deze gedimd naar 10. daarna word blauw op 255 gezet.

dit zijn de 2 kleuren die wij nodig hebben.

nu is de uitdaging om te zorgen dat wanneer hij de kleur rood naar 255 heeft gezet dat hij wacht op een digitale input. in het programma hieronder heb ik pin 13 gepakt maar dit kan eventueel ook een andere zijn. het programma werk zoals hij hieronder staat alleen kan ik hem niet stopzetten.

hieronder even een verduidelijking van hoe we het ongeveer willen.

// The color fading pattern

int RedList[]   =  {255, (stop, wacht op input)  10,  0,     0,  };
int GreenList[] = {0,    (stop, wacht op input)  0,    0,     0,  };
int BlueList[]  =  {0,    (stop, wacht op input)  0,    255,  255,};

kan iemand mij hier mee helpen? of heeft iemand een tip hoe ik dit anders kan doen?

ik ben zelf nieuw met de programmeertaal en ik ben nog aan het leren om met de code te werken.

de hele arduino code:

// - - - - -
// DmxSerial - A hardware supported interface to DMX.
// DmxSerialSend.ino: Sample DMX application for sending 3 DMX values:
// address 1 (red) -> also available on PWM Port 9
// address 2 (green) -> also available on PWM Port 6
// address 3 (blue) -> also available on PWM Port 5
// 
// Copyright (c) 2011 by Matthias Hertel, http://www.mathertel.de
// This work is licensed under a BSD style license. See http://www.mathertel.de/License.aspx
// 
// Documentation and samples are available at http://www.mathertel.de/Arduino
// 25.07.2011 creation of the DmxSerial library.
// 10.09.2011 fully control the serial hardware register
//            without using the Arduino Serial (HardwareSerial) class to avoid ISR implementation conflicts.
// 01.12.2011 include file and extension changed to work with the Arduino 1.0 environment
// - - - - -

#include <DMXSerial.h>

int plc = 13;
int val = 0;

// Constants for demo program

;const int RedPin =    9;  // PWM output pin for Red Light.
const int GreenPin =  6;  // PWM output pin for Green Light.
const int BluePin =   5;  // PWM output pin for Blue Light.

// The color fading pattern

int RedList[]   = {255,   10,  0,    0,  };
int GreenList[] = {0,     0,   0,    0,  };
int BlueList[]  = {0,     0,   255,  255,};

int RedLevel, GreenLevel, BlueLevel;

int RedNow = 0;
int GreenNow = 0;
int BlueNow = 0;

int state = 0;

void setup() {
  DMXSerial.init(DMXController);
 
  pinMode(plc,      INPUT);
  pinMode(RedPin,   OUTPUT); // sets the digital pin as output
  pinMode(GreenPin, OUTPUT);
  pinMode(BluePin,  OUTPUT);
} // setup


// loop through the rainbow colors 
void loop() {
  val = digitalRead(plc);   // read the input pin
  
  RedLevel = RedList[state];
  GreenLevel = GreenList[state];
  BlueLevel = BlueList[state];
 
  if ((RedLevel == RedNow) && (GreenLevel == GreenNow) && (BlueLevel == BlueNow)) {
    state += 1;
    if (state == 6)
      state = 0;
   
  } else {
    if (RedNow < RedLevel)  RedNow++; 
    if (RedNow > RedLevel)  RedNow--; 
    DMXSerial.write(1, RedNow);
    analogWrite(RedPin,   RedNow); 

    if (GreenNow < GreenLevel)  GreenNow++; 
    if (GreenNow > GreenLevel)  GreenNow--; 
    DMXSerial.write(2, GreenNow);
    analogWrite(GreenPin, GreenNow); 

    if (BlueNow < BlueLevel)  BlueNow++; 
    if (BlueNow > BlueLevel)  BlueNow--; 
    DMXSerial.write(3, BlueNow);
    analogWrite(BluePin,  BlueNow); 
   
  } // if
  
  delay(30); // wait a little bit
} // loop

alvast hartelijk dank voor de moeite en reacties

Hoi.

Het programma dat je nu hebt, doet volgens mij meer dan wat je wil.
Maar dat even in het midden.
Je wil een signaal geven met je PLC.
Hoe ga je dat dan doen ?
Als het om een digitaal signaaltje gaat, dan moet je dat dus binnen halen.
En wanneer je dat hebt binnen gehaald dan kun je je dim actie verder voeren.

Dus daar moet je eens over nadenken.
Je bent dus bezig met DMX, en gebruikt een locale LED als monitor om mee te kijken wat er buiten gebeurt.
Das alvast een leuke hulp en debug mogelijkheid.
Ik zie ook dat je iets met pin 13 wil doen omdat je die gereserveerd hebt, maar je doet er nu nog niets mee.
De truc is dus dat je op dit moment onvoorwaardelijk je dim actie uitvoert.
Je wil het voorwaardelijk doen.
Daarom heb je er zeker ook nog een verdwaalde if statement in staan die uitgecommenteerd is.
Als je dit maar 1 keer wil doen tijdens je optocht, dan kun je kijken of de voorwaarde al een keer is voorgekomen en dat dan opslaan.
Als je de kleur wil bepalen aan de hand van de voorwaarde die meerdere malen kan veranderen, dan kun je eventueel het opslaan overslaan,
Je kunt ook opslaan en als je de hele cyclus doorlopen hebt de opgeslagen waarde resetten.
Zo heb je dan zekerheid dat de actie leidt tot een volledige dim cyclus, en daarna eventueel besloten kan worden tot een volgende actie.

Nogmaals, je moet de dim actie dus afhankelijk maken van iets, en mogelijk is iets in dit geval een opgeslagen waarde.

het gaat hier om led par lampen die dmx aangestuurd worden.

ik wil het signaal simpel geven door de 5v van de arduino te pakken en en deze over een schakelcontact van de plc (solid state relais) te laten gaan en deze naar bijvoorbeeld pin13 (of een anderre pin) te laten gaan

@mas3

dit wil ik inderdaad realiseren, nu is het probleem dat ik totaal niet weet hoe ik dit moet doen en met welke commando’s

m.v.g
Erik Koevoets

Hoi Erik.

Ik raad je aan om je schakel contact naar GND te laten schakelen, en niet naar 5 volt.
Dat je daar aan dacht is een logische gedachtegang, maar je kunt het ook op de door mij voorgestelde manier doen.
Door dat te doen, spaar je jezelf onderdelen uit en creëer je een stabieler ingangssignaal (wanneer niet actief).

Je Arduino kan per ingang namelijk een signaal naar hoog trekken als er geen ander nivo op word aangeboden.
Dat heet pull up, je kunt zoeken naar die term hier op de site.

Ik raad je verder ook aan om eens in de voorbeeld sketches te kijken die je bij de Arduino cadeau hebt gekregen.
Daar leer je namelijk hoe je signalen kunt binnen halen en er iets mee kunt doen.

Iets doen kan dus zijn dat je een variabele maakt die weergeeft of je een druk op de knop hebt gezien.
Die variabele geef je dan een passende naam zoals 'actief'.
Jij kunt daarna bepalen wanneer je 'actief' actief maakt of weer deactiveert.

Je hebt zojuist gezegd dat dat inderdaad is wat je wil, maar ik heb meerdere mogelijkheden genoemd.
Daarmee weet ik dus nog niet wat je wil.
Dit zeg ik omdat het heel belangrijk is voor jezelf om te weten wat je wil bereiken.
Je kunt, door er over na te denken wat je nou eigenlijk precies wil doen, al een heel eind komen om een voorstelling te maken hoe je dat dan gaat doen.
Het is mijn bedoeling dat je dat nadenken ook doet, want zo leer je er van.
Daarom ga ik niet een stukje code voor je uitschrijven, want dan sta je voor de volgende optocht weer hier om te vragen hoe je een groene lamp kunt laten branden (bij wijze van spreken natuurlijk).
Je bent van harte welkom om je nieuwe stuk code te laten zien en om om commentaar daarop te vragen.
De meesten die hier regelmatig komen helpen je er graag mee.

wat ik wil bereiken is eingelijk heel simpel.

eerst moeten de led parren rood geven en wanneer ik een digitaal signaal geef moet hij faden naar blauw.

dat is eingelijk alles wat hij moet doen.

ik heb al gekeken naar de standaard voorbeelden in de arduino software maar ik kom er niet aan uit hoe ik dit in dit programma kan realiseren. dat is het probleem waar ik mee zit.

m.v.g
Erik Koevoets

Kijk naar het voorbeeld StateChangeDetection.

Daar zit in wat je nodig hebt.
De modulo (die truc met het procent teken) mag je verder even overslaan, maar wat daar omheen zit heb je nu nodig.

Pull up vind je ook terug in de voorbeelden, maar dat vormt voor nu even niet de kern van de zaak.

ik heb nu het volgende, ik heb de code van de state change detection zover overgenomen wat ik denk dat nodig is en even de groene kleur uit het programma gehaald omdat we deze niet gebruiken en dit het programma wat overzichtelijker maakt. nu zit ik er alleen nog mee waar ik nu in het programma moet gaan verwerken dat hij moet wachten tot pin 12 actief word (pin 13 heb ik veranderd naar pin 12)

dit is nu het prgramma:

// - - - - -
// DmxSerial - A hardware supported interface to DMX.
// DmxSerialSend.ino: Sample DMX application for sending 3 DMX values:
// address 1 (red) -> also available on PWM Port 9
// address 2 (green) -> also available on PWM Port 6
// address 3 (blue) -> also available on PWM Port 5
// 
// Copyright (c) 2011 by Matthias Hertel, http://www.mathertel.de
// This work is licensed under a BSD style license. See http://www.mathertel.de/License.aspx
// 
// Documentation and samples are available at http://www.mathertel.de/Arduino
// 25.07.2011 creation of the DmxSerial library.
// 10.09.2011 fully control the serial hardware register
//            without using the Arduino Serial (HardwareSerial) class to avoid ISR implementation conflicts.
// 01.12.2011 include file and extension changed to work with the Arduino 1.0 environment
// - - - - -

#include <DMXSerial.h>

const int  buttonPin = 12;
int buttonState = 0;         // current state of the button
int lastButtonState = 0;     // previous state of the button

// Constants for demo program

;const int RedPin =    9;  // PWM output pin for Red Light.
const int BluePin =   5;  // PWM output pin for Blue Light.

// The color fading pattern

int RedList[]   = {255,   10,  0,    0,  };
int BlueList[]  = {0,     0,   255,  255,};

int RedLevel, BlueLevel;

int RedNow = 0;
int BlueNow = 0;

int state = 0;

void setup() {
  DMXSerial.init(DMXController);
 
    // initialize the button pin as a input:
  pinMode(buttonPin, INPUT);
  pinMode(RedPin,   OUTPUT); // sets the digital pin as output
  pinMode(BluePin,  OUTPUT);
} // setup


// loop through the rainbow colors 
void loop() {
   
  RedLevel = RedList[state];
  BlueLevel = BlueList[state];
 
  if ((RedLevel == RedNow) && (BlueLevel == BlueNow)) {
    state += 1;
    if (state == 6)
      state = 0;
   
  } else {
    if (RedNow < RedLevel)  RedNow++; 
    if (RedNow > RedLevel)  RedNow--; 
    DMXSerial.write(1, RedNow);
    analogWrite(RedPin,   RedNow); 
 

    if (BlueNow < BlueLevel)  BlueNow++; 
    if (BlueNow > BlueLevel)  BlueNow--; 
    DMXSerial.write(3, BlueNow);
    analogWrite(BluePin,  BlueNow); 
   
  } // if
  
  delay(30); // wait a little bit
  // read the pushbutton input pin:
  buttonState = digitalRead(buttonPin);

  // compare the buttonState to its previous state
  if (buttonState != lastButtonState) ;
    // if the state has changed, increment the counter
    if (buttonState == HIGH) ;
      // if the current state is HIGH then the button
      // wend from off to on:
  // save the current state as the last state,
  //for next time through the loop
  lastButtonState = buttonState;} // loop

Hoi Erik.

Je hebt nu de twee codes aan elkaar geplakt, maar nog niet echt geïntegreerd.
De delen van de verschillende sketches staan nu wel in 1 sketch, maar ze beïnvloeden elkaar niet.
Je bent er wel al heel dicht bij.

Wat je nu doet is de kleuren laten lopen, en dan kijken of er al op een knopje word gedrukt.
Maar wat je wil doen, is kijken of er al op een knopje word gedrukt, en in dat geval door de kleuren lopen.
En anders dus niet.
Dat zijn wel bijna dezelfde woorden, maar het is iets heel anders, zie je ?

Als je met deze informatie niets kunt, bekijk de code die je nu hebt nog eens heel goed.
Pak een pen of potlood en een flink stuk papier (ja ja, LOWWWW tech), en schijf eens op wat je denkt dat de code doet per regel.
Dat klinkt kinderachtig, maar het dwingt je min of meer eens nader over de code na te denken.

Beste,

ik heb goed gekeken naar het programma en heb ook een familielid laten kijken die een opleiding doet in programmeren maar ook zei kwam er niet uit.

ik heb ook gekeken naar een gedetailleerde uitleg over het programma "blinkWithoutDelay’’
helaas zijn we hiermee niet verder gekomen omdat we niet weten hoe dat we de programma’s samen laten werken.

nog even een keer wat het programma moet gaan doen:

  • de DMX led spots branden continu rood
  • als pin 12 hoog word en blijft moeten de lampen faden naar blauw en blijven blauw zolang pin 12 hoog is.
  • wanneer pin 12 laag word moeten de lampen weer terug naar rood.

dit is wat we willen dat het programma gaat doen.

zou iemand hier a.u.b mee kunnen helpen?

Het programma zover we hem nu hebben:

// - - - - -
// DmxSerial - A hardware supported interface to DMX.
// DmxSerialSend.ino: Sample DMX application for sending 3 DMX values:
// address 1 (red) -> also available on PWM Port 9
// address 2 (green) -> also available on PWM Port 6
// address 3 (blue) -> also available on PWM Port 5
// 
// Copyright (c) 2011 by Matthias Hertel, http://www.mathertel.de
// This work is licensed under a BSD style license. See http://www.mathertel.de/License.aspx
// 
// Documentation and samples are available at http://www.mathertel.de/Arduino
// 25.07.2011 creation of the DmxSerial library.
// 10.09.2011 fully control the serial hardware register
//            without using the Arduino Serial (HardwareSerial) class to avoid ISR implementation conflicts.
// 01.12.2011 include file and extension changed to work with the Arduino 1.0 environment
// - - - - -

#include <DMXSerial.h>

const int  buttonPin = 12;
int buttonState = 0;         // current state of the button *initial value*
int lastButtonState = 0;     // previous state of the  *initial value*

// Constants for demo program

const int RedPin =    9;  // PWM output pin for Red Light.
const int BluePin =   5;  // PWM output pin for Blue Light.

// The color fading pattern

int RedList[]   = {0,255,10,0,0,0};
int BlueList[] = {0};

int RedLevel, BlueLevel;

int RedNow = 0;
int BlueNow = 0;

int state = 0;

void setup() {
  DMXSerial.init(DMXController);
 
    // initialize the button pin as a input:
  pinMode(buttonPin, INPUT);
  pinMode(RedPin,   OUTPUT); // sets the digital pin as output
  pinMode(BluePin,  OUTPUT);
} // setup


// loop through the rainbow colors 
void loop() {
         
          RedLevel = RedList[state];
          BlueLevel = BlueList[state];
         
          if ((RedLevel == RedNow) && (BlueLevel == BlueNow))
            {
            state += 1;
            }
            if (state == 6)
              {
              state = 0;
              }
             else{
            if (RedNow < RedLevel)  RedNow++; 
            if (RedNow > RedLevel)  RedNow--; 
            DMXSerial.write(1, RedNow);
            analogWrite(RedPin,   RedNow); 
         
        
            if (BlueNow < BlueLevel)  BlueNow++; 
            if (BlueNow > BlueLevel)  BlueNow--; 
            DMXSerial.write(3, BlueNow);
            analogWrite(BluePin,  BlueNow); 
             }
         // if
          
          delay(30); // wait a little bit
        
               // read the pushbutton input pin:
          buttonState = digitalRead(buttonPin);
        
          // compare the buttonState to its previous state
          if (buttonState != lastButtonState)
          {
            // het programma moet iets doen dus het knopje is ingedrukt

          }
            // if the state has changed, increment the counter
            else if (buttonState == HIGH) 
            {
              // het programma moet iets doen
                          int RedList[] = {0};
            
            int BlueList[]  = {0,0,0,255,255,0};
        
            }
              // if the curret state is HIGH then the button
              // wend from off to on:
          // save the current state as the last state,
          //for next time through the loop
          lastButtonState = buttonState;
  } // loop

alvast hartelijk dank,
met vriendelijke groet,
Erik Koevoets

als knop uit is (dat kan zowel lag als hoog zijn)
dan is kleur rood.
ga dan naar een functie die alle kleuren bedient dus dmxserial 1,2 3 ........
als knop aan is (je hoeft niet te kijken of er dender is (heb je geen probleem mee ) en is ook niet belangrijk hier.
dan een teller starten als teller >254 dan teller=255 anders ++
deze hangt aan de blauwe kleur
dan weer de functie van alle kleuren, maardan met de tellerkleur als je rood wilt dimmen dan doe je 255-teller.
dan een delay om het langzaam te laten gaan.
hou het simpel.