Arduino analoge(!) modelbaan sturing

[smits66]

hoi, Frits

Bedankt voor je reactie

Ik vind het leuk om printjes te ontwerpen, maar het is meer voor de nette/storingvrije werking van mijn modelbaan sturing, aangezien het geheel analoog is is de kans op een kleine kortsluiting zeer aanwezig, als ik een pro of nano zou gebruiken moet ik het gehele pro of nano vervangen, op mijn eigen print gebruik ik een dip atmega 328, mocht daar een poort kapot gaan hoef ik alleen een andere atmega 328 er in te zetten.

Voor het gebruik heb je een print nodig om de pro of nano op te solderen, de ervaring leert dat de bedrading onder de print vaak storingen geeft naar de diverse connectoren op de print.

Mijn voorkeur gaat dan ook uit naar een arduino print.


 

[Timo]

Je kunt gewoon een print ontwerpen voor een pro mini in zijn geheel. Gewoon een rij pinheaders om hem in te drukken, zelfde als een Arduino Uno zijn shield verwacht. Met zoiets kleins als een pro mini net zo solide als een dip socket. En tuurlijk kan je een dip AVR gebruiken op je eigen print. Maar de prijs van een complete pro mini is al lager dan een losse AVR328. En dan krijg je de benodigde condensatoren en spanningregelaar cadeau! Dat was voor mij de reden om een print rondom de pro mini te ontwerpen.

En nogmaals I2C is alleen geschikt voor korte afstanden. Redelijk storingsgevoelig anders. Dus goed als je alle arduino's naast elkaar dumpt maar minder geschikt om modulair onder de baan te bouwen.


Timo

[smits66]

Hoi Timo

Bedankt voor je input

Ik weet dat I2C alleen goed werkt op korte afstanden, maar het is ook niet de bedoeling om onder elke module een aparte sturing te zetten.
De modules worden op een plaats samengebracht en vandaar uit lopen er kabeltjes (geen losse draden) naar de wissels, seinen en andere componenten, elk kabeltje heeft een eigen codering zodat ik ze snel kan terug vinden in de documentatie.

Ik heb het niet op met de Arduino pro mini( ik heb daar nog geen ervaring mee, wel de specificaties bekeken),  er zit daar geen usb aansluiting op zodat ik hem iedere keer uit de print moet verwijderen om het programma evt. te updaten, wil ik de pro mini gebruiken voor de sturing met de computer / of smartphone ,zal ik daar een bluetooth seriele verbinding bij moet maken, en het lukt helaas niet om met bluetooth een programma te downloaden naar de pro mini.
 
Of ik een print ontwerp voor een dip avr328 of een pro maakt mij niet uit ontwerpen moet je het toch met dezelfde specificatie voor beide ontwerpen.

Het kunnen best vooroordelen zijn, maar zo zie ik het nu tenzij het tegendeel bewezen kan worden

Vanavond op de clubavond heb ik de analoge modelbaan sturing , bedient met mijn smartphone, het werkte nog ook
Helaas blijkt een bluetooth verbinding met de Arduino niet erg stabiel
Als de verbindig wegvalt kan ik de treinbaan niet meer bedienen, moet er maar voor de zekerheid een hardwarematige noodstop bij maken.

Het optrekken van de trein gaat best wel netjes zoals het programma nu is, helaas heb ik dat alleen kunnen bereiken door de delay functie te gebruiken, voor handbediening vind ik dat niet zo erg, maar wil ik automatische rijden zal ik daar toch een betere tijdvertraging moeten gebruiken.

Ik ben op dit moment bezig met het, her programmeren van de sturing van de grond af aan, om het programma beter leesbaar te maken, voor als er mensen zijn die er verder mee willen.

mvg Paul

[Timo]

Hoi Paul,

Een losse AVR heeft ook geen USB. Die zal je er ook uit moeten halen om te programmeren. Overigens hoeft hij er niet uit, als je de boel goed ontwerpt kan het gewoon in circuit. Er zit op de pro mini gewoon een header voor op. Een pro mini is dus eigenlijk gewoon een losse Atmega alleen dan met alle randcomponenten er al op. En dat voor een lagere prijs dan een losse Atmega...

En dat goed ontwerpen geld voor alles, losse Atmege, Arduino Pro Mini, Arduino Uno, Arduino Mega enz. Ze gebruiken allemaal de UART (serieel) om het programma in de uC te krijgen. En als je deze ook voor iets anders gebruikt, zoals bluetooth, zal je er zeker van moeten zijn dat dit geen obstakel vormt tijdens het programmeren.

Zou wel goed bezig gaan met het onderzoeken hoe je een delay kunt gebruiken zonder de delay. Heb je misschien de code die je nu hebt? Dan kan ik je misschien op weg helpen. Snap ook als je zegt dat je eerst de boel leesbaarder wilt maken. Word ik alleen maar blij van 


Timo

[tuurtje]

Hi Allen,

Ik volg dit nog steeds met grote interesse 
Alleen meen ik mij ter herinneren toen Philips de I2C bus ontwikkelde niet alleen voor de korte afstand was.
Dus ben zo vrij geweest om even te googlen.

http://www.nodo-domotica.nl/forum/viewtopic.php?f=4&t=1580

Groetjes

Arthur

[Timo]

Dat het werkt zegt niet dat het goed is. I²C is bedoelt voor korte afstanden. Enkele meters max. Met buffers wel op te rekken maar blijft redelijk storingsgevoelig. Als iets 99% van de tijd blijft het erg vervelend dat het 1% van de tijd niet werkt. Met shielding enzo kan je al wat weg werken enzo. Maar zo uit de Arduino zelf is  I²C niet geschikt voor lange afstanden. Zie ook de Wiki.

Ben voor afstanden daarom meer gecharmeerd van RS485. Maar als ze bij elkaar komen te zitten is dat allemaal niet nodig


Timo

[tuurtje]

Hi Timo,

Helemaal mee eens, ik wil niet te ver afdwalen van het eigenlijke onderwerp.
Maar als ik soms de netwerk testen zie van een industrieel netwerk (profibus, RS485 layer) dan denk ik oei  of de bussnelheid omlaag of een beter kabel nemen.
En op die kabel (=koper) wordt nog wel eens te veel bezuinigd wat een betrouwbaar netwerk niet bevorderd.
Om nog maar te zwijgen over de shielding van de kabels. De kan je dagen over discussiëren. 

Gelukkig van dat in onze eigen model wereld nog wel mee.

Groetjes

Arthur

[smits66]

Hoi volgers

@ Timo en Arthur

Bedankt voor het meedenken.

@allen

Het I²C protocol is in de loop der jaren sterk verbeterd, we komen het overal tegen.
De tegenwoordige computer motherboarden zijn voorzien van het I²C om de sensoren te kunnen uitlezen naar het scherm,ook word het gebruikt door het motherboard om de diverse sensoren onboard te kunnen uitlezen.

Ik wil zeggen dat het huidige I²C voor 100% betrouwbaar is.
Voor mijn analoge modelbaan sturing maak ik ook gebruik  van I²C.

In de pen zit nog een wisselsturing en een seinsturing en evt nog een bloksturing die via I²C   
In grove lijnen heb ik de communicatie tussen de diverse Arduino's werkend maar nog niet in de vorm voor de analoge modelbaan sturing.

De master luistert naar de I²bus en de twee Arduino's melden zich met hun kenmerk (naam) ik kan met meer Arduino's in het systeem opnemen zonder dat ze elkaar in de weg zitten.
Ik moet er alleen voor zorgen dat elke Arduino een eigen adres heeft.

Analoge modelbaan sturing.

Ik ben weer heel wat avonden bezig geweest met de Arduino analoge modelbaan sturing, ik heb het programma flink zitten wijzigen.

De sturing in drie stappen heb ik vervangen voor een traploze regeling.
De functie void move heb ik veranderd in void sturing.
Er is nu een functie ingebouwd om linksom en rechtsom te kunnen rijden.
De functie trein 1 en trein 2 heb ik er uit gehaald, het is veranderd in trein linksom en trein rechtsom.

Doordat de regeling in drie stappen is verwijderd heb ik ook geen wachtlussen meer nodig, die code heb ik er ook uitgehaald.
Ook is de code opgeschoond zodat er geen overtollige programmeer code meer instaat.

Hoewel het programma nog lang niet compleet is werk het stuur gedeelte van de treinen goed, zowel in simulatie mode (een andere Arduino UNO) als in real mode gekoppeld aan mijn proefbaantje.

Ik wil er alleen op korte termijn wel een bleutooth communicatie er bij hebben, in een proef op stelling werkt het goed, en nog een voordeel het kost geen programmeercode om het te laten werken, je kan het direct aansluiten op de rx/tx poort van de Arduino en het werkt.
Helaas was de verbinding niet erg betrouwbaar, viel regelmatig weg, waardoor ik de Arduino niet kon bedienen, alleen een harde reset werk dan nog.

Ik ga er maar een hardwarematige oplossing voor een noodstop maken, om in geval van nood de baanspanning te kunnen uitschakelen.

Er zijn nog een aantal functies die ik in het programma wil gaan maken.

Een verbeterde bloksturing. (met behulp van reed contacten)
Bluetooth communicatie.
Een verbeterde terminal bediening.
Een grafische bediening met Gambas, is de visual basic programmeer omgeving van Linux.
Een I²C sturing waarbij de Arduino Leonardo als master gaat dienen.
De  Arduino Leonardo heeft de voorkeur omdat je daarmee een toetsenbord kan gebruiken voor het geven van commando's zonder een computer nodig te hebben (tenminste dat heb ik zo begrepen, mocht het anders zijn hoor ik dat graag.)

Ook staat er een wisselsturing via de Arduino en een sein sturing en evt een bloksturing(uitgebreid) nog op het verlanglijstje.

Hoewel het programma nog niet van de grond opnieuw is opgebouwd, ik heb het programma gewijzigd, sommige functies zijn nog niet of nauwelijks beschreven en er kan nog andere commentaar in staan die niet helemaal meer klopt, en het kan er wat rommelig uitzien.

Als ik tevreden ben met deze versie ga ik het programma opnieuw van de grond opbouwen.

Voor de mensen die gedesinteresseerd zijn zal ik het programma er bij zetten in dit topic.

Code: [Selecteer]

/*  Arduino analoge modelbaan sturing.
   
   Auteur : Paul Smits
   
   Versie 4.6 (is nog in testfase)
   
   Nieuwe functie sturing(trein,snelheid,richting)
   Vervangt de functie move(motor,speed,direction)
   Zijn feitelijk dezelfde functie alleen omgezet naar de modelbaansturing.
   
   Het in stappen optrekken en afremmen is er uit gehaald.
   De trein trekt nu langzaam op of remt nu langzaam af zonder stappen.
   
   Deze software is vrij aanpasbaar en kan door iedereen gebruikt worden,
   voor zijn eigen modelbaan of eigen project.
   
   LET OP !:Het gebruik van het programma geschied op eigen risico.
*/

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h> // library voor 12c lcd display

/***** Global vars ***********************************************/

// Define I2C Address where the PCF8574A is
#define BACKLIGHT_PIN     3

LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7); // adressering lcd display

char incomingByte;

/******************************************************************************
 * Definitions
 ******************************************************************************
 *motor A is aangesloten op OUT1 en OUT2 van de motorsturing
 *motor B is aangesloten op OUT3 en OUT4 van de motorsturing
 ******************************************************************************/

// constants won't change. Used here to
// set pin numbers:

const int ledPin =  13; // Pin nummer LedPin
const int blok1Pin = 6; // Pin nummer Blok 1
const int blok2Pin = 7; // Pin nummer Blok 2

int Interval = 500;

// Variables will change:

//Motor A

int PWMA = 3; //Speed control
int AIN1 = 9; //Direction
int AIN2 = 8; //Direction

//Motor B

int PWMB = 5; //Speed control
int BIN1 = 11; //Direction
int BIN2 = 12; //Direction

int ledState = LOW;             // ledState used to set the LED

long previousMillis = 0;        // will store last time LED was updated

// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.

void setup(){

  lcd.begin (16,2);

  // Switch on the backlight

  lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
  lcd.setBacklight(HIGH);
  lcd.home ();                   // go home

  // Print a message to the LCD.

  lcd.setCursor(2,0); //Start at character 2 on line 0
  lcd.print("Arduino Uno");
  lcd.setCursor(1,1);
  lcd.print("L298  M-Sturing");

  Serial.begin(9600);

  Serial.println("Arduino test programma : Motorsturingen en blok meldingen");

  menu();

  // Set all the pins we need to output pins
  // pinMode(STBY, OUTPUT);

  pinMode(PWMA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);

  pinMode(PWMB, OUTPUT);
  pinMode(BIN1, OUTPUT);
  pinMode(BIN2, OUTPUT);

  pinMode(2, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(ledPin, OUTPUT);
}

void loop (){

  // Controlle led om te zien of het programma nog werkt.

  unsigned long currentMillis = millis();

  if(currentMillis - previousMillis > Interval) {

    // save the last time you blinked the LED

    previousMillis = currentMillis;   

    // if the LED is off turn it on and vice-versa:

    if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;

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

    digitalWrite(ledPin, ledState);

  }

    if (Serial.available()) {

    //read serial as a character
    //char ser = Serial.read();

    if (Serial.available() > 0) {  // kijk of de seriele verbinding beschikbaar is.
      incomingByte = Serial.read(); // Lees een 'byte'.
    }

    // Begin Taak 1: Blok1 vrij

    if(incomingByte == '1') {
     
      lcd.home ();
      lcd.setCursor(0,1);
      lcd.print("Blok 1: Vrijgave");
     
      Serial.println("Blok 1 : Vrij");
      digitalWrite(blok2Pin, HIGH);

      menu();
   
    }

    // Einde Taak 1: Blok1 vrij 

    // Begin Taak 2: Blok 1 bezet 

      if(incomingByte == '2') {
     
      lcd.home ();
      lcd.setCursor(1,1);
      lcd.print("Blok 1: Bezet  ");
       
      Serial.println("Blok 1: Bezet");
      digitalWrite(blok2Pin, LOW);

      menu();
     
    }

    // Einde Taak 2: Blok 1 Bezet 

    // Begin Taak 3: Motor B aan

    if(incomingByte == '3') {
     
      lcd.home ();
      lcd.setCursor(0,1);
      lcd.print("Trein 1: Rijdt  ");
         
      int value;
      for(value = 60 ; value <= 250; value++)
{
   
       sturing(1,value,1);
       delay(60);
}     
     
      Serial.println("Trein 1: Rijdt linksom");
      Serial.println("Trein 1: Rijd op maximale snelheid, totdat er een stop commando komt.");

      menu();
 
    }

    // Einde Taak 3: Motor B on     

    // Begin Taak 4: Motor B off

    if(incomingByte == '4') {
     
      lcd.home ();
      lcd.setCursor(0,1);
      lcd.print("Trein 1: Gestopt");
     
      int value;
     
      for(value = 250 ; value >= 0; value--)
{
      sturing(1, value, 1);
      delay(30);
     
}
     
      Serial.println("Trein 1: Linksom, is gestopt");
      Serial.println("Trein 1: Staat stil omdat er een stop commando gegeven is.");

      menu();
     
    }
    // Einde Taak 4: Motor B off

    // Begin Taak 5 : Blok 2 On

    if(incomingByte =='5'){ 
       
      lcd.home ();
      lcd.setCursor(0,1);
      lcd.print("Blok 2: Vrijgave");

      Serial.println("Blok 2: Vrij");
      digitalWrite(blok1Pin, HIGH);

      menu();
     
    }

    // Einde Taak 5 : Blok On

    // Begin Taak 6: Blok 2 Off

    if(incomingByte == '6') {
     
      lcd.home ();
      lcd.setCursor(0,1);
      lcd.print("Blok 2: Bezet   ");

      Serial.println("Blok 2: Bezet");
      digitalWrite(blok1Pin, LOW);

      menu();
     
    }

    // Einde Taak 6: Blok 2 bezet

    // Begin Taak 7: Motor A On

    if(incomingByte == '7') {

      int value;
      for(value = 60 ; value <= 250; value++)
{
   
       sturing(1,value,0);
       delay(60);
}           
      Serial.println("Trein 1 : Rijdt rechtsom");
      Serial.println("Trein 1 : Rijdt op maximale snelheid, totdat er een stop commando komt.");

      menu();
     
    }

    // Einde Taak 7: Motor A on 

    // Begin Taak 8: Motor A Off

    if(incomingByte == '8') {

      int value;
     
      for(value = 250 ; value >= 0; value--)
{
      sturing(1, value, 0);
      delay(30);
}
     
      Serial.println("Trein 1: Rechtom, gaat stoppen");
      Serial.println("Trein 1: Is gestopt omdat er een stop commando gegeven is.");

      menu();
     
    }

    // Einde Taak 8: Motor B off

    // Begin Taak 9 : Noodstop

    if(incomingByte == '9') {
     
      lcd.home ();
      lcd.setCursor(0,1);
      lcd.print("Noodstop trein");

      Serial.println("Noodstop :Treinen A+B stop en blok 1+2 bezet");

      menu();
     
      sturing(1, 0, 0);// Trein 1 stop
      Serial.println("Trein 1 noodstop");
     
      sturing(0, 0, 0);// Trein 2 stop
      Serial.println("Trein 2 noodstop");

      digitalWrite(blok1Pin, LOW);
      Serial.println("Blok 1: Bezet");

      digitalWrite(blok2Pin, LOW);
      Serial.println("Blok 2: Bezet");
         
      // Einde Taak 9 : Noodstop

    }
  }
}

void sturing(int trein, int snelheid, int richting){

  //Move specific motor at speed and direction
  //motor: 0 for B 1 for A
  //speed: 0 is off, and 255 is full speed
  //direction: 0 clockwise, 1 counter-clockwise

  boolean inPin1 = LOW;
  boolean inPin2 = HIGH;

  if(richting == 1){
    inPin1 = HIGH;
    inPin2 = LOW;

  }

  else{
    if(richting == 0) 
    inPin1 = LOW;
    inPin2 = HIGH;

  }

  if(trein == 1){
    digitalWrite(AIN1, inPin1);
    digitalWrite(AIN2, inPin2);
    analogWrite(PWMA, snelheid);

  }

  else{
    digitalWrite(BIN1, inPin1);
    digitalWrite(BIN2, inPin2);
    analogWrite(PWMB, snelheid);

  }
}


void menu(){


  Serial.println();
  Serial.println("Stuur comando's");
  Serial.println();
  Serial.println("1 = Blok 1 vrijgeven            5 = Blok 2 vrijgeven");
  Serial.println("2 = Blok 1 bezet melden         6 = Blok 2 bezet melden");
  Serial.println("3 = Trein linksom starten       7 = Trein rechtsom starten");
  Serial.println("4 = Trein linksom stoppen       8 = Trein rechtsom stoppen");
  Serial.println("9 = Trein noodstop");
  Serial.println();
  Serial.println("Volgende comando >");
  Serial.println();
}

Ik zal straks kijken of ik een filmpje kan maken van de trein die rijd met de Arduino analoge modelbaan sturing.

Voor op/aan/verbeter opmerking hou ik mijn aanbevolen.

Paul

[dimo1_dimo1]

code even snel doorlopen.. de functie menu is denk ik eerder iets van drawMenu

    if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;

dit kan een stuk eenvoudiger.. het kan ook zo:

ledState!=ledState;

[Peter van der Leek]

Ik zou het op ledState = !ledState houden.
Bovendien hangt jouw verkorte statement wel af van de daadwerkelijke waardes van HIGH en LOW. Jij gaat er van uit dat die TRUE en FALSE zijn.

[ROn30]

Ik heb het niet op met de Arduino pro mini( ik heb daar nog geen ervaring mee, wel de specificaties bekeken),  er zit daar geen usb aansluiting op zodat ik hem iedere keer uit de print moet verwijderen om het programma evt. te updaten, wil ik de pro mini gebruiken voor de sturing met de computer / of smartphone ,zal ik daar een bluetooth seriele verbinding bij moet maken, en het lukt helaas niet om met bluetooth een programma te downloaden naar de pro mini.

Paul,

Mogelijk is de Nano V3 een goed alternatief? paar euro meer een 328 inclusief USB en kabeltje.
Ik gebruik de Nano als DCC command station.

DX.com
miniinthebox.com

cmdrarduino

[smits66]

Hoi volgers

@ROn30 , Peter, Dimo

Bedank voor jullie input.

@ROn30

Bedankt voor je tip.

De nano zou een mogelijkheid zijn maar ook de nano moet op een motherboard komen, er zal dan toch ook een print voor gemaakt moeten worden.

Mijn voorkeur ligt nog steeds bij het zelf ontwerpen van een arduino print.

@allen

Ik ben nog even verder gegaan met het programma, ik heb er nu een bluetooth verbinding met de arduino beschikbaar, en het werk.
Ik kan nu met mijn smartphone de Arduino analoge modelbaan sturing bedienen zonder dat deze aan de computer zit.

Zoals belooft heb ik een filmpje gemaakt van de sturing van de trein met de arduino analoge modelspoor sturing.

De kwalitijd van het filmpje is niet zo goed, maar het gaat om het idee.

Het filmpje http://youtu.be/KN-rbEq3ceE

Paul

[Timo]

Hoi Paul,

Je bent weer goed bezig! Mag ik na een snelle scan door de code toch weer wat opmerkingen geven?

Beginnende bij I²C. Je hoeft mij niet te overtuigen dat het een prima bus is. Je moet alleen wel aan de voorwaarde voldoen van de bus en dat is geen lange draden. Plaats je alle printen, zoals jij, bij elkaar is dat geen probleem. Ga je ze alleen verspreiden onder de tafel (iets dat me voor een echte baan handig lijkt) is het vragen om problemen.

Het eerste wat me opvalt is dat de code uitlijning niet altijd klopt. Dit is niet zo goed voor de meesbaarheid en je zal niet de eerste zijn die zich daardoor in de vingers snijdt. Zorg dus dat je bij een functie, if, else, en switch gebruikt maakt van een inspring en dat de sluit } op dezelfde hoogte staat als hetgeen waar de { bij hoort. Voorbeelden zijn te vinden bij alle incomming byte checks, daar staan de brackets van de for-loop gewoon tegen de kantlijn. Of op regel 137, het hele blok erna hoort ingesprongen te zijn omdat het onderdeel van de if is.

Om daar gelijk verder te gaan, je hebt daar twee checks voor serial.available, de tweede mag weg.

Ook valt me op dat je nu veel tekst naar de computer stuurt. Dit is wel leuk voor in een terminal maar het idee was toch om een programma te gebruiken? Tekst kost namelijk echt enorm veel ruimte vergeleken met de code. Het zou dus enorm schelen als je de tekste op de computer laat genereren en alleen een commando naar de PC stuurt.

En dan het grootste wat me opvalt, je hebt nog steeds niet af van je delay  Voor eht optrekken en afremmen maak je daar nog gebruik van. In die tijd kan je dus geen andere taken doen, zelfs geen noodstop. Denk dat je hier dus nog wel vanaf zou moeten willen.

Bij sturing, in de comment heb je het over de var motor maar je gebruikt trein. Ik moet zeggen, ik zou de var motor logischer vinden. Ook heb je nu dat motor A = 1 en motor B = 0. Werkt wel, maar lijkt me niet meest logische...

In de setup doe je netjes pinmode geven. Maar er vallen nog twee dingen op. Waar zijn pin 2, 4, 6, 7 en 10 voor? Naamloze pinnen die je output maakt maar ik nergens in de code terug kan vinden. Ook zou ik je willen aanraden om de pinMode als eerste in de setup te doen. Een pin is standaard een output als de Arduino opstart. Deze pinnen zweven dus. Dit betekend ook dat de ingangen van je motordriver tijdens het opstarten misschien HIGH kunnen worden en je motor/trein laten rijden. Dus in de setup eerst de belangrijke dingen (pinMode), dan minder belangrijke dingen opzetten (lcd enzo) en dan pas beginnen met de minder belangrijke dingen als het printen van teksten.

En hoe is het kruipen? Blijft het mooi rijden op lage snelheden? Anders moet je nog maar in dit draadje om te kijken om hoe stilstand kleef te overwinnen.


Succes verder!

Timo

[smits66]

Hoi volgers

@Timo

Bedankt voor je input.

Helaas was deze versie van het programma, de test versie en de commentaren waren nog niet aangepast.

De opmerking van het I²C was algemeen bedoeld.

Wat betreft de code er zitten inderdaad nog slordigheidjes in de code.
De delay(30) had ik er in gezet voor test doeleinden.

De terminal bediening heb ik nodig om er mee te kunnen werken.

Ik ben inderdaad nog bezig met het programma, ik heb geen Windows meer op de computer staan, ik heb tegenwoordig linux op de computer staan.

Ik kan niet meer in visual basic programmeren en moet derhalve met een linux visual programmeertaal  gaan werken, ik heb er ondertussen een gevonden die sterk lijkt op visual basic (gambas)

Ik ben er mee aan de slag gegaan met het onderstaande resultaat.
Voor de duidelijkheid dit is een aangepast programma, ik heb het niet zelf geschreven (ben ik te lui voor   of word ook wel gezegd, ik ga het wiel niet opnieuw uitvinden.  ), ik heb het alleen aan mijn eigen behoefde aangepast.

Er zal wel nog meer worden aangepast maar dat komt wel, voor nu werk het goed.



Het heeft niet de mooiste interface maar het werkt wel, zoals je ziet is het menu in het Arduino programma verwijderd en word het menu in de interface getoond.

Mvg Paul

[Timo]

De delay(30) had ik er in gezet voor test doeleinden.

Maar het doet nu wel iets belangrijks, het rampen van de snelheid. Ik denk dat je het het makkelijkste op kunt lossen door twee speed functies te maken. Laten we zeggen speedSet(int motor, int speed) waarmee je de snelheid voor een spoor instelt (direction kan je achterwegen laten, achteruit is dan gewoon een negatieve waarde, vooruit max = 255, achteruit max = -255). En speedCheck(), een functie die je in de loop opneemt en die checkt wat de huidige snelheid is, wat de set snelheid is en of het tijd is om de snelheid te verhogen/verlagen (van beide motoren).

De terminal bediening heb ik nodig om er mee te kunnen werken.

Snap ik, maar probeer alleen korte data heen en weer te sturen. Zou hou je veel ruimte en tijd in de Arduino over. Op dit moment staat de Arduino zich nog stierlijk te vervelen maar dat zal anders zijn als je het programma uitbreid.

Ik ben inderdaad nog bezig met het programma, ik heb geen Windows meer op de computer staan, ik heb tegenwoordig linux op de computer staan.

Er zal wel nog meer worden aangepast maar dat komt wel, voor nu werk het goed.

Leuk begin  Ik zou alleen de baud rate opvoeren. De Arduino doet de UART toch met hardware en dan is de data alleen maar sneller bij de PC. 115200 baud zou geen probleem moeten zijn. Ook zou je als extra check parity aan kunnen zetten om foute overdrachten af te vangen. Je krijgt dan Serial.begin(115200, SERIAL_8E1) voor 115200 baud met even parity en 1 stop bit.

Zelf zou ik iets meer proberen een algemeen protocol te gaan maken. Voor nu, met twee blokken, is het nog te overzien, maar hoe wil je dit later doen? Ik zou iets doen als 'b01' versturen naar de PC betekend "blok 1 bezet". 'v12' voor 'blok 12 vrij'. 's02100' voor 'speed blok 2 op 100' enz.

Of helemaal afstappen van ASCII. Immers wordt er dan voor 's02100' 6 bytes verstuurd terwijl 3 ook genoeg was. Eén commando, één blok (byte tussen 0 en 255) en één voor snelheid. Toegeven, nog niets voor richting gedaan.

Maar goed, genoeg gezeur  Je bent lekker bezig!


Timo