Arcomora en mijn begrip van Arduino

[ron.kraaijkamp]

Ik heb het concept van Arcomora doorgenomen en ben er erg gecharmeerd van.
Omdat ik nog niet zeker ben of ik digitaal ga rijden ben ik begonnen mijn baan vast  op te bouwen.
Die is aardig groot. En nu moet ik er nog omheen lopen om de wissel te bedienen.
Ik heb zo'n twaalf elektrische en twee hand wissels in het schaduw station. De elektrische zijn nog niet aangesloten.

Die wissels kan je natuurlijk via drukknoppen aansturen. De analoge uitgezonderd.
Dus gaan bouwen met een Arduino nano. Nog niet eerder gedaan. Daarom wat voorbeeld code bij elkaar gezocht.
En een test opstelling gemaakt.
Middels de analoge poorten lees ik (digitaal) de status HIGH of LOW), afhankelijk daarvan wordt de betreffende digitale ouput geactiveerd).

Inmiddels kan ik een handwissel omzetten met een servo en een elektrisch wissel met twee poorten en twee MOSFET printjes (je leert een hoop door de Arcomora handleiding te lezen en de video's te bekijken).
De manier waarop ik het geprogrammeerd heb (in een void loop() ), houdt eiegnlijk in dat alles na elkaar wordt uitgevoerd.
Dat bracht aan het denken over het type processor en de code. Feitelijk kan de Arduino maar een ding tegelijk uitvoeren en wel sequentieel door door de loop te lopen. Dus ik heb een stukje code togevoegd om het onboard ledje te laten knipperen (pin 13).
Zolang er niets in de status van de schakelaars veranderd, blijft de LED knipperen.
Zodra ik een schakelaar voor een wissel omzet, zie je de LED stoppen met knipperen en weer beginnen zodra het wissel is omgezet.
Op zich geen probleem als je er wissels mee aanstuurt. Dat kost weinig tijd. En ook wordt het omzetten van een tweede wissel, wanneer de eerste aan het omslaan is, in de wacht gezet en uitgevoerd zodra het eerste wissel klaar is.

Nu mijn vraag; Kent Arcomora dit fenomeen ook? Of werkt die met software interrupts (weet wat het is, kan het nog niet toepassen op de Arduino)?

[Remco_Nzo]

In principe kun je prima een dozijn servo's gelijktijdig laten bewegen - je moet alleen de 'loop' anders vormgeven.
In de praktijk kun je het zo maken dat de loop 100-den keren per seconde doorlopen wordt - en dus dat het knipperen (voor het oog) ononderbroken door gaat.

Dus ja - het is 'single tasking' maar als je de acties maar klein genoeg maakt en aan allemaal een kleine timeslice kunt besteden is het voor het oog/gevoel aan het multi-tasken.

....hope this makes sense...
Remco.

[ron.kraaijkamp]

Hallo Remco,

Bedankt voor je snelle antwoord.

Dus de loop gebruiken om detectie op de input doen en dan uit de void loop() de acties doen? Daarna terug in de loop. Of moet alles binnen de loop gebeuren.

Het is een single core processor. Dus eerst moet je actie klaar zijn voordat de volgende uitgevoerd kan worden. Dat zie ik ook. Knipperende led stopt, wissel gaat om. Afhankelijk van de snelheid waarmee dat gebeurt, knippert de led langer of korter.

Dat hoeft voor wissels geen probleem te zijn. Die zijn hoogsten een halve tot hele seconde ermee bezig.

Groeten, Ron


Verzonden vanaf mijn iPhone met Tapatalk

[meino]

Dag Ron

In principe gebeurd alles in de loop() functie. Je kunt met interrupts werken, maar dat is een verhaal apart, dus het aansturen van servo's doe je in de loop() functie. De truck is dat je niet de hele servo beweging in een keer doet. Ik neem aan dat je met de Servo bibliotheek werkt. In die bibliotheek kun je een servo laten bewegen door een waarde van 0-180 te schrijven. 0 en 180 corresponderen met de uiterste standen. Wat je moet doen is om bij te houden wat de huidige stand is van een servo en iedere keer dat je door de loop() komt, de servo een stapje verder te zetten, door een nieuwe waarde naar het servo object te schrijven. Als je dan ook nog de tijd registreerd op het moment dat je een servo naar een nieuwe positie brengt, kun je de volgende stap pas doen als een bepaalde tijd is verstreken. Daarmee kun je dan de snelheid van de servo reguleren.

Groet Meino

[spock]

Hallo Ron,

Het is bij arduino de bedoeling dat je nergens specifiek op blijft wachten maar dat je blijft loopen (= lekker Nederlands).

Kijk voor dat principe eens naar het verschil tussen de voorbeeld sketch blink en blinkwithoutdelay (onder Voorbeelden - Digitaal). Beide laten een led knipperen maar op een heel andere manier.
Als je dat principe begrijpt kun eens naar libraries kijken hoe deze dit principe doorvoeren, bv libraries voor het knipperen van een led of het aansturen van een servo.

mvg spock

[ikbenerevenniet]

in een void loop()

Even een begripsverwarring uit de wereld helpen: het is geen void maar een functie. Het woord void betekent alleen dat deze functie geen waarde teruggeeft aan de aanroepende code. Bij andere functies kan er bv. "int", "long" of "char" voor de naam staan, om het datatype van de returnvalue aan te geven.

[ikbenerevenniet]

Ron, heb je de sketch zelf geschreven? Misschien is het handiger om de servo-library van Michael Margolis te gebruiken, die neemt je veel werk uit handen! Is - als het goed is - al geïnstalleerd, en de uitleg staat op https://www.arduino.cc/reference/en/libraries/servo/ .

[ron.kraaijkamp]

Heren,

bedankt voor jullie antwoorden.

Ik ga mijn recht toe, recht aan code maar eens veranderen.
En wat libraries door kijken. Ik gebruik inderdaad de servo library.

Eerst eens even de tip om twee verschillende manieren van blinken van de LED bekijken. Om een idee te krijgen.

[spock]

Hallo Ron,

Een antwoord op de vraag of Arcomora ook dat gedrag heeft. Antwoord: Nee.

mvg spock

[ron.kraaijkamp]

Hallo Ron,

Een antwoord op de vraag of Arcomora ook dat gedrag heeft. Antwoord: Nee.

mvg spock

Dank je Spock.

Dat vermoedde ik al.
Anders zou het nooit goed kunnen werken.


Verzonden vanaf mijn iPhone met Tapatalk

[bask185]

Ik heb even snel ene programma in elkaar geflanst die 2 servo's kan bedienen aan de hand van de seriele monitor. Je kan hem zo in Arduino IDE kopieren plakken.

Beide servo's kunnen onafhankelijk van elkaar naar links en naar rechts Sweepen. Elke keer als je via de monitor een 'L' stuurt gaat de linker servo de andere kant op. Als je een L stuurt terwijl de servo nog halverwege is, gaat hij keurig weer terug.

De rechter servo doet precies hetzelfde met R. Als je stuurt RL, dan gaan beide servo's de andere kant op.

Ja kan het servo gedrag heel makkelijk wijzigen door de constantes in de eerste 8 regels te veranderen. Ik heb hier een paar dummy waardes ingevoerd. De servo's bewegen naar verschillende eind posities met een verschillende snelheid.

Hiermee toon ik aan, hoe je servo's kan multitasken.

Deze code kan nog 10x mooier door hem te verwerken naar een library. Je hebt nu namelijk 2 bijna identiek functies, en als een object library heb je nog maar 1 zo'n functie nodig waarmee je zoveel servo motors kan aansturen als de servo.h library aankan  Maar dit is verder niet relevant aan je vraag.

Ik hoop dat je er wat aan heb 

Mvg,

Bas

Code: [Selecteer]

#include <Servo.h>

Servo servoL ;
Servo servoR ;


// LEFT SERVO
const int servoPinL = 3 ;
const int servoSpeedL = 20 ;
const int servoMinL = 20 ;
const int servoMaxL = 100 ;


// RIGHT SERVO
const int servoPinR = 4 ;
const int servoSpeedR = 30 ;
const int servoMinR = 50 ;
const int servoMaxR = 150 ;


enum servoStates {
    moveRight ,
    moveLeft ,
} ;

unsigned long currentTime ;
byte signal1 ;
byte signal2 ;

byte servoPosL = 90 ;
byte servoPosR = 90 ;

char serialByte ;

void setup() {
cli() ;
    servoL.write( servoPosL ) ; // send both servo's to middle
    servoR.write( servoPosR ) ;

    servoL.attach( servoPinL ) ;
    servoR.attach( servoPinR ) ;

    Serial.begin( 115200 ) ;

    sei() ;
    Serial.println(" hello world ") ;
}

void loop() {
    currentTime = millis() ;

    if( Serial.available() > 0 ) {
    serialByte = Serial.read() ;
    }

    servoLeft() ;
    servoRight() ;

   
}

void servoLeft () {
    static unsigned long timeToRun ;
    static byte state = moveLeft, prevPos;

    if( currentTime > timeToRun ) {
        timeToRun = currentTime + servoSpeedL ;

        switch( state ) {

        case moveRight:
            if( servoPosL < servoMaxL ) servoPosL ++ ;
           
            if( serialByte == 'L' ) {
            serialByte = 0 ;
                state = moveLeft ;
                Serial.println("moving left") ;
            }
            break ;


        case moveLeft:
            if( servoPosL > servoMinL ) servoPosL -- ;
            if( serialByte == 'L' ) {
            serialByte = 0 ;
                state = moveRight ;
                Serial.println("moving right") ;
            }
            break ;
        }
        if( servoPosL != prevPos ) {
            prevPos = servoPosL ;
           
            Serial.println( servoPosL ) ;
            servoR.write( servoPosL ) ;
        }
    }
}

void servoRight () {
    static unsigned long timeToRun ;
    static byte state = moveLeft, prevPos;

    if( currentTime > timeToRun ) {
        timeToRun = currentTime + servoSpeedR ;

        switch( state ) {

        case moveRight:
            if( servoPosR < servoMaxR ) servoPosR ++ ;
            if( serialByte == 'R' ) {
            serialByte = 0 ;
           
                state = moveRight ;
                Serial.println("moving left") ;
            }
            break ;


        case moveLeft:
            if( servoPosR > servoMinR ) servoPosR -- ;
            if( serialByte == 'R' ) {
            serialByte = 0 ;
           
                state = moveRight ;
                Serial.println("moving right") ;
            }
            break ;
        }
        if( servoPosR != prevPos ) {
            prevPos = servoPosR ;
           
            Serial.println( servoPosR ) ;
            servoR.write( servoPosR ) ;
        }
    }
}


[ron.kraaijkamp]

Geweldig Bas,

Ik ga er eens mee stoeien.
Ik wil tuimelschakelaars gebruiken zodat je aan de hand daarvan ook kan zien hoe de wissels staan.
Dat heb ik al gemaakt en ga dat met jou voorbeeld verwerken.

[ron.kraaijkamp]

Hallo Bas,

aan het stoeien geweest met je code.
Ook nog even gekeken naar ASAR (de analoge versie van MARDEC). Om die code omte bouwen zodat ik ook electrische wissel kan omzetten, gaat boven mijn pet.

Goed, terug naar je code.
Je hebt er over dat je in de serial monitor R en L kan sturen zodat de bijhorende servo's van stand wisselen.
Dat werkt niet, heb ik gemerkt. De servo wordt wel in de juiste stand gezet bij het opstarten. ik zie het ook gebeuren in de monitor.

Als ik de code doorkijk, met de kennis die ik heb, mis ik ergens dat afhankelijk van de letter die je gebruikt een actie wordt gedaan.
Ik vermoed dat het hier gedaan moet worden, omdat hier de serial line wordt gelezen.

Code: [Selecteer]

void loop() {
    currentTime = millis() ;

    if( Serial.available() > 0 ) {
    serialByte = Serial.read() ;
    }

    servoLeft() ;
    servoRight() ;

   
}

Zie ik iets over het hoofd?

[bask185]

Ik heb een foutje gespot!

Op regel 114 staat: state = moveRight ;
Maar dat moet zijn: state = moveLeft ;

Zie je op de monitor wel de getallen voorbij komen van de servo posities?
Als ik nu een L of een R stuur dan zie ik dit wel op de monitor.

Ik krijg dit te zien

Code: [Selecteer]

moving left
99
98
97
96
95
94
93
92
91
90
89
88
87
86
85
84
83
82
81
80
79
78
77
76
75
74
73
moving left
72
71
149
70
148
69
147
68
67
146
66
145
65
64
144
63
143
62
61
142
60
141
59
Bij de eerste keer moving left, zie je keurig de getallen lopen. Halverwege had ik ook de "R" verstuurd en toen ging de andere motor dus ook naar left moven. Daarom zie je vanaf de 2e keer moving left, 2 getallen reeksen door elkaar heen lopen. Je kan hier ook goed zien dat de tijden hier tussen ongelijk zijn aan elkaar.

Ik heb zelf niet met een daadwerkelijke motor getest alleen met de monitor, maar omdat deze regels onder elkaar staan:

Code: [Selecteer]

Serial.println( servoPosR ) ;
servoR.write( servoPosR ) ;
Maak ik de aanname dat de motor daadwerkelijk wordt aangestuurd.

Als je die regel 114 aanpast zouden ze het moeten doen. En let er natuurlijk op dat je wel hoofdletters verstuurt!

Als ik de code doorkijk, met de kennis die ik heb, mis ik ergens dat afhankelijk van de letter die je gebruikt een actie wordt gedaan.
Ik vermoed dat het hier gedaan moet worden, omdat hier de serial line wordt gelezen.

Zie ik iets over het hoofd?

Ja. Kijk wat ik doe is dit. Elke cyclus kijk ik met Serial.available() of er een byte is ontvangen. Zo ja dan lees ik hem in met Serial.read en stop de waarde in een globale variabele genaamd 'serialByte'.

Vervolgens roep ik de 2 servo functies aan en daarin wordt de serialByte uitgelezen en gewist.

Code: [Selecteer]

if( serialByte == 'R' ) {
    serialByte = 0 ;
             
    state = moveLeft ;
    Serial.println("moving left") ;
}
In nederlands:
Als serialByte gelijk is aan 'R'
Dan maak serialByte 0 en beweeg de motor naar links.

Ik wis de serialByte opdat hij niet continu gelijk is aan 'R' anders blijft de motor eindeloos van links naar rechts springen totdat ik een andere byte stuur.

Ik heb, omdat ik er toegevoegde waarde voor het groter goed in zie, deze code tot een library verwerkt. Het eerdere voorbeeld is enigszins wat primitief, maar mijn pauze duurde ook maar zolang 

Ik heb de library ook voorzien van de functionaliteit om een puntstuk relais mee te schakelen wanneer de servo in het midden tussen max en min zit. Ik heb hem ook getest met de seriele monitor en volgens mij werkt hij. Maar als je het wilt, mag je hem testen 

Je .ino bestand kan er zo uitzien:

Code: [Selecteer]

#include "ServoSweep.h"

const int interval = 3000 ;
const int inputButton = 12 ;
const int servoPin = 13 ;

unsigned long prev ;
byte state ;

//                   pin   min max speed (bigger speed = slower movement ;
ServoSweep servo1(servoPin, 10, 30, 50) ; // als je hier een 5e getal toevoegt, dan is dat getal het pinnummer van je puntstuk relais.

void setup() {
}

void loop() {
 
  servo1.sweep(); // de sweep moet continu aangeroepen worden

  if( digitalRead( inputButton ) ) servo1.setState( 1 ) ; // door setState aan te roepen met een 1 of een 0, kan je motor laten bewegen
  else                             servo1.setState( 0 ) ;
 
}
En dan moet je wel in dezelfde folder als je .ino de ServoSweep library (.h en .ccp) downloaden van hier en hier

Ik hoop je hiemee verder geholpen te hebben.

Mvg,

Bas

[ron.kraaijkamp]

Hallo Bas,

je hebt me zowiezo geholpen.
Het is nog niet de oplossing.

Even in tweeen delen:
1) Je originele code.
Ik heb regel 114 veranderd.
Wanneer ik de code geupload heb, en de boel start op, dan zie ik in de monitor "hello world", de tijd en stand van de servo voorbij komen. Er gebrurt niets wanneer ik een R of L (inderdaad in hoofdletters) stuur.
De servo's doen ook niets (een wel tijdens initialiseren). In je originele code moeten de servo's op pin3 en pin4 worden aangesloten.

Terwijl ik dit schrijf, een idee...
Ai, even PuTTY geprobeerd ipv de serial monitor. Dan zie ik de cijfers wel voorbij komen. En de servo op pin4 doet het. Overigens zowel bij R als L indrukken. Dat zal nog wel een typo hier of daar zijn. Ga ik zo even naar kijken.

2) Je hebt het over de SweepServo.h library. Dat is niet de code die je laat zien. Dat is de INO.
Waar vindt ik die SweepServo.h. Ik heb wel die andere bestanden Adafruit .cpp en .h bestanden gedownload en in dezelfde directory gezet als de ino file.

As je het vervelend vindt dat ik je blijf storen, moet je het maar zeggen, dan zoek ik een andere manier. Moet me zeker gaan verdiepen in de Arduino programmeertaal. Het zo'n 40 jaar geleden dat ik echt geprogrammeerd heb (TurbBasic en Z80 machinetaal). Doe nu alleen nog een beetje website bouwen en onderhouden (PHP).

MVG, Ron