Go Down

Topic: 3x Lineare meting tbv frees (Read 11565 times) previous topic - next topic

Sjuuls

en de rest...

Quote

void loop(){                                                     //Hoofd programma, wordt elke cyclus doorlopen is leeg maar moet wel aanwezig zijn
    
}

void A_RISE(){                                                   //Sub programma met de naam A_Rise
 detachInterrupt(0);                                             
 A_SIG=1;
 
 if(B_SIG==0)
 pulses++;//moving forward
 if(B_SIG==1)
 pulses--;//moving reverse
 Serial.println(pulses);
 attachInterrupt(0, A_FALL, FALLING);
}

void A_FALL(){                                                   //Sub programma met de naam A_FALL
  detachInterrupt(0);
 A_SIG=0;
 
 if(B_SIG==1)
 pulses++;//moving forward
 if(B_SIG==0)
 pulses--;//moving reverse
 Serial.println(pulses);
 attachInterrupt(0, A_RISE, RISING); 
}

void B_RISE(){                                                   //Sub programma met de naam B_Rise
 detachInterrupt(1);
 B_SIG=1;
 
 if(A_SIG==1)
 pulses++;//moving forward
 if(A_SIG==0)
 pulses--;//moving reverse
 Serial.println(pulses);
 attachInterrupt(1, B_FALL, FALLING);
}

void B_FALL(){                                                   //Sub programma met de naam B_FALL           
 detachInterrupt(1);
 B_SIG=0;
 
 if(A_SIG==0)
 pulses++;//moving forward
 if(A_SIG==1)
 pulses--;//moving reverse
 Serial.println(pulses);
 
 attachInterrupt(1, B_RISE, RISING);
}
void schrijven(){                                                //Sub programma met de naam schrijven
   lcd.setCursor(3,0);                                           //Plaats cursor op karakter 3 op regel 0
   lcd.print("               ");                                 //ruimte leegmaken (vanaf karakter 0 op regel 3) dmv deze met spaties te overschrijven
   lcd.setCursor(3,0);                                           //Plaats cursor op karakter 3 op regel 0
   lcd.print(pulses);                                            //aantal pulsen schrijven
 }


MAS3

Hoi Sjuul.

Ik ben ook nog maar een jaartje bezig (maar heb wel al heel lang geleden eens naar basic en machinetaal programmeren gekeken en wat later ook eens naar Delphi, een Pascal variant).
Omdat ik nog niet zo lang bezig ben voel ik me ook nog redelijk groen.
En daar is helemaal niets mis mee.
Deze week mocht ik mezelf nog betrappen op een "groen" stukje code dat maar niet wilde werken.
Dit was dat stukje:

Code: [Select]

      if (currentMillis - LastFlash > FlashOn && ledState = 1) {


Dat is fout, omdat hier ledState niet gecontroleerd word op de waarde 1 (want dat moet  met == ), maar dat die hier de waarde 1 krijgt toegewezen.
En dat heeft veel gevolgen, want verderop in je code gaat dan ineens ook nog van alles fout.

Eerder haalde ik het gebruik van functies aan, maar ik denk dat je daar nog even niet aan toe bent dus daar ga ik verder even niet op in.

Inderdaad als je wil dat er iets "de hele tijd" word herhaald, dan zet je dat in je loop want die loop doet niets anders dan herhalen.
Wat je in het voorbeeld dat ik hierboven aanhaalde zult vinden, is dat er keuzes worden gemaakt om te bepalen of een stukje code wel of niet word uitgevoerd.
Dat is waarom ik zei dat je programma sneller kan verlopen, omdat als er aan een voorwaarde niet word voldaan, je dan dat stukje kunt overslaan en dus meer tijd hebt om iets anders te doen.

Ik zie dat je inmiddels wat code hebt geplaatst, daar ga ik zo naar kijken om te zien of ik er iets uit kan pikken.
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

MAS3

Okee ik heb er een blik op geworpen (ging sneller dan ik verwachtte).

Je hebt allerlei functies aangemaakt.
Die functies gaan verschillende dingen doen als je ze aanroept.
Dat zijn de RISE en FALL toestanden, maar ook "schrijven", waarin je naar je LCD wil schrijven.
Maar je roept ze dus nooit aan in je loop.
Alles wat je in je sketch hebt staan, word hooguit 1 maal uitgevoerd.
Dan begint je loop, waar je nooit meer uitkomt.
Maar omdat die loop leeg is, gebeurt er dus helemaal niets meer en breng je je Arduino dus in een kunstmatige coma.

Ik vraag me ook af of je geen foutmeldingen krijgt.
Want je gebruikt functies en variabelen met dezelfde naam (A_RISE en B_RISE).
Behalve dat het programma zich hierin zou kunnen verslikken (weet ik niet zeker), zit het er wel dik in dat jij je er in zult gaan verslikken.
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

Sjuuls

Ok, functies lijken een beetje op funtiebouwstenen die op een bepaald moment wel of niet oproept naar gelang de programma afloop.
ik ga me hier eens even wat beter in verdiepen.

op het schrijven naar het display na werkt ie gewoon perfect en zie ik de pulsen op de serial monitor stijgen of dalen naargelang de ringting ik opdraai met de encoder.


de code van de encoder heb ik uit dit filmpje en via de link vind je de code zelf.
de code wordt regel per regel uitgelegd, ik ga deze nog eens bestuderen 

http://www.kevindarrah.com/download/arduino_code/Encoder.pde

http://www.youtube.com/watch?v=HQuLZHsGZdI

Ik kan weer aan de bak  :)

MAS3

Wat doet de backlight van je LCD tijdens de uitvoering van jouw sketch ?

En lees nog even je eigen commentaren en vergelijk dat met mijn vorige berichtje.
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

Sjuuls

Ben nog niet helemaal bij-gelezen maar heb toch al weer wat te melden.
Ik heb mijn functie "void schrijven" gewist en vervolgens de code ervan in de void loop gezet.

Code: [Select]
//-------- Hoofdprogramma ------------------

void loop(){                                                     //Hoofd programma, wordt elke cyclus doorlopen is leeg maar moet wel aanwezig zijn
   lcd.setCursor(3,0);                                           //Plaats cursor op karakter 3 op regel 0
   lcd.print("              ");                                  //ruimte leegmaken (vanaf karakter 0 op regel 3) dmv deze met spaties te overschrijven
   lcd.setCursor(3,0);                                           //Plaats cursor op karakter 3 op regel 0
   lcd.print(pulses);                                            //aantal pulsen schrijven
   
}.....


En nu doet hij iets, hij schrijft de pulses op de plaats waar ik ze wil hebben.
Wat me wel opvalt is dat de template mooi helder brand maar de pulses-waarde is bijna niet leesbaar en flippert een beetje qua helderheid




En lees nog even je eigen commentaren en vergelijk dat met mijn vorige berichtje.

Ik ga me nu verder inlezen maar wilde dit toch al even melden
Sjuul

RbSCR

Quote
Ik heb mijn functie "void schrijven" gewist en vervolgens de code ervan in de void loop gezet.


Dat is 1 manier om het te doen.

Je had ook dit kunnen doen:

Code: [Select]

void loop(){              //Hoofd programma, wordt elke cyclus doorlopen is leeg maar moet wel aanwezig zijn
   
    schrijven();          //Aanroep van de functie (sub programma zoals jij het noemt) schrijven             
}.....




Quote
... maar de pulses-waarde is bijna niet leesbaar en flippert een beetje qua helderheid


Dat "flipperen" komt waarschijnlijk omdat de pulse-waarde heel vaak en heel snel achterelkaar met spaties wordt overschreven en meteen daarna weer wordt getoond.
Omdat er maar heel weinig in de loop() functie staat is deze supersnel.

Als je er een "pauze" in zet wordt het beeld waarschijnlijk rustiger.
Code: [Select]

void loop(){              //Hoofd programma, wordt elke cyclus doorlopen is leeg maar moet wel aanwezig zijn
   
    schrijven();          //Aanroep van de functie (sub programma) schrijven             
    delay(1000);         // Pauze van 1 seconde
}.....


Je kan ook, als pulses op de lcd worden "geschreven", de waarde onthouden en de volgende keer alleen de waarde schrijven als die is veranderd.
Bijvoorbeeld zo:

Bovenaan de sketch
Code: [Select]
int vorige_pulses = 0;     // Initialisatie op 0

Code: [Select]

void loop(){              //Hoofd programma, wordt elke cyclus doorlopen is leeg maar moet wel aanwezig zijn
   
    if (pulses != vorige_pulses) {
               schrijven();                    //Aanroep van de functie (sub programma) schrijven
               vorige_pulses = pulses;     //Gewijzigde waarde onthouden       
   }
}.....




MAS3

Heel mooi, er is vooruitgang.

Inderdaad word die onduidelijke weergave door te vaak wissen en herschrijven veroorzaakt.
Daarom is het slimmer en vermoedelijk sneller om vooraf te controleren of de waarde veranderd is.
Dat heb ik eerder ook al genoemd.
De snelheidswinst zit hem in het niet schrijven als dat niet nodig is.
Dat schrijven naar de LCD is 1 enkele handeling voor jou, maar de library gaat kijken wat er naar de LCD gestuurd moet worden en zal dat dan teken voor teken naar de LCD sturen.
En dat kost relatief veel tijd, meer dan de vergelijking tussen de oude waarde en de nieuwe waarde.

Dan je stappen.
Als je een bepaald bereik hebt, dien je de stappen daarop af te stemmen.
Dat geldt nog niet zolang je aan het droogzwemmen bent, maar zeer zeker als je er een eindproduct van gaat maken.
Dan moet je dus zorgen dat als je aan een eind komt, je niet nog meer stappen kunt zetten.
Daarvoor alleen heb je dus al een stappenteller nodig die bijhoudt wat het is en wat het zal gaan worden.
En dat kun je mooi combineren met je code voor het beschrijven van je LCD.

Het gebruik van delay is zeer ongewenst.
Delay betekent: "Doe ff helemaal niets".
Dat wil je niet.
Wat je wel zou kunnen willen is dat het schrijven even niet gebeurt, maar dat de rest van het programma wel doorloopt (en das dus iets heel anders dan helemaal niets doen).
Maar ik zou niet kiezen voor een vaste vertraging in de schrijf routine.
Onder meer omdat je zo theoretisch toetsdrukken of "draaistappen" onbemerkt voorbij kunt laten gaan of die pas ziet als ze al genomen zijn.
De enige reden die ik kan bedenken om delay toe te passen is voor debuggen (omdat je dan wil dat je stap voor stap kunt zien wat er gebeurt).

Dan je commentaren.
Als je je code aanpast, moet je er wel voor zorgen dat je commentaren mee aangepast worden.
Daarmee doel ik er op dat je loop nu niet meer leeg is, maar je dat wel beweert in je commentaar.
Het commentaar is voor niemand anders dan jezelf belangrijk.
De compiler vind dat totaal oninteressant (en sommige gebruikers hier op het internationale board ook, want je kunt tenslotte aan de code zien wat het doet (maar niet wat het moet doen)).
Met andere woorden:
Als je de commentaren niet actueel houdt, kun je ze beter helemaal weglaten want ze zullen je niet gaan helpen een probleem op te lossen.
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

Sjuuls

#23
Sep 14, 2013, 10:20 pm Last Edit: Sep 14, 2013, 10:22 pm by Sjuuls Reason: 1
Bedankt RbSCR & MAS3 heb het meteen toegepast, en werkt perfect.

Heb eers eens met de delay gespeelt maar heb uiteindelijk voor de luxe oplossing gekozen, het lijkt me inderdaad niet slim om in het hoofd programma de cyclustijd te gaan vertragen, zeker als er straks 3 metingen/encoders aan hangen

Ook meteen al het commentaar aangepast en up to date gemaakt ;)

Dit verhaal kan ik nog niet echt volgen
Quote
Dan je stappen.
Als je een bepaald bereik hebt, dien je de stappen daarop af te stemmen.
Dat geldt nog niet zolang je aan het droogzwemmen bent, maar zeer zeker als je er een eindproduct van gaat maken.
Dan moet je dus zorgen dat als je aan een eind komt, je niet nog meer stappen kunt zetten.
Daarvoor alleen heb je dus al een stappenteller nodig die bijhoudt wat het is en wat het zal gaan worden.
En dat kun je mooi combineren met je code voor het beschrijven van je LCD.


Ook moet ik nog eens gaan achterhalen hoe ik nu van de pulsen naar mm kom, ik moet nog een vermenigvuldigings factor gaan inbouwen
Al met al nog genoeg te puzelen

Het programma zoals het er nu uit ziet (en het werkt XD):

Code: [Select]
#include <Wire.h>                                                //Toevoegen van I2C bibliotheek
#include <LiquidCrystal_I2C.h>                                   //Toevoegen van LCD bibliotheek
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);   //Instellen LCD adres voor de bus

int Xpulses;                                                     //Aanmaken van -pulses- als integer
int vorige_Xpulses;                                               //Aanmaken van -vorige_Xpulses- als integer
int A_SIG=0;                                                     //Aanmaken van -A_SIG=0- als integer
int B_SIG=1;                                                     //Aanmaken van -B_SIG=1- als integer


float Xmm;                                                       //Aanmaken van -Xmm- als float
float Ymm;                                                       //Aanmaken van -Ymm- als float
float Zmm;                                                       //Aanmaken van -Zmm- als float

void setup()                                                     //Begin van initialisatie en opstart (eenmalige doorloop bij opstart)
{
{
 attachInterrupt(0, A_RISE, RISING);                            //Aangeven dat op pin0 een ineruptpin is en dat deze A_RISE heet en moet schakelen op stijgende flank
 attachInterrupt(1, B_RISE, RISING);                            //Aangeven dat op pin1 een ineruptpin is en dat deze B_RISE heet en moet schakelen op stijgende flank
 Serial.begin(115200);                                          //instellen baudrate  
 lcd.begin(20,4);                                               //aantal karakters en regels declareren van het LCD scherm
}
{
// ------- 3x knipperen backlight  -------------
 for(int i = 0; i< 3; i++)                                      //Het volgende stukje code i keer doorlopen, tot i gelijk is aan 3, beginnen bij o en na elke doorloop één bij i optellen
 {
   lcd.backlight();                                             //lcd backlight aan
   delay(100);                                                  //100ms wachten
   lcd.noBacklight();                                           //lcd backlight uit
   delay(100);                                                  //100ms wachten
 }
 lcd.backlight();                                               //lcd backlight aan

//-------- Welkomst boodschap ------------------

 lcd.setCursor(0,0);                                            //Plaats cursor op karakter 0 op regel 0
 lcd.print("********************");                             //Schrijf (vanaf karakter 0 op regel 0) ********************
 lcd.setCursor(0,1);                                            //Plaats cursor op karakter 0 op regel 1
 lcd.print("*                  *");                             //Schrijf (vanaf karakter 0 op regel 1) *                  *
 lcd.setCursor(0,2);                                            //Plaats cursor op karakter 0 op regel 2
 lcd.print("*                  *");                             //Schrijf (vanaf karakter 0 op regel 2) *                  *
 lcd.setCursor(0,3);                                            //Plaats cursor op karakter 0 op regel 3
 lcd.print("********************");                             //Schrijf (vanaf karakter 0 op regel 3) ********************  
 delay(500);                                                    //500ms wachten
 lcd.setCursor(4,1);                                            //Plaats cursor op karakter 4 op regel 1
 lcd.print("Sjuul's DRO");                                      //Schrijf (vanaf karakter 4 op regel 1) Sjuul's DRO
 lcd.setCursor(2,2);                                            //Plaats cursor op karakter 2 op regel 2
 lcd.print("Mini Mill ZX7016");                                 //Schrijf (vanaf karakter 2 op regel 2) Mini Mill ZX7016
 delay(1000);                                                   //1000ms wachten
 
 //-------- Template ------------------

 lcd.clear();                                                   //Wis scherm
 lcd.setCursor(0,0);                                            //Plaats cursor op karakter 0 op regel 0
 lcd.print("X:               mm ");                             //Schrijf (vanaf karakter 0 op regel 0) X:               mm
 delay(100);                                                    //100ms wachten
 lcd.setCursor(0,1);                                            //Plaats cursor op karakter 0 op regel 1
 lcd.print("Y:               mm ");                             //Schrijf (vanaf karakter 0 op regel 1) Y:               mm
 delay(100);                                                    //100ms wachten
 lcd.setCursor(0,2);                                            //Plaats cursor op karakter 0 op regel 2
 lcd.print("Z:               mm ");                             //Schrijf (vanaf karakter 0 op regel 2) Z:               mm
 delay(100);                                                    //100ms wachten
 lcd.setCursor(0,3);                                            //Plaats cursor op karakter 0 op regel 3
 lcd.print("n:               RPM");                             //Schrijf (vanaf karakter 0 op regel 3) n:               RPM
 
}
}                                                                //einde setup

 //-------- Hoofdprogramma ------------------

void loop(){                                                     //Hoofd programma, wordt elke cyclus doorlopen moet aanwezig zijn (mag leeg zijn)

if (Xpulses != vorige_Xpulses) {                                 //Als -Xpulsen- NIET gelijk is aan -vorige_Xpulses- volgende regel uitvoeren
              SchrijvenX();                                     //Aanroep van de functie schrijven
              vorige_Xpulses = Xpulses;                         //Gewijzigde waarde onthouden        
 }
}
void SchrijvenX(){                                               //Functie met de naam SchrijvenX
  lcd.setCursor(3,0);                                           //Plaats cursor op karakter 3 op regel 0
  lcd.print("              ");                                  //ruimte leegmaken (vanaf karakter 0 op regel 3) dmv deze met spaties te overschrijven
  lcd.setCursor(3,0);                                           //Plaats cursor op karakter 3 op regel 0
  lcd.print(Xpulses);                                           //aantal pulsen schrijven
}

void A_RISE(){                                                   //Functie met de naam A_Rise
detachInterrupt(0);                                            
A_SIG=1;

if(B_SIG==0)
Xpulses++;//moving forward
if(B_SIG==1)
Xpulses--;//moving reverse
Serial.println(Xpulses);
attachInterrupt(0, A_FALL, FALLING);
}

void A_FALL(){                                                   //Functie met de naam A_FALL
 detachInterrupt(0);
A_SIG=0;

if(B_SIG==1)
Xpulses++;//moving forward
if(B_SIG==0)
Xpulses--;//moving reverse
Serial.println(Xpulses);
attachInterrupt(0, A_RISE, RISING);  
}

void B_RISE(){                                                   //Functie met de naam B_Rise
detachInterrupt(1);
B_SIG=1;

if(A_SIG==1)
Xpulses++;//moving forward
if(A_SIG==0)
Xpulses--;//moving reverse
Serial.println(Xpulses);
attachInterrupt(1, B_FALL, FALLING);
}

void B_FALL(){                                                   //Functie met de naam B_FALL            
detachInterrupt(1);
B_SIG=0;

if(A_SIG==0)
Xpulses++;//moving forward
if(A_SIG==1)
Xpulses--;//moving reverse
Serial.println(Xpulses);

attachInterrupt(1, B_RISE, RISING);
}

MAS3

Jouw frees kan niet oneindig een richting op gaan, dat houdt ergens een keer op.
Daarom moet je de pulsen die je maakt ook bijhouden.
Als je een bepaald aantal pulsen hebt gezet, ben je op je eindpunt aangekomen.
Aangezien je inmiddels bijhoudt hoeveel stappen (pulsen) je hebt gezet, kun je dat dus gelijk gebruiken wanneer je je frees werkelijk gaat bouwen.
Het heeft echter geen relatie met het schrijven van je display dus klopte die opmerking van mij niet.
Voor dat schrijven gebruik je namelijk twee variabelen die je met elkaar vergelijkt, en voor de eindpunten gebruik je een variabele en een constante.

De relatie tussen stappen van je motor en afgelegde millimeters ligt aan een heleboel zaken.
Dat zijn onder andere de motor (hoe ver draait die met 1 stap ?) en de overbrenging welke waarschijnlijk bestaat uit een tandwiel met tandriem of een tandwiel en een spindel.
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

Sjuuls

Ok nu snap ik wat je bedoeld, dan moet ik nog even iets verduidelijken.
Ik heb een klein handmatig boor/frees machientje, deze wordt ook niet omgebouwd naar cnc.
Dit is um:

Om hier preciezer op te kunnen werken en omdat ik de linealen gratis heb gekregen komen deze op de machine.
Er hoeven dus geen limiet schakelaars of bewaking op, wel een nul knopje zodat je naar je werkstuk kunt gaan en vervolgens de mm op nul kunt zetten.
Soort van "IF buttonX then set Xmm to zero"

RbSCR

#26
Sep 15, 2013, 09:42 am Last Edit: Sep 15, 2013, 09:46 am by RbSCR Reason: 1
Dat is een mooi machientje. De foto en de uitleg maakt (in ieder geval voor mij) duidelijk wat je met het project wil bereiken.

Ik wil nog even terugkomen op het commentaar.
Zoals MAS3 al aangaf lopen de meningen over het gebruik van commentaar nogal uiteen, van geen commentaar (degene die dit doen vinden dat code zelfverklarend is) tot heel uitgebreid.
Jij moet uiteindelijk moet de manier van commentaar kiezen die voor jou goed werkt.

Je geeft nu bij iedere regel een commentaar wat er in die regel gebeurt, maar je geeft niet aan wat de bedoeling van de regel of een blok regels is.

Ik zit zelf meer aan de 'weinig' commentaar kant.
Ik zet commentaar bij een aantal regels of bij een functie en geef niet bij alle regels kommentaar.
Ik probeer mijn commentaar zo te maken dat ik de bedoeling van de regels/functie weergeef, zodat als ik over 1 of 2 jaar de code weer zie ik deze bedoeling weer snap.

Ik zou bijvoorbeeld dit stukje zo van commentaar voorzien:

Code: [Select]

....
if (Xpulses != vorige_Xpulses) {                     // Als -Xpulsen- NIET gelijk is aan -vorige_Xpulses-
              SchrijvenX();                              // - Xpulsen schrijven
              vorige_Xpulses = Xpulses;              // - Gewijzigde waarde onthouden        
 }
}

/*
*  Schrijf de Xpulsen naar de LCD
*
*  XPulsen staat op karakter 3, regel 0
*/
void SchrijvenX(){                                              
  lcd.setCursor(3,0);                                        
  lcd.print("              ");                                  //ruimte leegmaken
  lcd.setCursor(3,0);                                        
  lcd.print(Xpulses);                                         //aantal pulsen schrijven
}
...


Nogmaal: jij moet de manier van commentaar kiezen die voor jou werkt.

Sjuuls

Tot nu toe heb ik enkel wat beginners codes van andere op mijn arduino gedraaid, Blink, helloworld enz.
Omdat dit mijn eerste project is waar ik ook zelf wat moet gaan schrijven heb ik er voor gekozen elke regel te voorzien van kommentaar.
Ik zie mijn project ook als een leer/naslagwerk.

Op dit moment kan ik de code nog maar moeilijk "lezen" ik zit nog in het stadium dat ik de code echt regel voor regel moet analyseren om het te begrijpen.
Als ik straks de "taal" wat beter spreek dan gaat het vanzelf die kant op.

Ik moet wel toegeven dat het me "gepakt" heeft. Ik denk dat ik ook nadat de meting klaar is nog wel wat dingetjes kan bedenken die ik er mee wil doen.
Ik kom meer uit de PLC wereld, ik heb wel vaker wat kleine projectjes gemaakt voor huis-en-tuin maar de kosten van de PLC hardware waren vaak een probleem.
Probleem opgelost  XD




Jantje

C/C++ is moeilijk te lezen. (Dat vind ik toch na jaren ervaring)
Wat ik doe om dat probleem op te lossen is goede variabele namen en functie namen verzinnen.
VB
Code: [Select]

void loop()
{
if (digitalread(5)==HIGH)
{
digitalwrite(6,HIGH);
delay(10);
digitalwrite(6,LOW);
}
}

dat zegt me niks
dit is al beter omdat er goede variabele namen zijn
Code: [Select]

#define XasLiniaalResetKnop 6
#define XasLiniaalReset 5
void loop()
{
if (digitalread(XasLiniaalResetKnop)==HIGH)
{
digitalwrite(XasLiniaalReset,HIGH);
delay(10);
digitalwrite(XasLiniaalResetKnop,LOW);
}
}

en zo is het nog leesbaarder
Code: [Select]

#define XasLiniaalResetKnop 6
#define XasLiniaalReset 5
void loop()
{
if (isButtonPressed(XasLiniaalResetKnop))
{
resetLiniaal(XasLiniaalReset);
}
}

bool isButtonPressed(int ButtonPin)
{
return digitalread(ButtonPin)==HIGH
}
void resetLiniaal(int liniaalresetPin)
{
digitalwrite(liniaalresetPin,HIGH);
delay(10);
digitalwrite(liniaalresetPin,LOW);
}

Merk op dat dit een voorbeeld is met nog veel haken en ogen (vb engels en nederlands door elkaar; formattering ...). Het is gewoon bedoeld om een punt te maken.
Deze manier van werken vraagt wel om te weten waar je mee bezig bent. Met andere woorden zoek de belangrijke functies (setup en loop in arduino) en lees van daar. Dus niet beginnen bovenaan.
Met vriendelijke groet
Jantje
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 -

Sjuuls

#29
Sep 15, 2013, 04:39 pm Last Edit: Sep 15, 2013, 05:32 pm by Sjuuls Reason: 1
De reset button zit erin, en ook deze werkt  :D,


if (digitalRead(ZeroXbutton) == HIGH)                        
                {
                 Xpulses = 0;                                  
                }

Ga nu eens kijken hoe ik een vermenigvuldigings factor kan in bouwen zodat ik van Pulses naar mm's kom, ook nog afronden op 2 cijfers na de comma.

Code: [Select]
// *************************************************************************************
// *************--------------Sjuul's Digital Read out system------------***************
// *************************************************************************************


// ------- Aanroep & Aanmaak diverse  -------------
#include <Wire.h>                                                //Toevoegen van I2C bibliotheek
#include <LiquidCrystal_I2C.h>                                   //Toevoegen van LCD bibliotheek
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);   //Instellen LCD adres voor de bus

int Xpulses;                                                     //Aanmaken van -Xpulses- als integer
int vorige_Xpulses;                                              //Aanmaken van -vorige_Xpulses- als integer
int A_SIG=0;                                                     //Aanmaken van -A_SIG=0- als integer
int B_SIG=1;                                                     //Aanmaken van -B_SIG=1- als integer
int ZeroXbutton = 53;                                            //Aanmaken van -ZeroXbutton- als integer en toekennen aan Pin53

float Xmm;                                                       //Aanmaken van -Xmm- als float
float Ymm;                                                       //Aanmaken van -Ymm- als float
float Zmm;                                                       //Aanmaken van -Zmm- als float

void setup()                                                     //Begin van initialisatie en opstart (eenmalige doorloop bij opstart)
{
{
 attachInterrupt(0, A_RISE, RISING);                            //Aangeven dat op pin0 een ineruptpin is en dat deze A_RISE heet en moet schakelen op stijgende flank
 attachInterrupt(1, B_RISE, RISING);                            //Aangeven dat op pin1 een ineruptpin is en dat deze B_RISE heet en moet schakelen op stijgende flank
 pinMode(ZeroXbutton, INPUT);                                   //Aangeven dat ZeroXbutton een ingang is
 Serial.begin(115200);                                          //instellen baudrate  
 lcd.begin(20,4);                                               //aantal karakters en regels declareren van het LCD scherm
}
{
// ------- 3x knipperen backlight  -------------
 for(int i = 0; i< 3; i++)                                      //Het volgende stukje code i keer doorlopen, tot i gelijk is aan 3, beginnen bij o en na elke doorloop één bij i optellen
 {
   lcd.backlight();                                             //lcd backlight aan
   delay(100);                                                  //100ms wachten
   lcd.noBacklight();                                           //lcd backlight uit
   delay(100);                                                  //100ms wachten
 }
 lcd.backlight();                                               //lcd backlight aan

//-------- Welkomst boodschap ------------------

 lcd.setCursor(0,0);                                            //Plaats cursor op karakter 0 op regel 0
 lcd.print("********************");                             //Schrijf (vanaf karakter 0 op regel 0) ********************
 lcd.setCursor(0,1);                                            //Plaats cursor op karakter 0 op regel 1
 lcd.print("*                  *");                             //Schrijf (vanaf karakter 0 op regel 1) *                  *
 lcd.setCursor(0,2);                                            //Plaats cursor op karakter 0 op regel 2
 lcd.print("*                  *");                             //Schrijf (vanaf karakter 0 op regel 2) *                  *
 lcd.setCursor(0,3);                                            //Plaats cursor op karakter 0 op regel 3
 lcd.print("********************");                             //Schrijf (vanaf karakter 0 op regel 3) ********************  
 delay(500);                                                    //500ms wachten
 lcd.setCursor(4,1);                                            //Plaats cursor op karakter 4 op regel 1
 lcd.print("Sjuul's DRO");                                      //Schrijf (vanaf karakter 4 op regel 1) Sjuul's DRO
 lcd.setCursor(2,2);                                            //Plaats cursor op karakter 2 op regel 2
 lcd.print("Mini Mill ZX7016");                                 //Schrijf (vanaf karakter 2 op regel 2) Mini Mill ZX7016
 delay(4000);                                                   //4000ms wachten
 
 //-------- Template ------------------

 lcd.clear();                                                   //Wis scherm
 lcd.setCursor(0,0);                                            //Plaats cursor op karakter 0 op regel 0
 lcd.print("X:               mm ");                             //Schrijf (vanaf karakter 0 op regel 0) X:               mm
 delay(100);                                                    //100ms wachten
 lcd.setCursor(0,1);                                            //Plaats cursor op karakter 0 op regel 1
 lcd.print("Y:               mm ");                             //Schrijf (vanaf karakter 0 op regel 1) Y:               mm
 delay(100);                                                    //100ms wachten
 lcd.setCursor(0,2);                                            //Plaats cursor op karakter 0 op regel 2
 lcd.print("Z:               mm ");                             //Schrijf (vanaf karakter 0 op regel 2) Z:               mm
 delay(100);                                                    //100ms wachten
 lcd.setCursor(0,3);                                            //Plaats cursor op karakter 0 op regel 3
 lcd.print("n:               RPM");                             //Schrijf (vanaf karakter 0 op regel 3) n:               RPM
 
}
}                                                                //einde setup

 //-------- Hoofdprogramma ------------------

void loop()                                                      //Hoofd programma, wordt elke cyclus doorlopen moet aanwezig zijn (mag leeg zijn)
{                                                    

if (Xpulses != vorige_Xpulses)                                   //ALS -Xpulsen- NIET gelijk is aan -vorige_Xpulses- DAN...
             {
              SchrijvenX();                                     //... uitvoeren van de functie schrijven
              vorige_Xpulses = Xpulses;                         //Gewijzigde waarde onthouden        
             }
             
             {
if (digitalRead(ZeroXbutton) == HIGH)                            //ALS ZeroXbutton word gedrukt DAN...
                {
                 Xpulses = 0;                                   //... waarde van Xpulses nul geven
                }
             }
}

 //-------- Diverse functies  --------------

void SchrijvenX(){                                               //Functie met de naam SchrijvenX
  lcd.setCursor(3,0);                                           //Plaats cursor op karakter 3 op regel 0
  lcd.print("              ");                                  //ruimte leegmaken (vanaf karakter 0 op regel 3) dmv deze met spaties te overschrijven
  lcd.setCursor(3,0);                                           //Plaats cursor op karakter 3 op regel 0
  lcd.print(Xpulses);                                           //aantal pulsen schrijven
}

void A_RISE(){                                                   //Functie met de naam A_Rise
detachInterrupt(0);                                            
A_SIG=1;

if(B_SIG==0)
Xpulses++;//moving forward
if(B_SIG==1)
Xpulses--;//moving reverse
Serial.println(Xpulses);
attachInterrupt(0, A_FALL, FALLING);
}

void A_FALL(){                                                   //Functie met de naam A_FALL
 detachInterrupt(0);
A_SIG=0;

if(B_SIG==1)
Xpulses++;//moving forward
if(B_SIG==0)
Xpulses--;//moving reverse
Serial.println(Xpulses);
attachInterrupt(0, A_RISE, RISING);  
}

void B_RISE(){                                                   //Functie met de naam B_Rise
detachInterrupt(1);
B_SIG=1;

if(A_SIG==1)
Xpulses++;//moving forward
if(A_SIG==0)
Xpulses--;//moving reverse
Serial.println(Xpulses);
attachInterrupt(1, B_FALL, FALLING);
}

void B_FALL(){                                                   //Functie met de naam B_FALL            
detachInterrupt(1);
B_SIG=0;

if(A_SIG==0)
Xpulses++;//moving forward
if(A_SIG==1)
Xpulses--;//moving reverse
Serial.println(Xpulses);

attachInterrupt(1, B_RISE, RISING);
}


http://www.youtube.com/watch?v=bxJv_wGsuDI

Go Up