Pages: [1]   Go Down
Author Topic: hoe combineer ik 2 arduino sketch programma's  (Read 1494 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Newbie
*
Karma: 0
Posts: 1
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

hallo.
ik zou graag 2 codes willen combineren voor een discolamp te besturen, en ik kom er maar niet uit hoe ik dat moet doen.

CODE_1

// Output
int redPin = 9;   // Red LED,   connected to digital pin 9
int grnPin = 10;  // Green LED, connected to digital pin 10
int bluPin = 11;  // Blue LED,  connected to digital pin 11

// Color arrays
int black[3]  = { 0, 0, 0 };
int white[3]  = { 100, 100, 100 };
int red[3]    = { 100, 0, 0 };
int green[3]  = { 0, 100, 0 };
int blue[3]   = { 0, 0, 100 };
int yellow[3] = { 40, 95, 0 };
int dimWhite[3] = { 30, 30, 30 };
// etc.

// Set initial color
int redVal = black[0];
int grnVal = black[1];
int bluVal = black[2];

int wait = 1;      // 10ms internal crossFade delay; increase for slower fades
int hold = 0;       // Optional hold when a color is complete, before the next crossFade
int DEBUG = 1;      // DEBUG counter; if set to 1, will write values back via serial
int loopCount = 60; // How often should DEBUG report?
int repeat = 3;     // How many times should we loop before stopping? (0 for no stop)
int j = 0;          // Loop counter for repeat

// Initialize color variables
int prevR = redVal;
int prevG = grnVal;
int prevB = bluVal;

// Set up the LED outputs
void setup()
{
  pinMode(redPin, OUTPUT);   // sets the pins as output
  pinMode(grnPin, OUTPUT);  
  pinMode(bluPin, OUTPUT);

  if (DEBUG) {           // If we want to see values for debugging...
    Serial.begin(9600);  // ...set up the serial ouput
  }
}

// Main program: list the order of crossfades
void loop()
{
  crossFade(red);
  crossFade(green);
  crossFade(blue);
  crossFade(yellow);

  if (repeat) { // Do we loop a finite number of times?
    j += 1;
    if (j >= repeat) { // Are we there yet?
      exit(j);         // If so, stop.
    }
  }
}

/* BELOW THIS LINE IS THE MATH -- YOU SHOULDN'T NEED TO CHANGE THIS FOR THE BASICS
*
* The program works like this:
* Imagine a crossfade that moves the red LED from 0-10,
*   the green from 0-5, and the blue from 10 to 7, in
*   ten steps.
*   We'd want to count the 10 steps and increase or
*   decrease color values in evenly stepped increments.
*   Imagine a + indicates raising a value by 1, and a -
*   equals lowering it. Our 10 step fade would look like:
*
*   1 2 3 4 5 6 7 8 9 10
* R + + + + + + + + + +
* G   +   +   +   +   +
* B     -     -     -
*
* The red rises from 0 to 10 in ten steps, the green from
* 0-5 in 5 steps, and the blue falls from 10 to 7 in three steps.
*
* In the real program, the color percentages are converted to
* 0-255 values, and there are 1020 steps (255*4).
*
* To figure out how big a step there should be between one up- or
* down-tick of one of the LED values, we call calculateStep(),
* which calculates the absolute gap between the start and end values,
* and then divides that gap by 1020 to determine the size of the step  
* between adjustments in the value.
*/

int calculateStep(int prevValue, int endValue) {
  int step = endValue - prevValue; // What's the overall gap?
  if (step) {                      // If its non-zero,
    step = 1020/step;              //   divide by 1020
  }
  return step;
}

/* The next function is calculateVal. When the loop value, i,
*  reaches the step size appropriate for one of the
*  colors, it increases or decreases the value of that color by 1.
*  (R, G, and B are each calculated separately.)
*/

int calculateVal(int step, int val, int i) {

  if ((step) && i % step == 0) { // If step is non-zero and its time to change a value,
    if (step > 0) {              //   increment the value if step is positive...
      val += 1;          
    }
    else if (step < 0) {         //   ...or decrement it if step is negative
      val -= 1;
    }
  }
  // Defensive driving: make sure val stays in the range 0-255
  if (val > 255) {
    val = 255;
  }
  else if (val < 0) {
    val = 0;
  }
  return val;
}

/* crossFade() converts the percentage colors to a
*  0-255 range, then loops 1020 times, checking to see if  
*  the value needs to be updated each time, then writing
*  the color values to the correct pins.
*/

void crossFade(int color[3]) {
  // Convert to 0-255
  int R = (color[0] * 255) / 100;
  int G = (color[1] * 255) / 100;
  int B = (color[2] * 255) / 100;

  int stepR = calculateStep(prevR, R);
  int stepG = calculateStep(prevG, G);
  int stepB = calculateStep(prevB, B);

  for (int i = 0; i <= 1020; i++) {
    redVal = calculateVal(stepR, redVal, i);
    grnVal = calculateVal(stepG, grnVal, i);
    bluVal = calculateVal(stepB, bluVal, i);

    analogWrite(redPin, redVal);   // Write current values to LED pins
    analogWrite(grnPin, grnVal);      
    analogWrite(bluPin, bluVal);

    delay(wait); // Pause for 'wait' milliseconds before resuming the loop

    if (DEBUG) { // If we want serial output, print it at the
      if (i == 0 or i % loopCount == 0) { // beginning, and every loopCount times
        Serial.print("Loop/RGB: #");
        Serial.print(i);
        Serial.print(" | ");
        Serial.print(redVal);
        Serial.print(" / ");
        Serial.print(grnVal);
        Serial.print(" / ");  
        Serial.println(bluVal);
      }
      DEBUG += 1;
    }
  }
  // Update current values for next loop
  prevR = redVal;
  prevG = grnVal;
  prevB = bluVal;
  delay(hold); // Pause for optional 'wait' milliseconds before resuming the loop
}

CODE_2 simpel BLINK

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.
 
  This example code is in the public domain.
 */
 
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);    
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}
« Last Edit: April 25, 2013, 12:15:01 pm by Jantje » Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 8
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Klinkt als een leuk project..... kun je er wat meer over vertellen..?

Ik ben zelf bezig met een licht besturing maar wil ook nog niet echt flotten ( wachten voor mij is ook op onderdeeltjes, en ik ken arduino nog niet met programmeren, code beetje aanpassen begint te lukken  smiley-red )
Logged

Forum Moderator
Belgium
Offline Offline
Edison Member
*****
Karma: 68
Posts: 1926
Arduino rocks; but with my plugin it can fly rocking the world ;-)
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Ter info Ik heb de titel veranderd.

Voor het samenbrengen van 2 sketches zijn er een paar zaken die je moet doen.
1) Kijk of je niet dezelfde globale variabelen gebruikt. In dit geval dus niet. Indien je dezelfde globale variabelen gebruikt zal je 1 sketch moeten aanpassen om een andere naam te hebben voor de variabele.
2) Kijk of je dezelfde functies gebruikt. (Dit is zowiezo voor setup en loop maar dat komt later.) Indien je dezelfde functies gebruikt moet je 1 sketch aanpassen zodat dat niet meer het geval is. In puw voorbeeld is dat niet het geval.
3) Smijt alle code in 1 sketch. Dit kan op meerdere wijzen doen; ik veronderstel dat je de 2 sketches bij elkaar in 1 file steekt.
4) hernoem setup en loop van de 1ste sketch naar setup1 en loop1 en van de 2de sketch setup2 en loop2
5) maak een nieuwe setup en loop als volgt
Code:
void setup() { 
  setup1();
  setup2();
}

void loop() {
  loop1();
  loop2();
}
Als je sketches goed geschreven zijn is dit alles wat moet gebeuren. Maar ......
In het voorbeeld gebruik je blink. Blink is niet geschreven om een goede sketch te zijn maar om het leerproces te vergemakkelijken. Blink without delay is dan wel weer goed geschreven om samen te voegen.
Ook de andere sketch maakt gebruik van delay en zal dus niet het gewenste resultaat geven. Pas deze aan zoals blink without delay een aanpassing is van blink en dan kan je bovenstaande regels gebruiken voor een goede samengestelde sketch.

Met vriendelijke groet
Jantje
Logged

Do not PM me a question unless you are prepared to pay for consultancy.
Nederlandse sectie - http://arduino.cc/forum/index.php/board,77.0.html -

The Netherlands
Offline Offline
Edison Member
*
Karma: 50
Posts: 1709
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hoi Thijs en Dennis.

Jullie hebben je beiden zeer recent (< 1 week) aangemeld op dit forum.
Dat zegt niet alles maar doet vermoeden dat jullie net begonnen zijn.
Dennis hebben we van de week al voorbij zien komen, die heeft na wat strubbelingen zijn vraag zo'n beetje zelf opgelost.
Zelf ben ik ook nog niet zo lang bezig met Arduino.

Ik denk dat je voordat je codes gaat samenvoegen, beter eerst een beetje meer zou moeten spelen met de voorbeelden.
Natuurlijk weet ik niet of jullie dat hebben gedaan.
Die voorbeelden werken namelijk allemaal wel, en die in je Arduino schieten is niet zo'n groot probleem.
Dus daar leer je niet erg veel van.
Waar je wel van leert, is variëren op de oefen sketches.
Pak zo'n sketch en laat m net ff iets anders doen, of in een andere volgorde, of met andere Arduino pinnen.
Verander niet teveel in een keer.
Daar leer je van, en vooral als het niet in een keer goed gaat.
Neem niet te grote stappen ineens want dan kun je heel snel het overzicht verliezen.

Die code voor de 3 kleuren LED is al aardig ingewikkeld wanneer je net bent begonnen.
Uitpluizen hoe dat werkt door ermee te spelen is dan erg leerzaam.
Moet je natuurlijk wel de spulletjes hebben, want dan kun je zien wat er gebeurt als je de sketch hebt geüpload.

Zelf heb ik al in het eerste weekend de blink en de fading sketches gecombineerd en daarna uitgebreid met meerdere LEDs.
Die 2 sketches zijn nogal klein en dus gemakkelijker te combineren.

Zoals Jantje al zegt, delay is mooi om bijvoorbeeld te debuggen zodat je sketch lekker langzaam verloopt en je beter kunt volgen wat er gebeurt.
Maar beter is te kijken hoe je zonder delay iets vergelijkbaars kunt bereiken en daar is dus ook een sketch voor.

Veel spelen dus en geduld is een schone zaak.
Veel plezier tijdens het spelen.
Logged

Have a look at "blink without delay".
Did you connect the grounds ?
Je kunt hier ook in het Nederlands terecht: http://arduino.cc/forum/index.php/board,77.0.html

Pages: [1]   Go Up
Jump to: