BeneluxSpoor.net forum
Vraag en antwoord => Digitaal => Topic gestart door: ron.kraaijkamp op 26 August 2020, 20:08:17
-
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)?
-
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.
-
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
-
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
-
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
-
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.
-
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/ .
-
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.
-
Hallo Ron,
Een antwoord op de vraag of Arcomora ook dat gedrag heeft. Antwoord: Nee.
mvg spock
-
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
-
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 ;D Maar dit is verder niet relevant aan je vraag.
Ik hoop dat je er wat aan heb ;)
Mvg,
Bas
#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 ) ;
}
}
}
-
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.
-
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.
void loop() {
currentTime = millis() ;
if( Serial.available() > 0 ) {
serialByte = Serial.read() ;
}
servoLeft() ;
servoRight() ;
}
Zie ik iets over het hoofd?
-
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
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:
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.
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 ;D
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:
#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 (https://github.com/bask185/State-Machine-Scripts/blob/master/modules/Adafruit_PWMServoDriver.cpp) en hier (https://github.com/bask185/State-Machine-Scripts/blob/master/modules/Adafruit_PWMServoDriver.h)
Ik hoop je hiemee verder geholpen te hebben.
Mvg,
Bas
-
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
-
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.
Nee joh doe niet zo gek, ik help je met plezier. vin'k leuk :laugh:
Ik heb je de verkeerde links gestuurd :o , I'm sorry normaal zet ik mensen niet op een dwaalspoor :-[. Die adafruit dingen zijn waardeloos die zijn er om een ander apparaat aan te sturen
Waar vind ik die SweepServo.h
Je moet dus deze (https://github.com/bask185/State-Machine-Scripts/blob/master/modules/servoSweep.cpp) en en deze (https://github.com/bask185/State-Machine-Scripts/blob/master/modules/ServoSweep.h) hebben.
Je kan met de xxxx.setState() functie dus de servo de ene kant en de andere kant opsturen door een 1 of een 0 tussen de () haken te zetten. Je kan dit dus makkelijk koppelen aan een input zoals in het voorbeeld.
Moet me zeker gaan verdiepen in de Arduino programmeertaal. Het zo'n 40 jaar geleden dat ik echt geprogrammeerd heb (TurbBasic en Z80 machinetaal)
Ik heb btw een tweetal docu's op internet staan die het een en ander uitleggen over C en gedeeltelijk over C++ (de taal waarin we arduino's programmeren). Deel 1 is echt puur uitleg over de taal, en deel 2 gaat meer over hoe je het best (m.i.) je processen kan coderen, dat gaat meer over state-machines en structuur e.d. Ik zou zeggen lees ze een keer door, het is een vrij complete basis maar je hoeft niet alles te snappen dus laat pointers of structs je vooral niet afschikken:
Deel 1 (https://github.com/bask185/State-Machine-Scripts/blob/master/images/Goed%20programmeren%20in%20C%20deel%201.pdf)
Deel 2 (https://github.com/bask185/State-Machine-Scripts/blob/master/images/Goed%20programmeren%20in%20C%20deel%202.pdf)
Mvg,
Bas
-
Fijn dat je me wil helpen Bas.
Dat je de verkeerde link stuurde vind ik een bewijs dat je menselijk bent ;) .
En leuk ook nog dat je mijn schrijffouten subtiel verbeterde.
Ik heb de nieuwe library gedownload en ga deze eens proberen.
In de eerste code zat op regel 94 nog een foutje. Na verbeteren werken nu beide servo's.
Ik ben blij dat je die library gemaakt hebt. Anders had ik toch verschillende keren hetzelfde stuk code moeten toevoegen. Voor elke servo een keer.
Bedankt voor de documenten. Ik ga ze doornemen.
Fijn weekend en bedankt.
Ron
-
Hallo Bas,
Ben ik weer.
Ik krijg foutmeldingen wanneer ik de code compileer.
Compiling sketch...
"C:\\Program Files (x86)\\Arduino\\hardware\\tools\\avr/bin/avr-g++" -c -g -Os -std=gnu++11
-fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics
-Wno-error=narrowing -MMD -flto -mmcu=atmega328p -DF_CPU=16000000L
-DARDUINO=10813 -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR
"-IC:\\Program Files (x86)\\Arduino\\hardware\\arduino\\avr\\cores\\arduino"
"-IC:\\Program Files (x86)\\Arduino\\hardware\\arduino\\avr\\variants\\standard"
"-IC:\\Program Files (x86)\\Arduino\\libraries\\Servo\\src"
"C:\\Users\\Ron\\AppData\\Local\\Temp\\arduino_build_636335\\sketch\\servoSweep.cpp.cpp"
-o "C:\\Users\\Ron\\AppData\\Local\\Temp\\arduino_build_636335\\sketch\\servoSweep.cpp.cpp.o"
servoSweep.cpp:74:6: error: prototype for 'void ServoSweep::setState(uint8_t)' does not match any in class 'ServoSweep'
void ServoSweep::setState( uint8_t _state ) {
^~~~~~~~~~
In file included from C:\Users\Ron\stack\_Ron\Modeltrein\Arduino\_Voorbeelden\NewServo+Library\servoSweep.cpp:8:0:
C:\Users\Ron\AppData\Local\Temp\arduino_build_636335\sketch\ServoSweep.h:10:10: error: candidate is: void ServoSweep::setState(bool)
void setState( bool _state );
^~~~~~~~
In file included from C:\Users\Ron\stack\_Ron\Modeltrein\Arduino\_Voorbeelden\NewServo+Library\NewServo+Library.ino:1:0:
C:\Users\Ron\AppData\Local\Temp\arduino_build_636335\sketch\ServoSweep.h:4:7: error: redefinition of 'class ServoSweep'
class ServoSweep {
^~~~~~~~~~
In file included from C:\Users\Ron\stack\_Ron\Modeltrein\Arduino\_Voorbeelden\NewServo+Library\servoSweep.cpp:8:0:
C:\Users\Ron\AppData\Local\Temp\arduino_build_636335\sketch\ServoSweep.h:4:7: note:
previous definition of 'class ServoSweep'
class ServoSweep {
^~~~~~~~~~
Using library Servo at version 1.1.6 in folder: C:\Program Files (x86)\Arduino\libraries\Servo
exit status 1
prototype for 'void ServoSweep::setState(uint8_t)' does not match any in class 'ServoSweep'
Geen idee waar ik het zoeken moet.
mvg Ron
-
Sorry ik zie de fout, ik zou zwerend at ik hem al opgelost had.
De compiler zegt dat hij de functie setState met uint8_t als argument niet kan vinden. Dat is correct omdat er in de header file (.h bestand) staat:
void setState( bool _state );
Dat moet worden:
void setState( uint8_t _state );
Ik heb als het goed is de library op de github pagina aangepast. Excuses alweer ::)
Een fijne avond,
Bas
P.S. Je post heeft deze pagina gesloopt ;D. Als je een te lange regel plaats tussen de code blocks dan krijg je dus fenomeen
-
Goedendag Bas,
Ik heb de code kunnen compileren. Tenminste, nadat ik mijn directory en INo file name had veranderd. Er zat een + in. Windows kan daar tegen, de compiler niet.
Moet regel 16 ook n iet veranderd worden van
bool state ;in
uint8_t state ;?
Verder initialiseerd de Arduino wel. De servo draait eerst als een gek tegen het einde van het draaimoment aan, om daarna de juiste positie te kiezen.
Als ik het goed begrijp moet je dus een 1 (5v) of een 0 (0V) aanbieden op pin 12. Dat doet nu nog niets.
Vandaag eens kijken of ik e.e.a. aan de praat kan kriigen.
Bedankt voor je input.
mvg Ron
-
Nu voor servoPin 4 genomen, dan gaat de servo niet zo tekeer.
Op 13 zit ook de LED van het board. En die zie je een paar keer knipperen bij het versturen van de gecompileerde code.
pinMode(inputButton, INPUT);toegevoegd om pin 12 als input te definieren. Niet dat het wat uitmaakt.
Ik zoek verder.
-
Mijn input werkt nu. Voor de duidelijkheid stuur ik de status naar de seriele monitor.
Afhankelijk van waar ik de inputButton (12) aansluit, zie ik bij 5V een 1 verschijnen. En biji 0V een nul.
De servo doet (nog) niets.
Op naar de volgende stap.
-
pinMode(inputButton, INPUT);
Maakt idd. geen verschil, omdat de modus "INPUT" de default is. Maar goed om toch te schrijven, dat komt de leesbaarheid van je code ten goede.
Vraagje: hoe is de inputButton aangesloten? Afhankelijk daarvan is het nl. misschien beter om pinMode(inputButton, INPUT_PULLUP); toe te passen? (Dat is als de button eenzijdig aan de 0 volt ligt.)
-
Vraagje: hoe is de inputButton aangesloten? Afhankelijk daarvan is het nl. misschien beter om pinMode(inputButton, INPUT_PULLUP); toe te passen? (Dat is als de button eenzijdig aan de 0 volt ligt.)
Dank Erik,
Op het moment sluit ik de input pin of op de 5V, of op de 0V. In de serial monitor (heb ik toegevoegd om iets te kunnen zien) zie ik dat ook terug.
Afhankelijk van de 5 of 0 volt zie ik een 1 of 0 in de monitor.
De servo doet nog niets.
Ben even wat anders gaan doen. Anders blijf ik in rondjes denken.
Verzonden vanaf mijn iPhone met Tapatalk
-
Ik heb nu
pinMode(inputButton, INPUT_PULLUP);
en dat is nog eenvoudiger dan een pull up weerstand.
-
Ok nu ben ik het zat >:(! Ik heb de oscilloscope gepakt om te kijken wat er nu misgaat.
Ik heb niet 1 maar wel 2 dingen ontdekt die niet klopten. In de sweep library gebruikte ik een private Servo object om de motor mee aan te sturen vanuit de library. Ik weet nog niet waarom maar dat werkt niet om een of andere duistere reden.
Ik had ook een fout gemaakt met een lokale variabele (currentTime) in de sweep method zelf. Ik heb deze variabele verwijdert en vervangen naar een call naar millis().
Ik heb de libraries op de github aangepast die moet je opnieuw downloaden. Ze werken nu ook iets anders
Dit wordt de nieuwe sketch:
#include "ServoSweep.h"
#include "Servo.h"
const int interval = 3000 ;
const int servoPin1 = 2 ;
const int servoPin2 = 3 ;
Servo servoMotor1 ;
Servo servoMotor2 ;
// min max speed frogJuicer pin
ServoSweep servoControl1( 10, 150, 50, 13) ;
ServoSweep servoControl2( 9, 150, 10, 12) ;
void setup() {
Serial.begin( 115200 ) ;
Serial.println(" hello world ");
servoMotor1.write( 90 ) ;
servoMotor2.write( 90 ) ;
servoMotor1.attach( 2 ) ;
servoMotor2.attach( 3 ) ;
delay(100);
}
void loop() {
uint8_t servoPos ;
servoPos = servoControl1.sweep();
if( servoPos ) {
servoMotor1.write( servoPos ) ;
Serial.println( servoPos ) ;
}
servoPos = servoControl2.sweep();
if( servoPos ) {
servoMotor2.write( servoPos ) ;
Serial.println( servoPos ) ;
}
byte b = Serial.read() ;
if( b == 'L') servoControl1.setState( 1 ) ;
if( b == 'l') servoControl1.setState( 0 ) ;
if( b == 'R') servoControl2.setState( 1 ) ;
if( b == 'r') servoControl2.setState( 0 ) ;
}
Het verschil zit in de sweep functie zelf. Voorheen deed deze functie de servo aan sturen, althans ik wilde dat hij dat deed. Nu retourneert de functie de servo positie. Als de geretourneerde waarde ongelijk is aan 0, dan moet de servo naar een nieuwe positie.
Met
servoPos = servoControl1.sweep();
Haal ik een eventuele nieuwe positie op
En met
if( servoPos ) {
kijk ik of de waarde iets anders is dan 0. Zo ja, dan wordt de if statement uitgevoerd en wordt:
servoMotor1.write( servoPos ) ;
de motor aangestuurd.
Ik ben nog niet tevreden met hoe de code er uit zien. We kunnen de sweep objecten en servo objecten nog aan elkaar koppelen door middel van for-loops. Dat is fijn als je er meer dan 2 wilt aansturen. Ik meen dat je met een UNO 6 servo's tegelijk kan aansturen, als je er nog meer probeert dan gaat de millis() functie misschien raar doen.
Deze code werk wel... deze keer. 3 keer is immers scheepsrecht en ik kan ook maar zoveel fout doen :laugh:
Ik ga even op internet rondvragen waarom mijn originele library niet werkte.
Mvg,
Bas
-
Hahaha, Ik hoop dat je mij niet zat bent.
In ieder geval werkt het nu goed.
Ik ga eens kijken of ik de boel met toetsen (niet die van de het keyboard) aangesloten op de Arduino de servo's kan omzetten.
Ik ben van plan 10 wissels in mijn schaduw station ermee te bedienen. Kwestie van twee Arduino's.
Voor de boven baan moet nog eens kijken hoeveel ik nodig heb.
Bedankt voor al je moeite.
-
Ik hoop dat je mij niet zat bent
Nee, nog niet hoor :P
Ik ben van plan 10 wissels in mijn schaduw station ermee te bedienen. Kwestie van twee Arduino's.
So much to learn, this one has ;D
Die 'verkeerde' library die ik je per toeval opstuurde, die is per toeval gemaakt om om dit apparaat aansluiten:
Klik mij (https://hackerstore.nl/Artikel/1218).
Dit is een spotgoed servo driver board die je met 4 draden op je arduino kan aansturen. 5V, ground, A4 en A5. Dit boardje kan probleemloos 16 servo's aansturen en kost onder de 5 euro. Natuurlijk zijn ze voor 3 euro te vinden in China.
Wat ook wel een bijkomend voordeel is. Nu de servo sweep library slechts de posities uitrekent, ben je niet meer gedwongen om Arduino's servo library te gebruiken. Je kan dus die ene adafruit library gebruiken met dat pca9685 boardje in combinatie met de sweep library.
Echter als we het hebben over 5 wissels links en 5 wissels rechts met daartussen meer dan een meter spoor dan doe je er nog steeds goed aan om 2 losse arduino's te gebruiken ivm met storingen op de kabels. Als je echter 1 wisselstraat hebt waar alle 10 wissels in liggen, dan raad ik dit boardje aan.
Dan is er nog een interessant punt over het aansturen van de arduino. Je kan natuurlijk 10 wipwap schakelaars op dat ding aansluiten en je wissels individueel aansturen. Ik heb persoonlijk de pest aan het aansturen van losse wissels en daarom schakel ik complete wisselstraten.
Als je 6 sporen heb dan kan je ipv de 10 wip waps 6 drukknopjes gebruiken. Met deze drukknopjes kan je een weerstandsdeler maken die je op een analoge pin op een arduino kan inlezen. Ipv de wissels, schakel je dan de complete straat. Die wissels die dan omgezet moeten worden, zullen allemaal naar de goede positie sweepen.
Je gebruikt dan 1 input op de arduino en je kan hem ook nog dubbel bedraden naar 2 arduino's indien nodig. Is dit misschien een idee voor je?
Mvg,
Bas
-
So much to learn, this one has ;D
Dat is voor mij niet anders. Al ben ik nu 61 jaar jong.
Die 'verkeerde' library die ik je per toeval opstuurde, die is per toeval gemaakt om om dit apparaat aansluiten:
Klik mij (https://hackerstore.nl/Artikel/1218).
Dit is een spotgoed servo driver board die je met 4 draden op je arduino kan aansturen. 5V, ground, A4 en A5. Dit boardje kan probleemloos 16 servo's aansturen en kost onder de 5 euro. Natuurlijk zijn ze voor 3 euro te vinden in China.
Op het moment gebruik ik deze (makkelijk aansluiten):
(https://images.beneluxspoor.net/bnls/IMG_1823_3.jpg) (https://images.beneluxspoor.net/bnls/IMG_1823_3.jpg)
En heb deze ook nog liggen (uit China):
2-Way Motor and 16-Weg Servo Motor Drive Board (https://nl.aliexpress.com/item/32891439116.html?spm=a2g0s.9042311.0.0.1fba4c4dxjTi6E)
Wat ook wel een bijkomend voordeel is. Nu de servo sweep library slechts de posities uitrekent, ben je niet meer gedwongen om Arduino's servo library te gebruiken. Je kan dus die ene adafruit library gebruiken met dat pca9685 boardje in combinatie met de sweep library.
Dat boardje stuur je dan aan via I2C?
Echter als we het hebben over 5 wissels links en 5 wissels rechts met daartussen meer dan een meter spoor dan doe je er nog steeds goed aan om 2 losse arduino's te gebruiken ivm met storingen op de kabels. Als je echter 1 wisselstraat hebt waar alle 10 wissels in liggen, dan raad ik dit boardje aan.
Dit wordt mijn schaduw station:
(https://images.beneluxspoor.net/bnls/Zolder_Ron_1_NieuweVorm-blokken-wissels-nivo-0_1.jpg) (https://images.beneluxspoor.net/bnls/Zolder_Ron_1_NieuweVorm-blokken-wissels-nivo-0_1.jpg)
Inmiddels zijn de wissels W021* weggehaald. Zag er het nut niet van gezien het korte stuk aan de rechter onderzijde van die wissels.
Misschien heb ik er wel 3 nodig. De twee wissels links boven en die rechtsboven liggen zo'n 160 cm uit elkaar.
De meeste wissels zijn electrische. Behalve de twee link boven. Ik denk dat ik de elektrische verander in servo aangedreven modellen. Het is allemaal oud spul, dus kan met een gerust hart experimenteren. Of ik stuur ze toch elektrisch aan (met twee MOSFET printjes ertussen). Dat heb ik al werkend gekregen in mijn initiele code. Ik weet het nog niet. Met servo's werken is wel subtieler.
Dan is er nog een interessant punt over het aansturen van de arduino. Je kan natuurlijk 10 wipwap schakelaars op dat ding aansluiten en je wissels individueel aansturen. Ik heb persoonlijk de pest aan het aansturen van losse wissels en daarom schakel ik complete wisselstraten.
Als je 6 sporen heb dan kan je ipv de 10 wip waps 6 drukknopjes gebruiken. Met deze drukknopjes kan je een weerstandsdeler maken die je op een analoge pin op een arduino kan inlezen. Ipv de wissels, schakel je dan de complete straat. Die wissels die dan omgezet moeten worden, zullen allemaal naar de goede positie sweepen.
Je gebruikt dan 1 input op de arduino en je kan hem ook nog dubbel bedraden naar 2 arduino's indien nodig. Is dit misschien een idee voor je?
Dat heb ik ook getest aan de hand van de ASAR code. Je ziet op de foto nog een overblijfsel van de test. Werkt ook goed. Zou ik ook kunnen gebruiken.
Ik ben zelf gaan experimenteren om enig inzicht te krijgen in de materie. Daar moet ik nog aan werken, heb je wel gemerkt.
En eventueel dus elektrische wissels aan te sturen. Daar moet ik nog over denken.
Bedankt voor het meedenken.
mvg,
Ron
-
Dat boardje stuur je dan aan via I2C?
Yep (y)
Ik heb ontdekt waarom mijn library de eerste keer niet werkte. Het is een beetje ingewikkeld verhaal. Het programma wat je ziet in de .ino is niet het hele verhaal. Onderhuids gebeuren er nog meer dingen zoals de init() functie. Arduino's init() krijg je niet te zien, maar deze initialiseert alle hardware zoals de timers. Deze functie zorgt er o.a. voor dat de millis() functie werkt.
Deze regel:
ServoSweep motor1(pin, min, max, tijd);
roept de zgn. constructor aan. Het object wordt dan aangemaakt. Je kan de constructor gebruiken om alle variabelen die te maken hebben met dat object te initialiseren. Dat doen we dus met pin nummer, min stand, max stand en de beweeg tijd. Wat je niet mag doen in deze constructor is ook hardware dingen initialiseren. De constructor wordt namelijk uitgevoerd voordat de init() functie wordt uitgevoerd.
En wat ik dus fout deed, was in de constructor deze regels aanroepen:
servo.write( middlePos ) ;
servo.attach( pin ) ;
De attach functie die stelt timer 1 in om de servo motors aan te sturen. Maar als vervolgens init() wordt aangeroepen door arduino dan wordt timer 1 weer helemaal vernaggeld.
De oplossing was om de attach() functie uit de constructor te halen en om een nieuwe functie te maken (.begin() ) die je in de void setup() aanroept.
void setup() wordt namelijk uitvoerd na de init() functie is uitgevoerd. Zodoende wordt servo.attach() ook na de init() uitgevoerd en zou het goed moeten gaan.
Ik heb de library nu zo aangepast dat de libary alleen gebruik maakt van de servo.h library als je een pinnummer invoert in de constuctor die ongelijk is aan 255. De sweep functie retourneert namelijk ook nog steeds de positie zodat je dus ook een andere servo aansturing zou kunnen gebruiken zoals bijvoorbeeld die pca9685.
Als je dus bijvoorbeeld pinnummer 2 gebruik, wordt pin 2 direct gebruikt voor een servo motor en hoef je eigenlijk niks te doen met de return waarde van .sweep().
Wat ik fout deed, is een echte typische 'rookie mistake'. Zo zie je maar dat ook ik nog het een en andere kan leren :police:
Ik heb bijvoorbeeld ook geleerd om eerst vanavond de library te testen met m'n oscilloscoop voordat ik beweer "het zou moeten werken" ;D
De pauze is weer voorbij, dus een fijne dag verder,
Bas
-
Hallo Bas,
Ik snap wat je bezig houd. Zo'n probleem laat je niet los. Vroeger had ik een papiertje naast het bed, voor ideeen die ik 's nachts kreeg.
Ik begrijp wat je beschrijft en waarom het niet wilde werken.
Vanavond zal ik eens kijken. Ik ben net als jij aan het werk en dat kost best veel tijd ;-).
Ik hoop over een paar jaar met vervroegd pensioen te gaan. Heb ik meer tijd.
Alweer bedankt.
mvg Ron
-
Bas,
Na het nog een keer doorlezen van je bericht, ben ik toch verward.
Kan ik de initiele sketch gebruiken en de servoSweep (cpp en h) library moet ik opnieuw downloaden?
mvg, Ron
-
Ik vermoed het ja, maar ik heb het nog niet getest thuis. Dat kan ik vanavond pas doen.
Mvg,
Bas
-
ik vergeet iets te zeggen!
De originele sketch moet je uitbreiden met een call naar servo1.begin() en servo2.begin() (of hoe jij je motoren genoemd heb) aan te roepen in de void setup()
#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() {
servo1.begin() ; <-- dit toevoegen voor elke motor
}
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 ) ;
}
-
Wat je niet mag doen in deze constructor is ook hardware dingen initialiseren. De constructor wordt namelijk uitgevoerd voordat de init() functie wordt uitgevoerd.
Hee, weer wat geleerd, thnx! (y)
Heb al veel geleerd van mijn eigen fouten, maar die van anderen helpen daar ook bij. ;-) Ik lees ook mee op het Arduino forum, dat is vooral heel leerzaam omdat daar problemen aan de orde komen waarover je in de handleidingen niets vindt!
-
Ja je raakt nooit uitgeleerd.
Volgens mij oscilloscoop lijkt deze sketch te werken...
#include "ServoSweep.h"
const int inputButton1 = 11 ;
const int inputButton2 = 12 ;
const int servoPin1 = 2 ;
const int servoPin2 = 3 ;
unsigned long prev ;
byte state ;
// pin min max speed (bigger speed = slower movement ;
ServoSweep servo1(servoPin1, 0, 180, 20, 13) ; // led 13 is puntstuk output
ServoSweep servo2(servoPin2, 0, 180, 50) ;
void setup() {
Serial.begin( 115200 ) ;
pinMode( inputButton1, INPUT_PULLUP ) ;
pinMode( inputButton2, INPUT_PULLUP ) ;
servo1.begin() ;
servo2.begin() ;
}
void loop() {
servo1.sweep(); // de sweep moet continu aangeroepen worden
servo2.sweep(); // de sweep moet continu aangeroepen worden
char b = Serial.read() ;
if( digitalRead( inputButton1 ) ) servo1.setState( 1 ) ; // door setState aan te roepen met een 1 of een 0, kan je motor laten bewegen
else servo1.setState( 0 ) ;
if( digitalRead( inputButton2 ) ) servo2.setState( 1 ) ; // door setState aan te roepen met een 1 of een 0, kan je motor laten bewegen
else servo2.setState( 0 ) ;
}
Mvg,
Bas
-
Hallo Bas,
Het werkte in een keer. Dat had je al gezegd omdat je het getest had.
Je hebt de input nu anders gemaakt. En er kan nu met een tuimelschakelaar gewerkt worden.
Ik hoor de servo's nog wel een beetje rommelen. Dan komt waarschijnlijk omdat ze rommel oppikken op de servo pin.
Ik zal een test of dat te verhelpen is met een weerstand 4k7 van de servo pin naar de 5 volt te leggen.
Bij eerdere testen had ik detach gebruikt. Dan hield het ook op. Is dat hier ook te gebruiken? Ik twijfel namelijk omdat detach voor alle servo's tegelijk werkt.
Weer bedankt voor je moeite die je erin gestoken hebt.
mvg Ron
-
De pull up op de servo pin hielp niet.
Nu slapen. Half zes weer op.
Verzonden vanaf mijn iPhone met Tapatalk
-
Hoi,
Dat rommelen van de servo ga je niet oplossen door een pullup weerstand.
Het rommelen wordt veroorzaakt omdat de aanstuurpuls van de servo softwarematig wordt gegenereerd en dit niet exact constant is bij een arduino.
mvg spock
-
Dat dacht ik ook Spock, was het proberen waard. Had het ergens in een draadje gelezen.
Ik ga vanavond maar eens kijken of dat met een detach goed gaat.
-
Dat moet sowieso werken omdat je dan de pulsentrein stopt. Ik kan dat wel toevoegen aan de library. Dan hoef jij alleen maar de library weer te update ;)
Bas
-
Als je het goed doet dan is die puls super stabiel. Probleem is hier dat er een library wordt gebruikt. Lijkt slim maar voor een eenvoudig stukje hardware als een servo die alleen maar een tussen 1 en 2 mseconde regelbaar pulsje nodig heeft is dat een olifantengeweer gebruiken voor een veldmuis.
Veel beter 1 van de drie timers gebruiken op een interupt. Omdat die puls van die ene ms slechts een 50tal keer per seconde hoeft te worden gegeven blijft er een zee van tijd over om wel tot 16 servo met die ene timer aan te sturen. Jawel dat is de truck van dat adafruit printje.
Wel is er dan een schuifregister story nodig om de seriele aansturing van de servoos parallel te maken. Das niet zo een grote uitdaging....Succes..... Rob
-
Lijkt slim maar voor een eenvoudig stukje hardware als een servo die alleen maar een tussen 1 en 2 mseconde regelbaar pulsje nodig heeft is dat een olifantengeweer gebruiken voor een veldmuis.
Welkom in de wereld van C++ en OO programmeren. Collega Meino gebruikte zelfs een eigen library om de stand van een input uit te lezen terwijl hij het volgens mij afkon met digitalRead(), maar nogmaals, dat is C++ voor je.
Ik vind je analogie met library en olfifantengeweer wel wat vergezocht, een classe of een library is eigenlijk niet veel dan een geupgrade struct.
Dat adafruit printje werkt trouwens met I2C, daar heb je geen schuifregister voor nodig. Ik weet niet waar je dat vandaan heb? ander printje?
Ik weet wel dat je met een decade counter wel 10 servo's kan aansturen met een IO pin. Maar dat is weer wat anders.
Ik weet niet precies hoe die arduino library precies werkt. Ik weet alleen dat hij drie servo's op willekeurige IO kan laten draaien. Ik weet alleen niet hoe hij dat doet.
Arduino libraries zijn allemaal OO (object orientated) geschreven en dan heb je dus dit soort dingen. Ik vind het al knap dat hun library zo werkt zoals het nu doet.
Wat ik zelf wel eens gedaan heb, is om inderdaad zelf via een timer ISR meerdere servo's aan te sturen. Dat zag er ongeveer zo uit:
ISR(TIMER1_COMPA_vect) { // set at every 5us
static uint16_t counter = 0 ;
if( counter == 0 ) {
PORTB |= ( 1 << motor1.pin ) | ( 1 << motor2.pin ) | ( 1 << motor3.pin ) ; // turn on all pwm pins
}
if( counter == motor1.pos ) PORTB &= ~ (1 << motor1.pin ) ; // turn them off when it is their time
if( counter == motor2.pos ) PORTB &= ~ (1 << motor2.pin ) ;
if( counter == motor3.pos ) PORTB &= ~ (1 << motor3.pin ) ;
counter ++ ;
if( counter == 3600 ) counter = 0 ;
}
Even gauw in elkaar geflanst. De interval tijd zou hier 5.55556us moeten zijn omdat ( 2000us - 1000us) / 180 posities = 5.55556us per graad.
Na 3600 cycles is er dan precies 20ms gepasseerd en begint het weer opnieuw.
Probleem is alleen dat dit niet werkt met de standaard Arduino macro's een OO manier van programmeren. Volgens mij vreet deze methode ook meer performance, maar daar ik niet weet hoe hun library werkt, weet ik het zeker.
-
Dat moet sowieso werken omdat je dan de pulsentrein stopt. Ik kan dat wel toevoegen aan de library. Dan hoef jij alleen maar de library weer te update ;)
Bas
Graag dan.
Had zelf al zitten proberen. En kwam erachter dat het via de library moest.
Werd te laat.
Mvg Ron
Verzonden vanaf mijn iPhone met Tapatalk
-
Ik heb de code aangepast en dit wordt de nieuwe sketch. Je moet op de github pagina ook even zoeken naar de debounceClass.cpp en .h die heb je nu ook nodig omdat:
Om de servo sweep te laten attachen, moest ik dit doen in de functie setState. Tot op heden, riepen wij deze functie eigenlijk continu aan. De debounce class is gemaakt om precies dit soort problemen op te vangen. De schakelaars worden gefiltered van ruis en inputs kennen nu behalve de states ON en OFF ook een RISING en een FALLING state.
Als we dit in de sketch implementeren:
#include "ServoSweep.h"
#include "debounceClass.h"
const int pin5 = 5 ;
const int pin6 = 6 ;
Debounce btn1( pin5 ) ;
Debounce btn2( pin6 ) ;
unsigned long prevTime = 0 ;
byte state1 = 1;
byte state2 = 1;
ServoSweep servo1(3, 10, 180, 20, 1, 13 ); // de 1 is nieuw en geeft aan dat we detach willen gebruiken
ServoSweep servo2(4, 6, 10, 1, 20 );
unsigned long prev ;
void setup() {
Serial.begin(115200) ;
Serial.println("hello world");
}
void loop() {
unsigned long currTime = millis() ;
if( currTime > prevTime ) {
prevTime += 20 ; // debounce interval is 20ms
btn1.debounceInputs();
btn2.debounceInputs();
}
uint8_t btnState = btn1.readInput() ;
if( btnState == RISING ) {
servo1.setState( 1 );
Serial.println("motor 1 is true") ;
}
if( btnState == FALLING ) {
servo1.setState( 0 );
Serial.println("motor 1 is false") ;
}
btnState = btn2.readInput() ;
if( btnState == RISING ) {
servo1.setState( 1 );
Serial.println("motor 2 is true") ;
}
if( btnState == FALLING ) {
servo1.setState( 0 );
Serial.println("motor 2 is false") ;
}
servo1.sweep( );
servo2.sweep( );
}
Het is natuurlijk ongetest en mijn pauze is weer voorbij ;D dus het is nog experminenteel. Maar ik heb er vertrouwen in (y)
De debounce code heb ik getest en werkt:
hello world
motor 1 is true
motor 2 is true
motor 1 is false
motor 1 is true
motor 2 is false
motor 2 is true
De code in de library heeft nu deze toevoeging in setState
if( turnOff ) servo.attach( servoPin ) ;
en in sweep staat:
if( ( pos == servoMax || pos == servoMin ) && turnOff == 1 ) servo.detach( ) ;
Dus de sweep functie detacht, en de setState attacht, mits turnOff gelijk is aan 1 en die wordt in de constructor gezet.
Mvg,
Bas
-
@Bask185
Ik zie vandaag pas dit draadje.
Een voor de hand liggende vraag is voor mij: waarom gebruik je Mardec niet?
Daarmee kun je ook zonder DCC de servo's 'omzetten'.
Zelf knutselen aan software is natuurlijk leuk, maar waarom moeilijk doen als het ook gratis makkelijk kan?
Mvg
Nico
-
Je stelt de vraag aan de verkeerde persoon. Ik gebruik namelijk niks, ik bouw code.
, maar waarom moeilijk doen als het ook gratis makkelijk kan?
Ik doe helemaal niet moeilijk, ik ontwikkel en bouw simpelweg nieuwe code om zowel de OP verder te helpen als voor de compleetheid van mijn module folder in mijn github pagina. Ik zag meerwaarde in deze module voor het groter goed en ik heb nu een gouden tester die zeer waardevolle feedback oplevert. Mutual beneficial!
En wat simpel is, is relatief. Ik heb nooit met die mardec sw gewerkt en dat ga ik wss ook nooit zelf doen. Als ik het me goed herinner moet je via de terminal allemaal dingen instellen? En ik hoorde dat niet iedereen dat even 'simpel' vindt. Dit probleem vind ik sws niet een ingewikkeld probleem en het voor mij ook weer niet echt een uitdaging. Mardec kwam ook niet eens bij me op.
Nu is de gebruiker zelf instaat om deze module 'simpel' toe te voegen aan een bestaand programma. En in het voorbeeld zijn alle variabelen hardcoded bovenin het .ino bestand. Ik weet niet hoe modulair mardec is opgebouwd?
De OP met een programmeergeschiedenis, wilt ook leren van dingen en daar help ik hem ook meteen bij.
Mvg,
Bas
-
Hoi Nico,
Uiteraard ben ik op de hoogte van Mardec. Mooie stuk software, samen met de DCCnext en de andere modules vormt het mooi geheel.
Was alleen in de veronderstelling dat je het alleen kan aansturen via een DCC signaal/adres.
Ook ASAR bekeken. Dus zonder DCC. Ook goed om te gebruiken.
En wat je zegt. Het is leuk om met de code te spelen. En een indruk te krijgen hoe e.e.a. werkt.
Door Bas is dat voor mij nog in een stroomversnelling geraakt.
Ik heb een combinatie van hand en electrische wissels. Die kan ik met ASAR niet aansturen. Dus had zelf wat in elkaar geflanst. Heel rudimentair.
Het werkte zowel voor servo gestuurd wissels and electrische. En toen kwam mijn vraag "Arcomora en mijn begrip van Arduino".
En zo is het gekomen.
mvg Ron
-
ik heb nu een gouden tester die zeer waardevolle feedback oplevert. Mutual beneficial!
Hahaha, dank je Bas.
Het is niet uitgesloten dat ik later toch overstap naar Arcomora. Wanneer ik helemaal digitaal ga.
Het een sluit het ander niet uit.
Ik vind het leuk om met de code bezig te zijn en te testen. Daar leer ik een hoop van.
@Nico, ik heb alles al gedownload en doorgelezen van Arcomora, en vind het een mooi product. En ik, en vele met me, waardeer het dat je het niet commercieel uitbuit.
Zo blijft de hobby betaalbaar.
-
Ik heb de code aangepast en dit wordt de nieuwe sketch. Je moet op de github pagina ook even zoeken naar de debounceClass.cpp en .h die heb je nu ook nodig omdat:
Om de servo sweep te laten attachen, moest ik dit doen in de functie setState. Tot op heden, riepen wij deze functie eigenlijk continu aan. De debounce class is gemaakt om precies dit soort problemen op te vangen. De schakelaars worden gefiltered van ruis en inputs kennen nu behalve de states ON en OFF ook een RISING en een FALLING state.
Het is natuurlijk ongetest en mijn pauze is weer voorbij ;D dus het is nog experminenteel. Maar ik heb er vertrouwen in (y)
De debounce code heb ik getest en werkt:
Hallo Bas,
hier is je "gouden tester" weer.
De code werkt nog niet.
De in de debounceClass.h staat nog een keer een include van dezelfde H file. Dat kan natuurlijk niet en de compiler klaagt daar ook over. Ik heb de lijn uitgecomment (wat een woord) en krijg dan andere klachten. Tenminste de compiler.
"unsigned long prevTime = 0 ;" geeft de compiler aan.
-
@Nico Teering:
Hoe bedoel je dat je Mardec ook kan gebruiken zonder digitaal te gaan.
Je moet de DCCnext toch aansturen met een DCC adres?
Ik hoor het graag.
mvg, Ron
-
Je kan op een Mardec poorten zo configureren dat je er een schakelaartje op kan aansluiten, en instellen welke outputs daarmee geschakeld worden,.
-
Dank Nico,
Dan ga ik de handleiding nog eens doornemen.
Een overgang naar DCC is redelijk eenvoudig te doen.
Gebruik van dezelfde hardware en software.
mvg Ron
-
Ron
Ik volg je draadje ook. Maar tot nu toe nog niet veel aan commentaar geleverd omdat je al genoeg adviezen en hulp van Bas krijgt. Maar als je je verder wilt verdiepen en toch ook met DCC aan de gang wilt, Ik heb ook een heel draadje gewijd aan mijn aanpak van automatisering van mijn treinbaan met Arduino's. Maar het zou kunnen dat dat veel te erg de diepte ingaat, kijk maar. Dat draadje heet De Canbus komt naar Kranenberg (https://forum.beneluxspoor.net/index.php?topic=90291.msg3222059904#msg3222059904). Dat draadje bevat ook stukken arduino code waar je gebruik van kunt maken.
Groet Meino
-
Hallo Meino,
alle informatie is nieuw voor mij na 45 jaar als herintreder.
Ik ga je draadje ook eens doornemen.
Mvg, Ron
-
Ik had hem aan mijn kant wel succesvol gecompileerd. ??? Ik zal om 12:45 even kijken
-
Geen haast Bas.
Ik ben ook gewoon aan het werk en het is erg druk. Dus geen tijd voor privé zaken.
Mvg Ron
Verzonden vanaf mijn iPhone met Tapatalk
-
Zie het al, er stond nog een demo programma in debounce.h die had in commentaar moeten staan.
Je kan of een nieuwe debounce.h downloaden maar je kan ook alles achter de #endif op regel 23 verwijderen. De #endif moet blijven staan
-
Yup, compileerde nu goed.
Vanavond even verder testen.
Het is verleidelijk om de Arduino mee naar het werk te nemen. Dat gaan ze niet accepteren denk ik ;-).
-
Ik heb er bij mn werkstation permanent 1tje aan mn pc hangen. Ze zijn soms best handig om ff gauw een reeks getallen te berekenen, ik gebruik ze ook om te kijken of een bepaalde berekening werkt. Soms heb je onverwachts een bug met variabele groottes of typecasts en in de pauze kan je er ff code mee debuggen. Onboard Led 13 is mijn beste vriend soms ;D
Je hebt ook arduino's in de vorm van een USB stick, die kan je stiekem achterin je computer pluggen.
Bas
-
Ik denk denk dat ik deze keer iets goeds heb gedaan. Volgens de scoop valt het signaal weg zodra de servo zijn uiterste stand heeft bereikt, as requested :police:
Wat is de volgende uitdaging? :P
Bas
-
Hi Bas,
je hebt zeker iets goeds gedaan.
Nog niet 100% ;).
Het maakt niet uit of ik button 1 of 2 (pin 5 en 6) gebruik, servo 1 gaat altijd om.
De buttons worden wel goed ingelezen, dat zie ik op de monitor.
Zelf even gekeken en op lijn 43 en 48 gebruik je weer servo1. Dat moet servo2. zijn.
Werkt nu.
Ik heb een hoop geleerd op deze 5 pagina's. Waarvoor dank.
-
Hi Bas,
Een volgende uitdaging. Op het moment zou ik het niet weten.
Misschien anderen die meelezen.
mvg, Ron
-
Sorry voor de wat late reactie
Hoe bedoel je dat je Mardec ook kan gebruiken zonder digitaal te gaan.
Je moet de DCCnext toch aansturen met een DCC adres?
Ik hoor het graag.
Zoals Hennik (niet mijn persoon) al zei kun je ook middels schakelaars alles bedienen.
Dat is het mooie van Mardec. Door het gebruik van inputs te combineren met DCC kan je een accessoire zowel handmatig als automatisch aansturen.
Mvg
Nico
-
Geen probleem Nico,
Ik heb de handleiding nog eens doorgelezen en het is me duidelijk dat het Mardec ook kan.
Dus wanneer je een moment schakelaar gebruikt en een servo “kost” dat twee pinnen. Bij een elektrisch wissel drie pinnen.
Het maximum komt dan voor een DCCnext op vijf elektrische wissels met moment schakelaars te liggen. Met een DCC signaal hou je de pinnen van de moment schakelaars vrij voor andere zaken.
Verzonden vanaf mijn iPhone met Tapatalk
-
Hi Bas,
je wilde nog een uitdaging.
Ik heb beide servo's aangesloten.
De tweede servo reageert niet op de speed parameter. Het maakt niet uit wat je daar opgeeft.
Het gaat om servo2 dit op pin 4 is aangesloten.
Ben zelf ook aan het zoeken naar een reden.
Nog niet gevonden, dat mag duidelijk zijn.
Update;
het heeft te maken met de frogpin. Wanneer je die wel definieerd, werkt speed wel.
Ik zoek nog even verder.
Update 2;
De volgorde van onderstaande code in servoSweep.cpp klopt niet.
ServoSweep::ServoSweep( uint8_t _servoPin, uint8_t _min, uint8_t _max, uint8_t _turnOff, uint8_t _speed ) { // constructor 1
Dat moet zijn.
ServoSweep::ServoSweep( uint8_t _servoPin, uint8_t _min, uint8_t _max, uint8_t _speed, uint8_t _turnOff ) { // constructor 1
Hierdoor worden parameters verkeerd doorgegeven
mvg, Ron
-
De volgorde van onderstaande code in servoSweep.cpp klopt niet.
(y)
Stom dat die compiler er niks van zegt. Je hoeft offcieel volgens mij in het .h bestand niet eens de namen op te geven alleen de datatypes. Maar goed dat ik het toch gedaan heb :police:
Bas
-
Hi Bas,
Ik had ook gedacht dat de volgorde niet belangrijk zou zijn, gezien het feit dat de namen gedeclareerd zijn.
Ik kon me uit mijn programmeer verleden herinneren dat het toen wel belangrijk was. Kennelijk nog.
Mvg, Ron.
Verzonden vanaf mijn iPhone met Tapatalk