Arduino analoge(!) modelbaan sturing

[smits66]

Hoi Volgers,

@Peter, Gerard, Frits bedankt voor jullie input.

Ik heb de library nog een goed bekeken en zag twee integers staan die ik verplaatst heb van de header file naar de ccp file, en het programma doet het.

Debugen vond ik toch even te veel van het goede, de library files zijn goed met compileren van het programma kreeg ik geen foutmeldingen, het bleek dat ik twee integers in de verkeerde file stonden.

Nu alleen nog even uitzoeken waarom de tweede motor port het nog niet doet, daar kom ik vast wel achter.

Mvg Paul

[dimo1_dimo1]

PwmA is toegewezen aan pin 2. Dit is bij de uno geen pwm pin.. Je comments in de library geeft aan dat Pwma pin 3 moet zijn..  Zit daar het probleem misschien?
Die twee variabelen waren inpinwish en inpinwisl?

[Peter Korsten]

Debugen vond ik toch even te veel van het goede, de library files zijn goed met compileren van het programma kreeg ik geen foutmeldingen, het bleek dat ik twee integers in de verkeerde file stonden.

Het is kinderlijk eenvoudig een programma te schrijven dat goed compileert en absoluut niet werkt. Ik zou debuggen in mijn achterhoofd houden als ik jou was, het kan je veel tijd en ergernis besparen.

- Peter

[Timo]

Hoi Paul,

Je bent aardig op weg Maar ik zou je toch wat tips willen geven.

Laat ik dan wel even beginnen met zeggen dat ik het leuk vind te zien hoe iemand bezig is Alles wat ik zeg is alleen bedoelt om te helpen bij het bouwen van een makkelijk uitbreidbaar systeem volgens jou eisen

Ik zou wat beter nadenken over na naam van je library/classe. Start is wel een hele generieke naam en aangezien er in de hele library structuur van Arduino maar één keer de naam mag voorkomen is een fout snel gemaakt.

Om het voor jezelf makkelijk te maken zou ik ook wat beter opletten wanneer je de code in laat springen. Voor de werking doet het er niet toe maar je maakt zo makkelijk fouten.

Maar waar je denk ik de meeste baat bij hebt om een goed werkende library te schrijven (of meerdere). Is goed te bedenken welke onderdelen je wilt hebben. Het hele idee van een library is dat je alles groepeert wat je vaker wilt gebruiken en dus makkelijk meerdere keren kunt gebruiken. In dit geval lijkt mij het bijvoorbeeld logisch om bijvoorbeeld een blok als eerder bouwsteen te nemen. En dat te bedenken, wat heeft ieder blok nodig?

Wat het misschien nog wat lastig maakt is dat je niet ieder blok voorziet van een eigen motordriver maar via een relais meerdere blokken uit één motordriver voedt. Om dit duidelijk te maken maak ik even onderscheid tussen blok en sectie:
een blok => Deel van het spoor waar 1 loc in kan, geschakeld door relais
een sectie => Deel van het spoor bestaande uit meerdere blokken. Alle blokken van de sectie hangen achter een motordriver.

Dit is toch het idee van je systeem? En wat wil je dan aanhouden, dat er één rijdende trein per sectie is? (Dus dat er niet twee treinen achter dezelfde motordriver hangen?)

Goed, dan zou ik sectie en blok als bouwstenen nemen dus daar libraries voor maken.
Wat heeft iedere sectie?
- Eén motordriver
- Meerdere blokken (wat is de max?)

Wat heeft ieder blok?
- Eén stuur relais
- Eén sein (uitgaande van één richting)
- Detectie, hoeveel? Wat voor? (Als je nog meerdere soorten wilt gebruiken zou je dit ook af kunnen splitsen naar meerdere classe, één per detectie methode. Zo kan je ze uitwisselen)

Op deze manier kan je van sectie naar sectie rijden en binnen de sectie dingen doen met de losse blokken.

Voornaamste verschil met jou opzet is dus het echt opsplitsen van de onderdelen. Nu heb je eigenlijk alles wat je wilt gebruiken gewoon in één library gestopt. Maar dit schaalt zo niet makkelijk.

Wissels heb ik nog even niet genoemd. Jij hebt ze steeds namen genomen met een sectie maar heeft iedere sectie precies een wissel? Ik zou daarom de sturing voor een wissel ook opnemen in een losse classe/library. Op deze manier kan je gewoon het aantal wissels dat je nodig hebt implementeren.


Okay, waar het dus eigenlijk op neer komt, probeer niet eens precies voor dit plan passende library te maken maar probeer alle onderdelen op te delen. Denk dus aan meerdere libraries. Dit zal het uitbreiden naar een baan de boel flink vergemakkelijken. De indeling die ik hier noem is maar een voorbeeld afgeleid van hoe jij de baan aan wilt sturen.

En eigenlijk dezelfde tip als eerder, probeer af te komen van delays  (En denk er niet aan om floats te gebruiken  )


Timo

[smits66]

Hoi volgers,

@Timo, Peter, Auke, bedankt voor de input.

Na lang zoeken en veel testen heb ik mijn eigen library goed werkend gekregen, het doet precies wat ik in gedachte had.
Ik kan nu de sturing gaan testen en uitbreiden naar meer functies in de library.

Ik heb nu twee functies,  sturing.trein en sturing.wissel er moet nog een functie sturing.blok, sturing.keerlus, sturing.stroomdetectie, sturing.rgb (dag nacht simulatie) en sturing.verlichting., bijkomen.

Ik ben ondertussen de hoofdzaak vergeten,  zoals ik het in gedachte had, de computer als terminal voor de modelbaan, ik ben ondertussen bezig een automatische baansturing te ontwerpen.

Ik ga weer verder met het eerste idee en ga zeker wat experimenteren met de Arduino om een automatische modelbaan sturing te ontwerpen.

De functies die ik genoemd heb ga ik nog verder uitwerken en me concentreren op de handbediening via de computer en later ga ik me bezig houden om een automatische modelbaan sturing te maken.

Mvg Paul

[Peter Korsten]

Na lang zoeken en veel testen heb ik mijn eigen library goed werkend gekregen, het doet precies wat ik in gedachte had.
Ik kan nu de sturing gaan testen en uitbreiden naar meer functies in de library.

Dit is een beetje mosterd na de maaltijd, maar je kunt dus een testprogramma schrijven dat één voor één alle functies van je library probeert. Dan kun je zeker zijn dat alles precies werkt zoals je wil. In de software-wereld worden dit "unit tests" genoemd.

Voor zover je dit niet al gedaan had, natuurlijk.

- Peter

[Timo]

Ik heb nu twee functies,  sturing.trein en sturing.wissel er moet nog een functie sturing.blok, sturing.keerlus, sturing.stroomdetectie, sturing.rgb (dag nacht simulatie) en sturing.verlichting., bijkomen.

En dat zou ik dus juist opsplitsen. Het idee van een library (en object georiënteerd programmeren) is juist dat je alles in behapbare blokken hakt. Anders had je echt geen library hoeven schrijven hoor  Het is dan wel allemaal sturing maar in eerste instantie heeft de dag nacht simulatie niets met het rijden te maken. Ook blijf je op die manier steeds de library aanpassen aan specifieke wensen (omdat er bijvoorbeeld een stuk strip bij komt ofzo). Ook is het geheel dan nogal complex.

Splits het op in:
- Blok
- Sectie
- Detectie (per detectie soort een library)
- RGB(controller)
- Verlichting(controller)
- Wissel(controller)

Op deze manier is ieder ding op zichzelf simpel en maak je gewoon een extra instantie als je een extra blok of sectie hebt.


Timo

[smits66]

Hoi Volgers,

@Peter, bedankt voor de input.

Ik heb het per functie in de library gebouwd en getest als de functie werkte, ga in naar een volgende functie.

@Timo

Er begint rook uit mijn oren te komen

Ik snap nog niet helemaal waarom ik verschillende library's  moet maken, ik kan me niet voorstellen dat het daardoor  gemakkelijker word, in alle library's moet je dan weer verwijzingen maken naar andere library's.

Dat lijkt mij veel ingewikkelder dan 1 enkele library's met alle functie's  er in.

Waarom zou je voor een blok sturing  de library's moeten opsplitsen in Blok,Sectie,detectie en per detectie een andere library ,dat lijkt mij niet echt handig

Het is naar mijn inzien veel handiger om in de blok functie alle parameters te zetten, het main programma lijkt mij dan duidelijker als er zo min mogelijk commando's/functie gebruikt te hoeven worden.

In de main code lijkt het mijn handiger  als je bv : sturing.blok(bloknr,seinstand,sensor,sectie,drempelwaarde) programmeert,
dan dat je bv : sturing.blok()
                       sturing.sein()
                       sturing.sensor()
                       sturing.sectie()
                       sturing.drempelwaarde() enz. programmeert.

En dat geld ook voor de andere library denk ik.

Het heeft niets met eigenwijsheid te maken, ben nog een leek op dat gebied, snap het nog niet helemaal.

Ik wilde een library hebben waarin ik met 1 commano alle delen en functies op de modelbaan kan aansturen, het is nog steeds de bedoeling om met een terminal de modelbaan aan te sturen, ondertussen probeer ik een automatische modelbaan sturing te maken

Misschien kun je me het wat duidelijker  proberen uit te leggen wat het voordeel is van meerdere kleine library's ten opzichte van een grote library.

Ik vind het wel gemakkelijk als ik een commando heb voor mijn modelbaan sturing bv sturing.comando()
Als dat mogelijk is met meerdere library's dan wil ik het graag weten.

@allen

Vanavond nog een 4 voudige I²C interface gemaakt.

Mvg Paul

[Timo]

Grootste reden, schaalbaarheid. Stel dat je nu je library maakt voor twee blokken (je slaat alle pinnen van de onderdelen van een blokken op enzo). Maar nu wil je er toch 3. Je array's in je library zijn  maar 2 groot dus moet je de library aanpassen.

Maar maak je een library voor één blok kan je daar prima meerdere instaties van maken. Stel dat je een library aamBlok maakt waar alles voor één blok in past. Wil je nu 2 blokken doe je in je main gewoon
AamBlok blokken[2];

Wil je er 5:
AamBlok blokken[5];

Wil je iets doen met het eerste blok (blok 0) doe je gewoon:
blokken[0].checkVrij(); (of een andere functie in je classe).

Je kan de classes weer aan elkaar hangen in je main. De classes aan zich zijn allemaal erg makkelijk. Hoe je ze aan elkaar hangt kan nog wel verschillen en je komt al wel snel bij pointers uit. Maar uiteindelijk hou je (na de setup) een mooie begrijpbare main over

Voor detectie zou ik een classe maken waarbij je aan geeft welke soort detectie er gebruikt moet worden. Daarna kan je gewoon steeds checken of er een melding is.
AamDetectie detecties[5];
detecties[0].begin(LDR, A5, 100); //Voor bijvoorbeeld LDR op pin A5 met drempel 100
detecties[1].begin(REED, 5);

en hang je ze aan de blokken
for(byte i = 0; 1 < (sizeof(blokken)/sizeof(blokken[1])); i++){
  blokken.attachDetectie(&detecties);
}

Zijn maar wat van de opties die je hebt als je het los doet. Doe je het niet los is het het eigenlijk niet waard een library te maken, had je het ook gewoon in de main code kunnen zetten.


Timo

[Peter Korsten]

Ho even, maak het nou niet ingewikkelder dan het is. En libraries en klassen hebben weinig met elkaar te maken. Sowieso betwijfel ik of dit in C++ wordt geschreven.

Een library hoort over één onderwerp te gaan. Stel dat je een library schrijft om een database aan te spreken, dan wil je daar niet code in plaatsen om netwerkverbindingen te maken. Dat zijn twee heel uiteenlopende zaken en die horen daarom in verschillende libraries thuis.

Nu zul je zeggen: "Maar ik doe niets met databases of netwerkverbindingen." En dat klopt inderdaad, maar je doet wel verschillende dingen. Waar het vooral om gaat is dat je dingen zoveel mogelijk scheidt.

Ik kom hier morgen op terug, nu te moe.

- Peter

[smits66]

Hoi volgers,

@Timo

Bedankt voor je input.

Begin het nu te snappen denk ik

Wat je bedoeld is eigenlijk : als ik in een library bv sturing.comando() meerdere wissels wil ga sturen moet ik in een algemene library sturing 10 keer dezelfde instructie geven alleen met iedere keer een hoger wissel nummer.

Maak ik een library wissels aan kan ik in het main programma door middel van een teller er onbeperkt aantal wissels mee aansturen (theoretisch gezien) zonder dat de library vol loopt met programmeer code. 

Begrijp ik het goed, hoe library's werken, of snap ik het nog niet helemaal.


@Peter

Bedankt voor je input 
Ik ben benieuwt of ik morgen weer wat wijzer word met betrekking tot het programmeren van library's.

Voor zover ik het weet is de Arduino programmeertaal afgeleid van C++/C en kan volgens mij C++ librarys 's lezen, maar ik weet het niet zeker.

Mvg Paul

[Peter Korsten]

Wat je nu beschrijft zijn functies. Een functie (ook procedure genoemd in sommige programmeertalen als het geen waarde oplevert) is een stukje code dat je verschillende keren kunt aanroepen, zodat je niet steeds dezelfde statements hoeft uit te voeren.

Een functie kan ook parameters hebben. Stel bijvoorbeeld dat je wissel nummer 1 omzet door een bit naar pin 16 te schrijven. Wissel 2 zit op pin 17, wissel 3 op pin 18, enzovoorts.

Als je dan een wisselstraat wil instellen, dan zou je dat als volgt kunnen doen:

Code: [Selecteer]

schrijfBit( 16, 1 );
schrijfBit( 17, 1 );
schrijfBit( 18, 1 );
schrijfBit( 19, 1 );
Maar dat is niet zo handig. Handiger is om zoiets te schrijven:

Code: [Selecteer]

void zetWissel( int nummer )
{
    schrijfBit( 15 + nummer, 1 );
}
en even later:

Code: [Selecteer]

int i;
for( i = 1; i <= 4; i++ )
    zetWissel( i );
(Daar zit meteen een probleem: wat als je -1 als nummer meegeeft als parameter aan zetWissel? Daar moet je ook rekening mee houden.)

Maar dat is dus een functie en geen library. Een library is in feite niets anders dan een verzameling functies, of als je objectgeoriënteerd programmeert, een verzameling klassen, ieder met hun eigen variabelen en functies (of 'methoden' zoals je dat noemen bij objectgeoriënteerd).

Waarom zou je dan een library bouwen? Wel, zoals ik al zei, om zaken thematisch te scheiden. Als je aan code voor je seinen gaat werken, wil je liever niet aan de code voor je wissels komen. Je komt alleen aan die code die je daadwerkelijk wil wijzigen. Als je alles op een grote hoop gooit, is het veel gemakkelijker om het overzicht kwijt te raken en fouten te maken.

Je hebt dus de volgende elementen:

• functies zijn onderdeel van een .c of .cpp bestand
• .c en .cpp bestanden worden gecompileerd naar een .o bestand
• Bepaalde .o bestanden worden gelinkt tot een library
• Je gecompileerde .o bestanden en libraries worden gelinkt tot het uiteindelijke programma

Punt 3 kun je overslaan als je maar één programma schrijft en die code nergens anders voor gaat gebruiken. In dit geval kan dat dus best het geval zijn.

Wat echt belangrijk is, is om de koppeling tussen modules zo minimaal mogelijk te houden. Dat wil dus zeggen dat je functies thematisch scheidt in bronbestanden en dat je globale variabelen (die door het hele programma beschikbaar zijn) zoveel mogelijk vermijdt. Idealiter moet ieder bronbestand apart kunnen compileren en alleen afhankelijk zijn van bepaalde functies in andere bestanden of van het systeem.

- Peter

[Timo]

Hoi Peter,

Je hebt op zich gelijk dat een library en een classe niet hetzelfde zijn. Alleen is het eigenlijk binnen Arduino zo dat dit altijd het geval is. Vandaar dat ik ze in dit geval ook zo makkelijk door elkaar gebruik.

Verder kan ik het alleen maar met Peter eens zijn, splits de dingen die niets met elkaar te maken hebben. Een wissel en en blok hebben in de basis niets met elkaar te maken.

Verder is het schrijven van een libraries met classe makkelijk voor de schaalbaarheid. Als je één library zou schrijven voor alle blokken, hoe groot maak je dan de variabele voor welke pinnen bij welk blok horen? Het is embedded code dus je kan wel een array gebruiken maar tijdens het compilen moet de grote bekend zijn. Je zou natuurlijk kunnen zeggen, "dan ga ik gewoon aan de grote kant zitten en ga ik voor 20" maar dat is wel zonde van het geheugen als je maar 3 blokken maakt. Maak je een classe voor één blok kan je daar gewoon voor ieder blok een instantie van maken.

Kijk maar eens naar de servo library, per servo die je wilt besturen maak je gewoon een instantie aan van servo.


Timo

[Peter Korsten]

Tja, mijn achtergrond is momenteel Java, dus voor mij is een bronbestand gelijk aan een klasse en een library is een verzameling klassen.

'Momenteel Java' omdat ik ook ervaring heb met shell scripts, C, C++, Perl, PHP, Pascal, Modula-2, BASIC, Z80 assembly, 8088 assembly, 68000 assembly, Awk, Expect en nog een paar die ik nu vergeet.

- Peter

[smits66]

Hoi Volgers,

@Timo

Bedankt voor je input?

@Peter

Bedankt voor je input?

@ allen

Hoewel er al weer een tijdje geen update is geweest, heb ik niet stil gezeten.
Ik ben druk bezig geweest met proberen, om een Arduino library te schrijven voor een functie.

Het is de eerste keer dat ik het probeer (geheel van de grond opgebouwd, voorheen paste ik library's aan, aan mijn eigen eisen.)

De library heet : AamsTrein.h en AamsTrein.cpp

AamsTrein.h

Code: [Selecteer]

/*
AamsTrein.h v1 - Library voor Arduino Analoge Modelbaan Sturing of kortweg AAMS.
Writen by Paul Smits
*/

/*
Deze library stuurt de motordriver L298 voor de Arduino Analoge Modelbaan sturing.
*/

#ifndef AamsTrein_h
#define AamsTrein_h

#include "Arduino.h"

class AamsTrein {
public:
AamsTrein(byte pinPwmA, byte pinAin1, byte pinAin2, byte pinPwmB, byte pinBin1, byte pinBin2);

int value;

void start(byte train, byte direction);
void stop(byte train);
                void vertrek(byte train, byte direction);
void remmen(byte train, byte direction);
void noodstop(byte train, int speed);
void richting(byte direction);
void snelheid(byte speed);
void on(byte train);

private:

bool inPin1;
bool inPin2;

byte pinPwmA;
byte pinAin1;
byte pinAin2;
byte pinPwmB;
byte pinBin1;
byte pinBin2;

};

#endif
En Hier de

AamsTrein.cpp

Code: [Selecteer]

/*
AamsTrein.cpp v1 - Library voor Arduino Analoge Modelbaan Sturing of kortweg AAMS.
Writen by Paul Smits


/*
Deze library is, voor het sturen van de verschillende treinen.
*/


#include "AamsTrein.h"


AamsTrein::AamsTrein(byte pinPwmA, byte pinAin1, byte pinAin2, byte pinPwmB, byte pinBin1, byte pinBin2){

this-> pinPwmA = pinPwmA; // Arduino pin 3~
this-> pinAin1 = pinAin1; // Arduino pin 2
this-> pinAin2 = pinAin2; // Arduino pin 4
this-> pinPwmB = pinPwmB; // Arduino pin 6~
this-> pinBin1 = pinBin1; // Arduino pin 5
this-> pinBin2 = pinBin2; // Arduino pin 7

pinMode(this-> pinPwmA, OUTPUT);
pinMode(this-> pinAin1, OUTPUT);
pinMode(this-> pinAin2, OUTPUT);
pinMode(this-> pinPwmB, OUTPUT);
pinMode(this-> pinBin1, OUTPUT);
pinMode(this-> pinBin2, OUTPUT);

}

void AamsTrein::start(byte train, byte direction)
{

  bool inPin1 = LOW;
  bool inPin2 = HIGH;

  if(train == 0)
   {
    digitalWrite(this-> pinAin1, inPin1);
    digitalWrite(this-> pinAin2, inPin2);
    analogWrite(this->  pinPwmA, 120);
   }

  if(train == 1)
   {
    digitalWrite(this-> pinBin1, inPin1);
    digitalWrite(this-> pinBin2, inPin2);
    analogWrite(this->  pinPwmB, 120);
   }

  if(direction == 0)
   {
    inPin1 = HIGH;
    inPin2 = LOW;
   }

  if(direction == 1)
   { 
    inPin1 = LOW;
    inPin2 = HIGH;
   }
}

void AamsTrein::stop(byte train)
{

  if(train == 0)
   {
     analogWrite(this-> pinPwmA, 0);
   }

  if(train == 1)
   {
     analogWrite(this-> pinPwmB, 0);
   }
}
void AamsTrein::vertrek(byte train, byte direction)
{
  bool inPin1 = LOW;
  bool inPin2 = HIGH;
  int value;

  if(direction == 0)
   {
    inPin1 = HIGH;
    inPin2 = LOW;
   }

  if(direction == 1)
   { 
    inPin1 = LOW;
    inPin2 = HIGH;
   }

  if(train == 0)
   {
    digitalWrite(this-> pinAin1, inPin1);
    digitalWrite(this-> pinAin2, inPin2);
   
      for(value = 60 ; value <= 250; value++)
{
analogWrite(this->  pinPwmA, value);
}
   }

  if(train == 1)
   {
    digitalWrite(this-> pinBin1, inPin1);
    digitalWrite(this-> pinBin2, inPin2);

for(value = 60 ; value <= 250; value++)
{
  analogWrite(this->  pinPwmB, value);
}
   }
}

void AamsTrein::remmen(byte train, byte direction)
{
  bool inPin1 = LOW;
  bool inPin2 = HIGH;
  int value;

  if(direction == 0)
   {
    inPin1 = HIGH;
    inPin2 = LOW;
   }

  if(direction == 1)
   { 
    inPin1 = LOW;
    inPin2 = HIGH;
   }

  if(train == 0)
   {
    digitalWrite(this-> pinAin1, inPin1);
    digitalWrite(this-> pinAin2, inPin2);
   
      for(value = 250 ; value >= 50; value--)
{
analogWrite(this->  pinPwmA, value);
}
   }

  if(train == 1)
   {
    digitalWrite(this-> pinBin1, inPin1);
    digitalWrite(this-> pinBin2, inPin2);

for(value = 250 ; value >= 50; value--)
{
  analogWrite(this->  pinPwmB, value);
}
    }
}

void AamsTrein::snelheid(byte speed)
   {
//Er word nog aan functie snelheid gewerkt! (deze functie is bedoeld voor Handbediening)
   }

void AamsTrein::richting(byte direction)
   {
// Er word nog aan functie richting gewerkt! (deze functie is bedoeld voor Handbediening)
   }

void AamsTrein::on(byte train)
   {
// Er word nog aan functie on gewerkt! (deze functie is bedoeld voor Handbediening)
   }
void AamsTrein::noodstop(byte train, int speed)
   {
// Er word nog aan functie noodstop gewerkt! (deze functie is bedoeld voor Handbediening)
   }

De volgende functies heb ik in de library gebouwd :

start, stop, vertrek, remmen voor automatische bediening.
en voor handbediening : noodstop, richting, snelheid, on (moet nog een andere naan bedenken)

Ik heb de functies uitgeprobeerd in het Arduino programma, voor zo ver ik het kan zien worden de functies geaccepteerd, ik heb het nog niet in de praktijk geprobeerd, maar dat komt morgen, ik ga het testen met leds werkt dat goed ga ik het met de L298 shield verder testen.

Mochten er nog onvolkomenheden en/of fouten, of op/aanmerkingen zijn hoor ik dat graag.

mvg Paul