[OPGELOST]probleem met uitgebreid autonoom gedrag programma voor animatronic pop

International Nederlands
1

Hallo Allemaal,

Voor de mensen die graag willen weten hoe het probleem is gelost, heb ik nu het project in werkende staat (attachment Varkensgedrag_1) bijgevoegd. Er word nu geen delay meer gebruikt maar de millis(); methode van tijds indeling van de tutorial BlinkWhitoutDelay. Hopelijk heeft iemand er wat aan.

Hopelijk kan iemand mij helpen. Ik probeer een programma te schrijven dat door middel van diverse sensoren en knoppen verschillende servo's, lampjes en geluiden aanstuurt. Met dit programma wil ik een animatronic pop tot leven brengen en laten reageren op de omgeving zonder dat ik daar ter plekken veel aan hoef te doen.

Op het moment probeer ik diverse acties in losse functies onder te brengen die ik aanroep in gedragsprogramma's. Op die manier kan ik bijvoorbeeld voor de servo die het linker oor aanstuurt een aantal bewegingen scripten die vervolgens in diverse gedragsprogramma's aangeroepen kunnen worden.

Voorbeeld van een actie functie

void OorL2Function (){// deze functie beweegt het linker oor diverse keren
  Serial.println("OorL 0");
  OorLServo.write(0);
  delay(5000);
  Serial.println("OorL 180");
  OorLServo.write(180);
  delay(1000);
  Serial.println("OorL 90");
  OorLServo.write(90);
  delay(2000);
  Serial.println("OorL 120");
  OorLServo.write(120);
}

Voorbeeld van een gedragprogramma

else if (Gedrag == 6){
    Serial.println("gedrag6 gestart");//stand ins voor echte commando's 
    switch (Beweging){
    case 0:
      Serial.println("case 0");//stand ins voor echte commando's
      OorL0Function();
      Neus0Function();
      Beweging++;
      delay(6000);
      break;
    case 1:
      Serial.println("case 1");//stand ins voor echte commando's
      OorL1Function();
      Neus1Function();
      delay(6000);
      Beweging++;
      break;
    case 2:
      Serial.println("case 2");//stand ins voor echte commando's
      OorL2Function();
      Neus2Function();
      delay(18000);
      Beweging++;
      break;
    case 3:
      Serial.println("einde gedrag 6");//stand ins voor echte commando's reset alle parameters voor een nieuwe input mogelijkheid
      Beweging = 0;
      knopStaat = 0;
      knopActief = 0;
      Gedrag = 0;
      break;

  }

Helaas worden met mij huidige code alle actie functies achter elkaar afgespeeld in plaats van door elkaar. Dan beweegt de neus dus pas als oor 1 klaar is met bewegen en daarna pas de ogen. Dat ziet er dus suf uit en niet levend.

Mijn vraag is dus of iemand een manier weet om output parallel aan te sturen zonder dat ik alle acties direct in de gedragsprogramma's moet schrijven want als ik dat doe kan ik wel verschillende output apparaten tegelijk en door elkaar aansturen. Maar dan word de code massief en onoverzichtelijk.

De totale code heb ik als attachment bij gevoegd

Alvast bedankt voor de hulp.

Random_nummer_op_array_servo7.ino (13.4 KB)

Varkengedrag_1.ino (14.8 KB)

2

Hoi, welkom.

Ja dat is een bekend en veel voorkomend probleem.
Het komt omdat je niet alle tutorials hebt gevolgd.
Je maakt namelijk gebruik van delay, waarbij ik vertragingen van wel 18 seconden voorbij zie komen.
18 seconden is een eeuwigheid, daarin kan ontzettend veel gedaan worden, maar jouw programma is dan druk met de millisecondes te tellen en ondertussen niets anders te doen.
Ga op zoek naar de tutorial "blink without delay" en implementeer dat in je programma.
Het lost je probleem op, maar aanpassing kost je wel wat tijd.
Je kunt dit niet op een andere wijze oplossen, je moet dit eerst doen.
Wanneer er daarna nog andere problemen zijn kun je daar na deze aanpassing aandacht aan besteden.

3

Ah ik ben dus ongeduldig geweest. :blush: Bedankt voor je snelle reactie. Het geeft niet dat de aanpassing tijd kost. Ik ben bezig met een leer/werk proces. Ik ga wel naar de tutorials en wat meer basis programma's uitproberen.

ps. De 18 seconde delay zat er alleen in als test. Zodat de acties te volgen waren in de monitor

bedankt en wellicht tot later

4

Ik heb trouwens niet je hele code gedownload, maar alleen bekeken wat je hier hebt staan.
Ik zie wel dat je in elke case een Beweging++ doet, behalve in de laatste waar je er 0 van maakt.
Dat zou ik anders doen.
Ik zou Beweging++ doen vlak voor je de switch start.
Dat lijkt me efficiënter.
Dan moet je wel een iets andere volgorde aanhouden, omdat je niet de waarde 0 zult hebben maar altijd begint met waarde 1.
Want als je m reset en vervolgens verhoogt is ie dus 1 en niet 0.
Vergeet ook niet dat je de switch ook nog kunt afsluiten met een actie die geldt wanneer er aan geen van de andere cases word voldaan, met "default" en dat kan erg handig uitkomen.

Je gebruikt servo's zo te zien en die hebben een eigen feedback.
Dat betekent dat als je daartegen zegt dat ie naar een bepaalde waarde moet, je mag aannemen dat ie daar ook heen gaat.
Dat hoef je dus niet af te wachten, maar je vertelde nu dat je wacht om het geheel in serial monitor te kunnen volgen.

5

Nogmaals bedankt.ik heb je tip voor Beweging++ gebruikt en ben aan de slag gegaan met de BlinkWithoutDelay tutorial. Daar heb ik deze test mee gemaakt:

/* Blink without Delay
 
 Turns on and off a light emitting diode(LED) connected to a digital  
 pin, without using the delay() function.  This means that other code
 can run at the same time without being interrupted by the LED code.
 
 The circuit:
 * LED attached from pin 13 to ground.
 * Note: on most Arduinos, there is already an LED on the board
 that's attached to pin 13, so no hardware is needed for this example.
 
 
 created 2005
 by David A. Mellis
 modified 8 Feb 2010
 by Paul Stoffregen
 
 This example code is in the public domain.

 
 http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
 */

// constants won't change. Used here to 
// set pin numbers:
const int ledPin =  13;      // the number of the LED pin

// Variables will change:
int ledState = LOW;             // ledState used to set the LED
long actieMillis = 0;        // de tijd opslaan waar op de actie is begonnen
long tijdMillis = 0;        // de tijd opslaan waar op de timer voor het laatst is aangeroepen
int seconden = 0;          //de verstreken seconden opslaan
int actieHuidig = 0;   //bijhouden welke actie bezig is
int actieTotaal = 4;  //het maximale aantal acties
// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
int actieInterval = 1000;           // interval at which to blink (milliseconds)
int tijdInterval = 1000;
void setup() {
  Serial.begin(9600);
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);      
}

void loop()
{
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the 
  // difference between the current time and last time you blinked 
  // the LED is bigger than the interval at which you want to 
  // blink the LED.
  unsigned long currentMillis = millis();
 
  if((currentMillis > actieMillis + actieInterval)&&(actieHuidig <= actieTotaal)) {
    // save the last time you blinked the LED 
    actieMillis = currentMillis;
    actieHuidig++;  
    seconden = 0;
    switch (actieHuidig){
      case 1:
      actieInterval = 30;
      Serial.println("actie 1 actieInterval 30");//stand ins voor echte commando'
      break;
      case 2:
      actieInterval = 3000;
      Serial.println("actie 2 actieInterval 30000");//stand ins voor echte commando'
      break;
      case 3:
      actieInterval = 7000;
      Serial.println("actie 3 actieInterval 7000");//stand ins voor echte commando'
      break;
      case 4:
      actieInterval = 5;
      Serial.println("actie 4 actieInterval 5");//stand ins voor echte commando'
      break;
      case 5:
      actieInterval = 20000;
      Serial.println("actie 5 actieInterval 20000");//stand ins voor echte commando'
      break;
      default:
      Serial.println("default doe niets ");//stand ins voor echte commando'
      break;
    } 
  }
      if((currentMillis - tijdMillis > tijdInterval) && (actieHuidig <= actieTotaal)) {
    // save the last time you blinked the LED 
    tijdMillis = currentMillis;   
    Serial.print("verstreken seconden = ");//stand ins voor echte commando's
    Serial.println(seconden);//stand ins voor echte commando's
    seconden ++;

    // set the LED with the ledState of the variable:
  }
}

Dit doet zo ver ik kan zien precies wat ik nodig heb. Nu ga ik het in mijn project integreren.

Wat betreft je andere opmerkingen: Ja servo's gaan netjes naar hun toegewezen positie maar ik wil later wat meer controle uit gaan oefenen op de bewegingen van de servo's zodat ik ook het tempo kan beïnvloeden en eventueel een natuurlijkere beweging kan maken. De pauzes zijn niet zo belangrijk. Ik wilde alleen zeker weten dat de bewegingen die de servo's maakten op het moment gebeurden dat ik aangaf en dat is lastig te zien wanneer alles bijna tegelijk gebeurt.