Arduino analoge(!) modelbaan sturing

[Timo]

Haak ik gelijk weer in

Ik ken het helemaal. Hier slingeren ook altijd te veel projecten en onderdelen op me bureau. Breadboards met soms 3 verschillende niet met elkaar te maken hebbende testopstellingen, meerdere USB Serials, meerdere Pro Mini's, servo's, displays, DCDC converters, PIC programmer, D-sub connectoren, nieuwe voorraad weerstanden, Senseo condensatoren, Z80 en halve project printen is het op dit moment 

Maar goed, verder met dit project  Ik snap wat je nu wilt doen. En ik snap dat je een soort blokkaart wilt maken. (Zal eht verder dus ook maar blokkaart noemen voor de duidelijkheid.) Maar dat haalt geen van mijn punten neer  Je hebt nu veel dingen dubbel in de code die je makkelijker had kunnen doen. En dan is het ook nog schaalbaar, of je het nu nodig hebt of niet.

En even voor de duidelijkheid, wat noem jij een blok? Is dat alles wat achter een motordriver zit? Of juist elke relais deel (waarbij er dus 2 relais per motordriver hangen)?

De motordriver die je gebruikt heeft toch eigenlijk 2 drivers in zich? Is het dan niet zonde om steeds maar de helft te gebruiken? Is het dan niet handiger een Blokkaart te maken die 2 blokken aan kan sturen? Dinamo heeft toch ook kaarten voor meer dan 1 blok? Het denken zit immers in het terminal deel. De Arduino en de motordriver voeren domweg taken uit die ze krijgen. En een Pro Mini of uno is meeeeer dan krachtig genoeg om alles voor 2 motordrivers, 4 relais enzo te doen.

als extra kun je er bv wissels mee schakelen, daar wil ik een aparte sturing voor maken.

Wat bedoel je daarmee? Wil je losse wisselkaarten maken? Of wil je dat als onderdeel van de blokkaart? Of wil je soms 1 of soms 2 en soms 3 wissels met één blokkaart kunnen schakelen?

De twee seinen heb ik bewust als 4 aparte sturingen uitgevoerd zodat ik de seinen apart kan bedienen of via het blok sturen.

Dat is toch prima? Of vat je uit mijn tekst iets anders op?

Wat wel van belang is dat ikzelf de richting van de trein kan kiezen, hiervoor gebruik ik dus de case functie case'<' ,case'>'
Het is de bedoeling dat ik, voor ik de trein een vertrek comando geeft,  ik eerst de richting moet aangeven.

Dat snap ik. Maar hoe ga je dat dan doen als je straks meerdere blokken hebt? Waarom niet de snelheid als signed getal zien? Dus positief voor vooruit en negatief voor achteruit? Dan kan je snelheid en richting gewoon in één commando geven!

Waar ik je overigens niet meer over gehoord heb (en wel van belang gaat zijn), hoe ben je van plan de motor sturing van de verschillende Arduino's te synchroniseren? Zonder dat ga je tegen versnellingen aanlopen op blok overgangen.
Synchronisatie

En wat ik zeg, veel tips (zoals goeie variabele namen en functie namen) helpen je om beter begrijpbare code te maken. Niet alleen voor mij/ons maar vooral ook voor toekomst jij. Als jij over 2 jaar de code opent, weet jij dan nog waar variabele r voor staat? Of waarvoor de previousMillis gebruikt werd? Ik zelf zou dan een maand later al niet meer weten! Een variabele als richtingLink zie je gelijk aan wat je er mee bedoelt. En ook als het true of false is weet je gelijk de uitkomst. Terwijl als je het richting noemt en je krijgt er true(of 1 ) uit moet je maar weer opzoeken of 1 nu links of rechtsom is... Zelfde geld voor ledMillis, hieraan zie je gelijk dat je er een tijd voor de led mee bij houdt.

En het is leuk dat je nu a en A voor blok 1 gebruikt en b/B voor blok twee enz. Maar het geeft je een hoop werk dit steeds toe te moeten voegen aan de switch enz. En wat doe je als je bij blok 26 bent aangekomen? Je code aanpassen voor dingen als aa en BB is een hoop werk tegen die tijd. Terwijl het niet nodig is 


Timo

[smits66]

Hoi Volgers,

Ik heb me bezig gehouden met het programmeren van de Master, slave1, slave2 I²C sturing van de blokkaarten.

De programma's zijn nog in een test fase (sterker nog, niet getest)   

Voor de meedenkers  (alvast bedankt) de twee programma's arduino master en arduino slave

Arduino master

Code: [Selecteer]

//I2C Master Code(Arduino Nano)

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

#define BACKLIGHT_PIN     3

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

const byte SlavePin1 = 2;
const byte SlavePin2 = 3;
const byte SlavePin3 = 4;
const byte SlavePin4 = 5;
const byte MasterSendPin = 6;
const byte MasterRecivePin = 7;
const byte ControllePin = 13;

int Interval = 500; // Tijdvertraging ter controlle of het programma nog loopt.

boolean LedState = LOW;

unsigned long LedMillis = 0; // slaat de laatste stand van de LED op.

char I2CByte; // Slaat een waarde op in I2CByte

void setup()
{

  lcd.begin(20, 4); // Stelt de lcd driver in op 20 characters en vier regels.

  // set de backlight van het lcd display aan.
  lcd.setBacklightPin(BACKLIGHT_PIN, POSITIVE);
  lcd.setBacklight(HIGH);
  lcd.home (); // Ga naar de boventse regel en het eerste character.

  pinMode(SlavePin1, OUTPUT);
  pinMode(SlavePin2, OUTPUT);
  pinMode(SlavePin3, OUTPUT);
  pinMode(SlavePin4, OUTPUT);
  pinMode(MasterSendPin, OUTPUT);
  pinMode(MasterRecivePin, OUTPUT);
  pinMode(ControllePin, OUTPUT);

  Serial.begin(9600);
  Serial.println("Arduino test programma : I2C communicatie");

  lcd.home ();
  lcd.setCursor(0, 1);
  lcd.println("Arduino Bloksturing");

  Wire.begin();
  delay(1000);
}
void loop()
{

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

  unsigned long currentMillis = millis();

  if (currentMillis - LedMillis > Interval) {

    // Sla de laatste stand van de Led waneer die nog knipperde

    LedMillis = currentMillis;

    // Als de Led uit is zet de Led aan en vice-versa:

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

    digitalWrite(ControllePin, LedState); // Afhankelijk van de ledState is de Led aan of uit.

  }

  if (Serial.available() > 0) {  // Kijk of de seriele verbinding beschikbaar is.

    int I2CByte = Serial.read(); // Lees een 'byte'.

    switch (I2CByte) {

      case'A': // Blok 1 Vrij

        Wire.beginTransmission(2);
        Wire.write('A'); // Stuur een A naar slave 2, Blok1, HIGH
        Serial.println("Stuur een A naar de Slave 2");
        digitalWrite(MasterSendPin, HIGH);

        Wire.endTransmission();

        delay(20);

        Printmenu();

        break;

      case'a': // Blok 1 Bezet

        Wire.beginTransmission(2);
        Wire.write('a'); // Stuur een a naar slave 2, Blok1,LOW
        Serial.println("Stuur een a naar de Slave 2");
        digitalWrite(MasterSendPin, HIGH);

        Wire.endTransmission();

        delay(20);

        break;
      case'B': // Blok 2 Vrij

        Wire.beginTransmission(2);
        Wire.write('B'); // Stuur een B naar slave 2, Blok2, HIGH
        Serial.println("Stuur een B naar de Slave 2");
        digitalWrite(MasterSendPin, HIGH);

        Wire.endTransmission();

        delay(20);

        Printmenu();

        break;

      case'b': // Blok 2 Bezet

        Wire.beginTransmission(2);
        Wire.write('b'); // Stuur een b naar slave 2, Blok2,LOW
        Serial.println("Stuur een b naar de Slave 2");
        digitalWrite(MasterSendPin, HIGH);

        Wire.endTransmission();

        delay(20);

        Printmenu();

        break;

      case'C': // Blok 3 Vrij

        Wire.beginTransmission(3);
        Wire.write('C'); // Stuur een C naar slave 3, Blok3,HIGH
        Serial.println("Stuur een C naar de Slave 3");
        digitalWrite(MasterSendPin, HIGH);

        Wire.endTransmission();

        delay(20);

        Printmenu();

        break;

      case'c': // Blok 3 Bezet

        Wire.beginTransmission(3);
        Wire.write('c'); // Stuur een c naar slave 3, Blok3,LOW
        Serial.println("Stuur een c naar de Slave 3");
        digitalWrite(MasterSendPin, HIGH);

        Wire.endTransmission();

        delay(20);

        Printmenu();

        break;

      case'D': // Blok 4 Vrij

        Wire.beginTransmission(3);
        Wire.write('D'); // Stuur een D naar slave 3, Blok4,HIGH
        Serial.println("Stuur een D naar de Slave 3");
        digitalWrite(MasterSendPin, HIGH);

        Wire.endTransmission();

        delay(20);

        Printmenu();

        break;

      case'd': // Blok 4 Bezet

        Wire.beginTransmission(3);
        Wire.write('d'); // Stuur een d naar slave 3, Blok4,LOW
        Serial.println("Stuur een d naar de Slave 3");
        digitalWrite(MasterSendPin, HIGH);

        Wire.endTransmission();

        delay(20);

        Printmenu();

        break;

    }
  }
}
void Printmenu() {

  Serial.println();
  Serial.println(F("Arduino analoge modelbaan sturing: Motorsturingen en blok meldingen"));
  Serial.println();
  Serial.println(F("Stuur comando's"));
  Serial.println();
  Serial.println(F("A = Blok 1 vrijgeven       a = Blok 1 bezet melden"));
  Serial.println(F("B = Blok 2 vrijgeven       b = Blok 2 bezet melden"));
  Serial.println(F("C = Blok 3 vrijgeven       c = Blok 3 bezet melden"));
  Serial.println(F("D = Blok 4 vrijgeven       d = Blok 4 bezet melden"));
  Serial.println(F("< = Trein linksom          > = Trein rechtsom"));
  Serial.println(F("1 = Trein 1 starten        0 = Trein 1 stoppen"));
  Serial.println(F("| = Wissel 1 rechtdoor     / = Wissel 1 Afbuigend"));
  Serial.println();
  Serial.println(F("9 = Noodstop"));
  Serial.println();

}
Arduino slave

Code: [Selecteer]

//i2c Slave Code(NANO slave 2)

#include <Wire.h>

//char I2CByte;       // Slaat een waarde op in incomingByte

/******************************************************************************
 * Definities
 ******************************************************************************
 * Blok A en C is aangesloten op OUT1 en OUT2 van de motorsturing
 * Blok B en D is aangesloten op OUT3 en OUT4 van de motorsturing
 ******************************************************************************/
// constants zullen niet veranderen.

// Geef de output pinnen een naam.

const byte LedPin =  13; // Pin nummer LedPin
const byte blok1Pin = 8; // Pin nummer Blok 1
const byte blok2Pin = 12; // Pin nummer Blok 2
const byte sein1rPin = 4; // sein 2 Rood
const byte sein1gPin = 5; // sein 2 Groen
const byte sein2rPin = 2; // sein 1 rood
const byte sein2gPin = 3; // sein 1 Groen
const byte wissel1rPin = 6; // Wissel 1 Rechtdoor
const byte wissel1aPin = 7; // Wissel 1 Afbuigend

int Interval = 500; // Tijdvertraging ter controlle of het programma nog loopt.

//Trein 1

const byte PinPwmA = 9;  // Snelheids regeling trein 1
const byte PinAin1 = 10; // Rechtsom trein 1
const byte PinAin2 = 11; // Linksom trein 1

boolean Cw =  false;  // clockwise
boolean Ccw = false; // counter clockwise

boolean ledState = LOW;

unsigned long ledMillis = 0; // slaat de laatste stand van de LED op.

void setup()
{
  Wire.begin(2);
  // Stelt de comminicatie met de master in.
 
  Wire.onReceive(receiveBlok1);
  Wire.onReceive(receiveBlok2);
  Wire.onReceive(receiveWissel1r);
  Wire.onReceive(receiveWissel1a);
  Wire.onReceive(receiveVooruit);
  Wire.onReceive(receiveAchteruit);
  Wire.onReceive(receiveOptrekken);
  Wire.onReceive(receiveAfremmen);
 
}
void loop()
{
  // Controlle led om te zien of het programma nog werkt.

  unsigned long currentMillis = millis();

  if (currentMillis - ledMillis > Interval) {

    // Sla de laatste stand van de Led waneer die nog knipperde

    ledMillis = currentMillis;

    // Als de Led uit is zet de Led aan en vice-versa:

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

    digitalWrite(LedPin, ledState); // Afhankelijk van de ledState is de Led aan of uit.

  }
}
void receiveBlok1(int howMany)
{
  while (Wire.available())
  {
    char I2CByte = Wire.read();

    if (I2CByte == 'A')
    {

      baanvak(1, 0);

    }
    else if ( I2CByte == 'a')
    {

      baanvak(1, 1);

    }
  }
}
void receiveBlok2(int howMany) {
 
  while (Wire.available())
  {
    char I2CByte = Wire.read();

    if (I2CByte == 'B')
    {

      baanvak(2, 0);

    }
    else if ( I2CByte == 'b')
    {

      baanvak(2, 1);

    }
  }
}

void receiveWissel1r(int howMany) {
 
}
void receiveWissel1a(int HowMany) {
 
}
void receiveVooruit(int HowMany) {
 
}
void receiveAchteruit(int howMany) {
 
}
void receiveOptrekken(int howMany) {
 
}
void receiveAfremmen(int howMany) {
 
}

void locomotief(int loc, int snelheid, int richting) {

  // Zet de parameters van de functie locomotief (loc, snelheid, richting)
  // Loc: 1 output A op het motorshield
  // Snelheid: 0 is stop, 250 is maximale snelheid
  // Richting: 0 Rechtsom, 1 Linksom

  boolean inPin1 = LOW;
  boolean inPin2 = HIGH;

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

  }

  else {

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

    }
  }

  if (loc == 1) {

    digitalWrite(PinAin1, inPin1);
    digitalWrite(PinAin2, inPin2);
    analogWrite(PinPwmA, snelheid);

  }
}
void baanvak(int blok, int status) {

  // Zet de parameters van de functie baanvak (blok, status)
  // Blok: 1 waarde blok kan van 1 tot zoveel blokken nodig zijn worden gebruikt.
  // Voor elk blok moet een routine schrijven.
  // Status: 0 vrij, 1 bezet.


  if (blok == 1) {

    if (status == 1) {

      digitalWrite(blok1Pin, LOW);

      digitalWrite(sein1rPin, LOW);
      digitalWrite(sein1gPin, HIGH);

    }
  }

  if (blok == 1) {
    if (status == 0) {

      digitalWrite(blok1Pin, HIGH);

      digitalWrite(sein1rPin, HIGH);
      digitalWrite(sein1gPin, LOW);

    }
  }

  if (blok == 2) {

    if (status == 1) {

      digitalWrite(blok2Pin, LOW);

      digitalWrite(sein2rPin, LOW);
      digitalWrite(sein2gPin, HIGH);

    }
  }
  if (blok == 2) {
    if (status == 0) {

      digitalWrite(blok2Pin, HIGH);

      digitalWrite(sein2rPin, HIGH);
      digitalWrite(sein2gPin, LOW);

    }
  }

  if (blok == 0) {

    if (status == 1) {

      digitalWrite(blok2Pin, LOW);
      digitalWrite(blok1Pin, LOW);

      digitalWrite(sein1rPin, LOW);
      digitalWrite(sein2rPin, LOW);

      digitalWrite(sein1gPin, HIGH);
      digitalWrite(sein2gPin, HIGH);
    }
  }

  if (blok == 0) {

    if (status == 0) {

      digitalWrite(blok2Pin, HIGH);
      digitalWrite(blok1Pin, HIGH);

      digitalWrite(sein1rPin, LOW);
      digitalWrite(sein2rPin, LOW);

      digitalWrite(sein1gPin, HIGH);
      digitalWrite(sein2gPin, HIGH);
    }
  }
}

void wissel(int wnummer, int wrichting) {

  // Zet de parameters van de functie wissel (wnummer, wrichting)
  // wnummer   : 1, deze waarde bevat het nummer van de wissel
  // wrichting : 0, deze waarde geeft de richting van de wissel, 1 rechtdoor, 0 afbuigend
  // Let op !, deze parameters moetten voor elke wissel worden ingesteld, de wissels worden in paar gesteld.
  // De wissels kunnen ook per wissel gesteld worden, de programeercode hoeft daar niet voor aangepast worden.

  if (wnummer == 1) {

  }

  if (wrichting == 0) {

    digitalWrite(wissel1rPin, HIGH);
    delay(500);
    digitalWrite(wissel1rPin, LOW);
  }

  if (wnummer == 1) {

  }
  if (wrichting == 1) {

    digitalWrite(wissel1aPin, HIGH);
    delay(500);
    digitalWrite(wissel1aPin, LOW);
  }
}
Mvg Paul Smits

[smits66]

Hoi volgers,

Ik ben al weer een tijdje bezig met I²C tussen meerder Arduino's om dat voor elkaar te krijgen.

Het is eindelijk gelukt om een I²C communicatie voor elkaar te krijgen, ik heb al heel wat programmaatjes er voor
geschreven maar deze werkt allemaal niet.

Ik ben nu in staat om twee blokschakelingen via I²C te sturen, op elke slave zit dezelfde code alleen de mededelingen zijn aangepast en het slave nummer is anders, de master is eigenlijk een interface tussen de computer en de slave units, de slave units sturen de poorten aan.

De programmeer code is nog in ontwikkel stadium, deze code moet ik nog gaan aanpassen naar de uiteindelijke versie,
ik programmeer eerst een werkende versie en van de werkende versie wil ik dan uiteindelijk een gestructureerd programma maken

Het master programma is nu nog geprogrammeerd met een " if functie" voor de communicatie met de slave units,
ik wil daar uiteindelijk een case functie voor gaan gebruiken, alle mededelingen en menu structuur zal door de master voor zijn rekening worden genomen.

Per Arduino Blokkaart heb ik:

* 8 poorten voor de sturingen van wissels seinen of blokken of een combinatie ervan.
* 3 poorten voor motorsturing.
* Communicatie poort (serial 0 en 1) deze poorten kan ik in principe gewoon gebruiken, de slave units communiceren via I²C
* I²C poort (a4 en a5)
* 4 Analoge poorten (uno) of 6 analoge poorten (nano).
* Poort 13 word gebruikt om de communicatie tussen de Master unit en slave unit zichtbaar te maken.

Op deze manier kan ik de programmeercode van alle slave units relatief eenvoudig houden.

Foto, opstelling Arduino analoge modelbaan sturing.




De master code:

Code: [Selecteer]

// I2C Mastercode (NANO)
#include<Wire.h>

void setup()
{
  Serial.begin(9600);
  //Serial.println("Arduino i2c sturing tussen twee of meer arduino's");
  Wire.begin();
 
  //Printmenu();
}
void loop()
{
  if (Serial.available());
  {
    char c = Serial.read();
    if (c == 'A')
    {
      Wire.beginTransmission(5); // Adres eerste slave unit
      Wire.write('A');
      Wire.endTransmission();
      Serial.println("Blok 1 Vrij geven.");
     
      Printmenu();
    }
    if (c == 'a')
    {
      Wire.beginTransmission(5);
      Wire.write('a');
      Wire.endTransmission();
      Serial.println("Blok 1 Bezet melden.");
    }
    if (c == 'B')
    {
      Wire.beginTransmission(5);
      Wire.write('B');
      Wire.endTransmission();
      Serial.println("Blok 2 Vrij geven.");
    }
    if (c == 'b')
    {
      Wire.beginTransmission(5);
      Wire.write('b');
      Wire.endTransmission();
      Serial.println("Blok 2 Bezet melden.");
    }
    if (c == '|')
    {
      Wire.beginTransmission(5);
      Wire.write('|');
      Wire.endTransmission();
      Serial.println("Wissel 1 Rechtdoor.");
    }
    if (c == '/')
    {
      Wire.beginTransmission(5);
      Wire.write('/');
      Wire.endTransmission();
      Serial.println("Wissel 1 Afbuigend");
    }
     if (c == 'C')
    {
      Wire.beginTransmission(6); // Adres tweede slave unit.
      Wire.write('C');
      Wire.endTransmission();
      Serial.println("Blok 3 Vrij geven.");
    }
    if (c == 'c')
    {
      Wire.beginTransmission(6);
      Wire.write('c');
      Wire.endTransmission();
      Serial.println("Blok 3 Bezet melden.");
    }
    if (c == 'D')
    {
      Wire.beginTransmission(6);
      Wire.write('D');
      Wire.endTransmission();
      Serial.println("Blok 4 Vrij geven.");
    }
    if (c == 'd')
    {
      Wire.beginTransmission(6);
      Wire.write('d');
      Wire.endTransmission();
      Serial.println("Blok 4 Bezet melden.");
    }
  }
}
void Printmenu() {

  Serial.println();
  Serial.println(F("Arduino analoge modelbaan sturing: Motorsturingen en blok meldingen"));
  Serial.println();
  Serial.println(F("Stuur comando's"));
  Serial.println();
  Serial.println(F("A = Blok 1 vrijgeven       a = Blok 1 bezet melden"));
  Serial.println(F("B = Blok 2 vrijgeven       b = Blok 2 bezet melden"));
  Serial.println(F("C = Blok 3 vrijgeven       c = Blok 3 bezet melden"));
  Serial.println(F("D = Blok 4 vrijgeven       d = Blok 4 bezet melden"));
  Serial.println(F("< = Trein linksom          > = Trein rechtsom"));
  Serial.println(F("1 = Trein 1 starten        0 = Trein 1 stoppen"));
  Serial.println(F("| = Wissel 1 rechtdoor     / = Wissel 1 Afbuigend"));
  Serial.println();
  Serial.println(F("9 = Noodstop"));
  Serial.println();

}
De slave code:

Code: [Selecteer]

// I2C Slave code (NANO)
#include <Wire.h>

void setup()
{
  Wire.begin(5);
  Wire.onReceive(receiveEvent);
 
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
  digitalWrite(13, LOW);

}
void loop()
{
}
void receiveEvent(int howMany)
{
  while (Wire.available())
  {
    char c = Wire.read();
    if (c == 'A')
    {
      digitalWrite(8, HIGH); // BloK 1 Vrij geven.
    }
    if (c == 'a')
    {
      digitalWrite(8, LOW); // Blok 1 Bezet melden.
    }
    if (c == 'B')
    {
      digitalWrite(12, HIGH); // Blok 2 Vrij geven.
    }
    if (c == 'b')
    {
      digitalWrite(12, LOW); // Blok 2 bezet melden.
    }
    if (c == '|')
    {
      // Wissel 1 Rechtdoor.
      digitalWrite(6, HIGH);
      delay(750); // bekrachtigings- tijd wisselspoel.
      digitalWrite(6, LOW);

    }
    if (c == '/')
    {
       // Wissel 1 Afbuigend.
      digitalWrite(7, HIGH);
      delay(750); // bekrachtigings- tijd wisselspoel.
      digitalWrite(7, LOW);

    }
  }
}
De communicatie tussen de computer en de Master unit gaat via een bluetooth verbinding, ik vind dat makkelijker om de master unit dan niet vastzit aan de computer maar dat er wel communicatie is, tussen de pc en de master unit.

@Timo

Even nog terug komen op jou opmerkingen, ik vind het fantastisch dat je met/voor mij meedenkt.

Nu je een display aan de module hangt is dat wel wat lastiger. Of krijgt niet elke module een display? Staat me iets van bij dat je graag had dat je één Adruino tussen PC en rest wilde die ook als interface zou dienen. Dan kan het wel makkelijk. Maar dan zou ik nu al beginnen met de boel op te splitsen. Hoe meer je er nu bij maakt hoe lastiger...

Alleen op de master komt een I²C lcd display.

Gelijk ook terug komende op je foto's, hoe stuur je nu de wissels? Via de relais? En zie ik dat goed, schakel je de relais gelijk door de Arduino? Zo ja, welke relais zijn het? (Zoveel vermogen kan de Arduino niet leveren op een pin.) En ik lijk geen back EMF diodes te zien...
 

De wissels worden gestuurd door vermogenstransistor.(BD 135)
De relais worden aangestuurd door kleine transistors. (BC547)
Dat klopt vergeten te plaatsen, alsnog gedaan.

Het klopt dat de motorsturingen die ik gebruik twee uitgangen voor motoren hebben.
Ik gebruik "out a" voor blokkaart 1 en "out b" voor blokkaart 2

Over de synchronisatie van de motor sturingen, heb ik nog niet over nagedacht.

De suggesties voor het programma ga ik zeker proberen te gebruiken.
Ik moet nog veel leren met betrekking tot het programmeren, ik doe het dan ook met kleine stapjes.

Timo, nogmaals bedankt voor je input en ik hoop dat je me in het verdere ontwikkeling van het programma, steeds wil voorzien van suggesties.

Mvg Paul

[Timo]

Kijk, dat begint ergens op te lijken.

Alleen waarom ben je opeens compleet afgestapt van variabele? Komt de leesbaarheid van de code niet echt ten goede. Zeker als je er meer code bij gaat maken.

Ook zou ik de code van de slave zo maken dat het makkelijk is om het adres aan te passen. Je zou kunnen overwegen dit naar het EEPROM te schrijven. Dan hoef je niet voor elke slave iets aan te passen voor het programmeren.

En dan echt de volgende stap, je wil af van die delay's  Daarmee ga je je anders hard mee in de vingers snijden later

Ook denk ik dat je nu wilt gaan proberen de communicatie tussen master en PC anders te maken. Voor nu is het leuk dat je een case statement hebt daarvoor maar het maakt het wel echt veeeeeeeeeeeel ingewikkelder dan nodig. Maw, veeeeeeel meer werk dan nodig


Timo

[smits66]

Hoi volgers

Ik heb gisteravond  de code aangepast en de master en beide slave's aangepast tot een hopelijk een meer leesbare code.

Alle functies zijn er nog niet er in gebouwd, dat moet zo spoedig mogelijk gedaan worden.

Listing Master :

Code: [Selecteer]

//I2C Master Code(Arduino Nano)

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

#define BACKLIGHT_PIN     3

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

const byte SlavePin1 = 2;
const byte SlavePin2 = 3;
const byte SlavePin3 = 4;
const byte SlavePin4 = 5;
const byte MasterSendPin = 6;
const byte MasterRecivePin = 7;
const byte ControllePin = 13;
char Slave;
char I2CByte; // Slaat een waarde op in I2CByte

void setup()
{

  lcd.begin(20, 4); // Stelt de lcd driver in op 20 characters en vier regels.

  // set de backlight van het lcd display aan.
  lcd.setBacklightPin(BACKLIGHT_PIN, POSITIVE);
  lcd.setBacklight(HIGH);
  lcd.home (); // Ga naar de boventse regel en het eerste character.

  pinMode(SlavePin1, OUTPUT);
  pinMode(SlavePin2, OUTPUT);
  pinMode(SlavePin3, OUTPUT);
  pinMode(SlavePin4, OUTPUT);
  pinMode(MasterSendPin, OUTPUT);
  pinMode(MasterRecivePin, OUTPUT);
  pinMode(ControllePin, OUTPUT);

  Serial.begin(9600);
 
  Printmenu();

  Wire.begin();

  lcd.home ();
  lcd.setCursor(0, 1);
  lcd.println("Arduino Bloksturing");
}
void loop()
{
  Wire.requestFrom(5, 1);   // request
  //Wire.requestFrom(6, 1);

  if (Wire.available()) { // slave may send less than requested
   
    char Slave = Wire.read(); // receive a byte as character
   
    if (Slave == 5)
    {
      digitalWrite(SlavePin1, HIGH);
      digitalWrite(MasterSendPin, HIGH);
    }
    else
    {
     
      digitalWrite(SlavePin1, LOW);
      digitalWrite(MasterSendPin, HIGH);     
    }
     
    //if (Slave == '6')
    //{
   
     // digitalWrite(SlavePin2, HIGH);
     // digitalWrite(MasterSendPin, HIGH);
    //}
    //else
    //{
   
      //digitalWrite(SlavePin2, LOW);
      //digitalWrite(MasterSendPin, HIGH);     
    //}
  }
 
  if (Serial.available()) { // Kijk of de seriele verbinding beschikbaar is.

    char I2CByte = Serial.read(); // Lees een 'byte'.

    switch (I2CByte) {

      case'A': // Blok 1 Vrij

        Wire.beginTransmission(5);
        Wire.write('A'); // Stuur een A naar slave 2, Blok1, HIGH
        Wire.endTransmission();

        Serial.println("Blok 1 Vrij");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin1, LOW);

        Printmenu();

        break;

      case'a': // Blok 1 Bezet

        Wire.beginTransmission(5);
        Wire.write('a'); // Stuur een a naar slave 2, Blok1,LOW
        Wire.endTransmission();

        Serial.println("Blok 1 Bezet");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin1, LOW);

        Printmenu();

        break;

      case'B': // Blok 2 Vrij

        Wire.beginTransmission(5);
        Wire.write('B'); // Stuur een B naar slave 2, Blok2, HIGH
        Wire.endTransmission();

        Serial.println("Blok 2 Vrij");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin1, LOW);

        Printmenu();

        break;

      case'b': // Blok 2 Bezet

        Wire.beginTransmission(5);
        Wire.write('b'); // Stuur een b naar slave 2, Blok2,LOW
        Wire.endTransmission();

        Serial.println("Blok 2 Bezet");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin1, LOW);

        Printmenu();

        break;

      case'C': // Blok 3 Vrij

        Wire.beginTransmission(6);
        Wire.write('C'); // Stuur een C naar slave 3, Blok3,HIGH
        Wire.endTransmission();

        Serial.println("Blok 3 Vrij");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin2, LOW);

        Printmenu();

        break;

      case'c': // Blok 3 Bezet

        Wire.beginTransmission(6);
        Wire.write('c'); // Stuur een c naar slave 3, Blok3,LOW
        Wire.endTransmission();

        Serial.println("Blok 3 Bezet");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin2, LOW);

        Printmenu();

        break;

      case'D': // Blok 4 Vrij

        Wire.beginTransmission(6);
        Wire.write('D'); // Stuur een D naar slave 3, Blok4,HIGH
        Wire.endTransmission();

        Serial.println("Blok 4 vrij");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin2, LOW);

        Printmenu();

        break;

      case'd': // Blok 4 Bezet

        Wire.beginTransmission(6);
        Wire.write('d'); // Stuur een d naar slave 3, Blok4,LOW
        Wire.endTransmission();

        Serial.println("Blok 4 Bezet.");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin2, LOW);

        Printmenu();

        break;

      case'|': // wissel 1 rechtdoor

        Wire.beginTransmission(5);
        Wire.write('|');
        Wire.endTransmission();

        Serial.println("Wissel 1 Rechtdoor.");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin1, LOW);

        Printmenu();

        break;

      case'/': // wissel 1 afbuigend

        Wire.beginTransmission(5);
        Wire.write('/');
        Wire.endTransmission();

        Serial.println("Wissel 1 Afbuigend.");
        digitalWrite(MasterSendPin, LOW);
        digitalWrite(SlavePin1, LOW);

        Printmenu();

        break;
    }
  }
}

void Printmenu() {

  Serial.println();
  Serial.println(F("Arduino analoge modelbaan sturing: Motorsturingen en blok meldingen"));
  Serial.println();
  Serial.println(F("Stuur comando's"));
  Serial.println();
  Serial.println(F("A = Blok 1 vrijgeven       a = Blok 1 bezet melden"));
  Serial.println(F("B = Blok 2 vrijgeven       b = Blok 2 bezet melden"));
  Serial.println(F("C = Blok 3 vrijgeven       c = Blok 3 bezet melden"));
  Serial.println(F("D = Blok 4 vrijgeven       d = Blok 4 bezet melden"));
  Serial.println(F("< = Trein linksom          > = Trein rechtsom"));
  Serial.println(F("1 = Trein 1 starten        0 = Trein 1 stoppen"));
  Serial.println(F("| = Wissel 1 rechtdoor     / = Wissel 1 Afbuigend"));
  Serial.println();
  Serial.println(F("9 = Noodstop"));
  Serial.println();

}
 
Listing Slave 5 :

Code: [Selecteer]

// I2C Slave code (NANO)
#include <Wire.h>

char I2CByte;

const byte Blok1Pin = 8;  // Blok 1
const byte Blok2Pin = 12; // Blok 2
const byte Sein1rPin = 4; // Sein 1 rood
const byte Sein1gPin = 5; // Sein 1 groen
const byte Sein2rPin = 2; // Sein 2 rood
const byte Sein2gPin = 3; // Sein 2 groen
const byte Wissel1rPin = 6; // Wissel 1 rechtdoor
const byte Wissel1aPin = 7; // Wissel 1 afbuigend
const byte PinPwm = 9; // Snelheids regeling pwm
const byte PinIn1 = 10; // Trein cw
const byte PinIn2 = 11; // Trein ccw

boolean Cw = false;
boolean Ccw = false;

void setup()
{

  pinMode(Wissel1rPin, OUTPUT);
  pinMode(Wissel1aPin, OUTPUT);
  pinMode(Blok1Pin, OUTPUT);
  pinMode(Blok2Pin, OUTPUT);
  pinMode(Sein1rPin, OUTPUT);
  pinMode(Sein1gPin, OUTPUT);
  pinMode(Sein2rPin, OUTPUT);
  pinMode(Sein2gPin, OUTPUT);
  pinMode(PinPwm, OUTPUT);
  pinMode(PinIn1, OUTPUT);
  pinMode(PinIn2, OUTPUT);
  pinMode(13, OUTPUT);

  digitalWrite(13, LOW);

  Wire.begin(5); // Stelt de communicatie met de master in.
  Wire.onReceive(receiveEvent); // Iets ontvangen van de Master.
  Wire.onRequest(requestEvent); // Stuur een 5 naar de Master.

}
void loop()
{
}
void receiveEvent(int howMany)
{
  while (Wire.available())
  {
    char I2CByte = Wire.read();

    if (I2CByte == 'A')
    {
      digitalWrite(Blok1Pin, HIGH); // BloK 1 Vrij geven.
    }
    if (I2CByte == 'a')
    {
      digitalWrite(Blok1Pin, LOW); // Blok 1 Bezet melden.
    }
    if (I2CByte == 'B')
    {
      digitalWrite(Blok2Pin, HIGH); // Blok 2 Vrij geven.
    }
    if (I2CByte == 'b')
    {
      digitalWrite(Blok2Pin, LOW); // Blok 2 bezet melden.
    }
    if (I2CByte == '|')
    {
      // Wissel 1 Rechtdoor.
      digitalWrite(Wissel1rPin, HIGH);
      delay(750); // bekrachtigings tijd wisselspoel.
      digitalWrite(Wissel1rPin, LOW);

    }
    if (I2CByte == '/')
    {
      // Wissel 1 Afbuigend.
      digitalWrite(Wissel1aPin, HIGH);
      delay(750); // bekrachtigings tijd wisselspoel.
      digitalWrite(Wissel1aPin, LOW);

    }
  }
}
void requestEvent() {
  Wire.write(5); // Stuur een 5 naar de Master.
}
@ Timo
Bedankt voor je input. 

Ik heb gisteravond de raw code gepost, ik was nog bezig om de goede code met goede variable namen te maken, om snel test code te programmeren gebruik ik geen variable namen, ik hoef dan ook op dat moment niet aan variable namen te denken, meestal zet ik de raw code niet op het forum ,soms vergeet ik een variable te hernoemen zodat het wel in de code zichtbaar is.

De slave hoeft geen ander adres te krijgen,  eenmaal geprogrammeerd, zal het adres van de slave niet meer veranderen, het kan dat het programma in de slave nog wat aangepast word maar geenszins het adres.

De delay's in de slave vind ik persoonlijk niet erg, de noodstop werkt altijd (Hardware matig)

De vertraging van de wissels zijn niet veel groter dan een halve seconde, ze staan nu op 750 maar dat heb ik gedaan om de wissel aansturing te zien (leds die gaan branden), als de trein optrekt ga ik geen wissels stellen, ook op dat gebied vind ik een kleine vertraging in de vorm van een delay, bij het optrekken en afremmen van de trein geen probleem, per blokkaart heb je maar 1 motorsturing.

Ik wil niet eigenwijs zijn  al lijkt wel, maar tot nu toe snap ik nog niets van de millis commando en hoe ik dat moet programmeren, voor de master lijkt het mij wel een goed idee om van de delay's in het programma af te komen, er staan nu nog geen delay's in de code van de master.

Ik vind het case commando een makkelijke manier van het opzetten van een commando structuur, ik zou ook zo gauw niet weten hoe ik het anders kan doen.

Misschien als ik goede en duidelijke voorbeelden op het internet kan vinden, in het Nederlands, mijn Engels is niet zo goed, ik kan het wel lezen maar met veel moeite.

Op mijn modelbaan komen voor nu, geen 26 blokken, kan altijd nog veranderen, vandaar dat ik de letters van het alfabet gebruik voor het sturen van de blokken.

Voor het sturen van wissels moet ik nog eens bekijken hoe ik dat goed kan oplossen.

Ook voor het synchroniseren van de motorsturingen moet ik nog een oplossing vinden.

Al met al hoop ik, dat ik wat vragen heb kunnen beantwoorden en hoe ik het zie, ik hoop dat je me nog steeds van voorbeeld code te willen voorzien, ik kan er altijd wat van leren.(Misschien een uitleg van het Millis commando in het Nederlands)

Mvg Paul 

[Reinout van Rees]

Naar wat ik heb gelezen.... heeft het de voorkeur in de hoofd "loop()" geen delays te zetten, want gedurende de delays kan de arduino nergens op reageren. Geen input, geen i2c spul, niks.

Voor alles dat regelmatig iets moet doen moet je een eigen functie maken die je vanuit de loop aanroept. Die functie moet dan in een variabele kijken of het alweer tijd is om iets te doen. Van te voren moet je dan ergens de huidige tijd in milliseconden (=millis()) opslaan, verhoogd met de waarde die je anders in de delay() gestopt zou hebben.

Ondertussen loopt je hoofd loop() als een gek alles af te zoeken naar iets om te doen. En reageert dus netjes op commando's die binnenkomen.

Probleem: je moet je programma iets anders opzetten en iets beter structureren. Voordeel: je hoofd loop wordt niet steeds platgelegd.

(Dit is wat ik uit de documentatie begrijp. Ik moet zelf m'n eerste millis() commando nog schrijven. In mijn geval wordt het waarschijnlijk micros() omdat ik met m'n servo die extra nauwkeurigheid nodig denk te hebben ).

Reinout

[Timo]

[oeps, iets te vroeg, nog bezig  Klaar!]

@Reinout,

Ik weet niet wat je probeert te doen met servo's maar die kan je standaard (out of the box) al gewoon aansturen. Tenzij je een goede reden hebt lijkt mij micros() niet nodig...

Ik vind het eigenlijk heel slecht dat er in alle Arduino voorbeelden zo veel met delay() gedaan wordt. In het begin lijkt het leuk maar als snel zal je er last van hebben. Voor hele simpele programma's of kleine testjes kan het handig zijn maar buiten dat wil je er eigenlijk vanaf. Ik zou dan ook graag zien dat nadat je "Hoofdstuk 1, Blink program" hebt gehad je gelijk door gaat naar "Hoofdstuk 2, delay() is slecht!". Probeer jij in je programma straks maar eens twee treinen tegelijk te laten optrekken. Of een wissel schakelen terwijl je aan het optrekken bent. En je noodstop mag dan wel hardwarematig werken, software matig is hij op deze manier nutteloos. Überhaupt je stop kan op deze manier zelfs makkelijk te laat aankomen. Als je bijvoorbeeld de loc wilt laten stoppen door een bezetmelding dan ga je er wel vanuit dat de loc gelijk stil staat en niet 20cm verder, toch? En je zegt wel dat je geen wissel gaat schakelen als de trein op trekt enz. Maar waarom zou je hezelf zo beperken? Dit maakt de computer kant alleen maar lastiger...

Ik heb gisteravond de raw code gepost, ik was nog bezig om de goede code met goede variable namen te maken, om snel test code te programmeren gebruik ik geen variable namen, ik hoef dan ook op dat moment niet aan variable namen te denken.

Dat is eigenlijk best wel gek. Variabele namen zijn juist bedacht omdat die makkelijker zijn dan de pinnamen... En als je het pinnummer makkelijker vindt dan de pinnaam gebruik je misschien niet de juiste naam... Niet om betweterig te doen ofzo maar ik denk dat het makkelijker is om gelijk vanaf het begin gewoon namen te gebruiken. Vind het ook makkelijker om jou Paul te noemen dan 8883 (je forum id ).

En nu we het over pinnamen hebben, wat is de taak van SlavePinx ?

De slave hoeft geen ander adres te krijgen,  eenmaal geprogrammeerd, zal het adres van de slave niet meer veranderen, het kan dat het programma in de slave nog wat aangepast word maar geenszins het adres.

Ik snap dat een slave tijdens normaal gebruik geen ander adres hoeft te krijgen. Maar wat als je later (als je al 10+ slave modules hebt) opeens toch nog een aanpassing maakt aan de software? Ga je dan:
- Eerste module aan PC
- Adres in de code aanpassen
- Module programmeren
- Volgende module aan de PC
- Weer adres aanpassen
- Programmeren
- enz?

Zo blijf je bezig... Maar als je het adres in EEPROM op slaat hoef je dat later met herprogrammeren niet aan te passen. Ondanks dat je dan de software aanpast blijft dat bewaard! Hoe je nog maar
- Module aan PC
- Programmeren
- Volgende module aan PC
- Programmeren
- Enz

Kan dan veel tijd schelen. Hoe je een adres dan werkelijk een adres geeft is aan jou. Kan je bijvoorbeeld met eerste keer programmeren doen bijvoorbeeld.

Code: [Selecteer]

#include <EEPROM.h>

byte moduleAdres = 2; //Dit adres zal worden opgeslagen in EEPROM als dit de eerste keer programmeren is of als je FORCEER_NIEUW_ADRES defined (adres 255 niet teogestaan)

//#define FORCEER_NIEUW_ADRES //Uncomment als je de module geforceerd een nieuw adres wilt geven.

const byte AdresEE = 0; //Adres van het eeprom waar het module adres staat opgeslagen

void setup(){
  #ifdef FORCEER_NIEUW_ADRES
    //We passen adres aan. Alleen als deze niet al juist is.
    if(EEPROM.read(AdresEE) != moduleAdres){
      EEPROM.write(AdresEE, moduleAdres);
    }
  #else
    //Is adres niet ingesteld? Nooit ingesteld heeft een waarde van 255 ofwel 0xFF
    if(EEPROM.read(AdresEE) == 0xFF){
      EEPROM.write(AdresEE, moduleAdres);
    }
    else{
      moduleAdres = EEPROM.read(AdresEE); //haal adres uit EEPROM
    }
  #endif
 
}

void loop(){
  //gebruik hier het moduleAdres
}
De eerste keer moet je de variabele moduleAdres zelf de gewenste waarde geven. Deze komt dan in EEPROM. Pas je nu het programma aan en wil je het weer uploaden naar de Arduino zal het module adres gewoon uit EEPROM gehaald worden. Wat je op dat moment hebt staan achter moduleAdres maakt niet uit. Je kunt dus gerust alle modules updaten terwijl je daar hetzelfde adres hebt staan, het wordt niet aangepast. Tenzij je #define FORCEER_NIEUW_ADRES gebruikt.

Misschien een uitleg van het Millis commando in het Nederlands)

Goed, komt hij dan he. Misschien wat kort maar dit is een veel gebruikt voorbeeld.

De Arduino kan maar één ding tegelijk, eigenlijk net als wij. En als je delay() gebruikt is het enige wat de Arduino op dat moment doet dus stomweg wachten... Laten we dat nu eens toepassen op ons en wel op het maken van een broodje ei met bacon.

Je begint met het toasten van het brood. Dit stop je in de toaster en je zet de timer (de delay(1000)) op 1 minuut. Vervolgens ga je wachten tot de minuut om is. Dan haal je het brood uit de toaster.

Nu ga je het spek bakken. Je legt het in de pan en zet een timer voor 2 minuten (delay(2000)). Weer ga je wachten tot de bacon klaar is. Hierna haal je het uit de pan.

En als laatste moeten natuurlijk de eieren nog. Deze doe je in de pan en zet de timer voor 3 minuten (delay(3000)).

Zijn de eieren ook klaar dan kan je de eieren op de toast doen en dan de bacon erop leggen.

Maar dit is gelukkig niet zoals wij nomaal een eitje bakken  Zou wel beetje nutteloss zijn om de hele tijd naar die eierwekker te staren... Wat wij normaal zouden doen is meer als:

- Beginnen met de eitjes, deze duren het langst. Doet ze in de pan en je kijkt naar de klok.
- Je pakt alvast de bacon maar kijkt zo nu en dan op de klok
- Is een minuut om leg je de bacon ook in de pan en kijkt weer op de klok
- Ondertussen pak je het brood en kijkt zo nu en dan op de klok
- Is weer een minuut om dan doe je het broodrooster naar beneden. Ook nu kijk je weer hoe laat het is.
- Nu kan je een bordje pakken en je kijkt weer zo nu en dan naar de klok.
- Je ziet dat er weer een minuut om is. Nu weet je dat alles kaar is. Je maakt je broodje ei met bacon

Je hebt ondertussen steeds tijd voor andere dingen. Zolang je maar met regelmaat op de klok kijkt om te kijken hoe laat het NU is en je vergelijkt het met de tijd dat je met een actie begon. Maar je hebt zelf nu tijd om de deur open te doen als er wordt aangebeld (Serial data komt binnen?) of de brandblusser te pakken als het brandalarm aan gaat (noodstop).

Zelfde kan je doen op een Arduino. Alleen heet de klok millis(). Deze geeft alleen niet de tijd maar het aantal milliseconde sinds je de Arduino aan gezet hebt. Maar dit is niet zo heel anders dan een klok, die geeft immers aan hoeveel uur er gepasseerd is sinds middernacht

Stel nu dat we in code iedere minuut iets willen doen. Dan wordt dat ik code:

Code: [Selecteer]

unsigned long vorigeMillis = 0; //Wanneer is de laatste keer dat we iets gedaan hebben?
const unsigned int Interval = 60 * 1000; //Om de hoeveel tijd (met welk interval) willen we de taak doen?

void loop(){
  //We kijken hoe laat het is,
  //we halen hier vanaf hoe laat het de vorige keer was
  //en kijken of dit al langer dan interval geleden is
  if(millis() - vorigeMillis >= interval){
    //sla de tijd van nu op als laatste keer dat we iets gedaan hebben
    vorigeMillis = millis();
   
    //doe hier wat je eens per minuut wilde doen
  }
}

Of stel nu dat je een ledje voor 10 minuten wilt laten branden nadat je een knopje hebt ingedrukt. Je wilt niet 10 minuten wachten en dan helemaal niets anders doen...

In code zou dat er als volt uit zien. Ik gebruik de Bounce2 library om het knopje af te handelen, veeeeeeeel makkelijer.

Code: [Selecteer]

#include <Bounce2.h>

unsigned long ledjeAanMillis = 0; //De tijd dat we het ledje aan gezet hebben
const unsigned long LedjeAanTijd = 10 * 60 * 1000; //Voor 10 minuten aan

const byte LedjePin = 13; //Pin waar het ledje aan hangt
const byte KnopjePin = 9; //Pin waar het knopje aan hangt (naar GND)

Bounce knopje; //Het object (door de library) van het knopje

void setup(){
  pinMode(LedjePin, OUTPUT); //We willen het ledje laten branden dus een output
  knopje.attach(LedjePin, INPUT_PULLUP); //Geven aan aan welke pi het knopje zit en dat voor deze pin de pull up aan moet
}

void loop(){
  ledjeUpdate();  //Controleren of we het ledje aan of uit moeten zetten
 
  /*
  En hier kan nog veel meer gebeuren
 
  interessanteFunctie();
  nogIets();
 
  ditKanOokwelGebeuren(true);
 
  enz
  */
}

void ledjeUpdate(){
  //Beginnen we met kijken of het knopje is ingedrukt want ja, dan moet het ledje aan
  knopje.update(); //Lees het knopje
 
  //Is het knopje ingedrukt?
  if(knopje.fell()){
    digitalWrite(LedjePin, HIGH); //zet het ledje aan
    ledjeAanMillis = millis();  //sla op wanneer je it gedaan hebt
  }
 
  //nu we dat gedaan hebben, is het misschien tijd om het ledje uit te zetten? Moet hij wel aan staan natuurlijk!
 
  //Staat ledje aan? (Ja, je kan gewoon een digitalRead op een output doen, geen probleem :) )
  if(digitalRead(LedjePin)){
    //Ledje is dus aan, maar moet hij al uit?
    if(millis() - ledjeAanMillis >= LedjeAanTijd){
      digitalWrite(LedPin, LOW);
    }
  }
}

Let er wel op dat je altijd de check doet als:
if( tijdNu/millis() - vorigeTijd >= interval)
Dus vorige tijd aftrekken van tijd nu. En dan controleren of deze groter dan of gelijk is aan het interval. Niet alleen gelijk. Wij laten immers het ei ook niet aanbranden als we er achter komen dat we iets te laat op de klok keken. Dan halen wij het ei ook alsnog uit de pan 

Is het zo al wat duidelijker?

Voor het serial data tussen PC en master gedoe (en dit kan je dan eigenlijk ook gebruiken op de slaves...) zal ik later nog ff iets maken. Dit was al genoeg werk om nu even uit te schrijven. Maar ik dacht dat ik er al eens een opzetje (misschien alleen tekst) voor gemaakt had.


Timo

[Reinout van Rees]

@Reinout,

Ik weet niet wat je probeert te doen met servo's maar die kan je standaard (out of the box) al gewoon aansturen. Tenzij je een goede reden hebt lijkt mij micro() niet nodig...

In jouw uitleg gebruik je millis() om de timing mee te doen, ik doe dat met micros(), dus een factor 1000 nauwkeuriger. Aansturing van servo's doe ik inderdaad met de out-of-the-box standaard servo library. Had jij met "micro()" i.p.v. "micros()" iets anders in gedachte ofzo? Ik doe in ieder geval geen handmatige PWM ofzo

Reden voor micro's: als ik uitga van een servo die ik met writeMicroseconds() aanstuur heb ik max 1000 stapjes. Dan zou een millis() timer met z'n 1000 tijdstappen per seconde perfect zijn voor een servo die ik egaal in 1 seconde om wil zetten. Maar 1.2 seconde of 0.75 seconde is dan lastig/irritant. Met micros() kan ik nauwkeuriger werken.

Of zie ik iets enorm over het hoofd? (Ik sluit niet uit dat ik beter moet opletten met int/unsigned int/unsigned long enzo en het mixen ervan, want ook met micros() vind ik mijn servo niet 100% soepel lopen met m'n tweede testprogrammaatje).

Om spraakverwarring te voorkomen: huidige versie testprogrammaatje, alleen één slag van min naar max van de servo.

Reinout

[Timo]

Oeps, typo. Moest gewoon micros() zijn.

Of zie ik iets enorm over het hoofd?

Yep, het feit dat de interne regelloop van een servo absoluut die nauwkeurigheid niet heeft. Het is alsof je een TGV wilt aansturen op 0,0000001km/h. Compleet nutteloos dus  Een standard SG90 servo doet er bijvoorbeeld al 360ms over om van 0 naar 180 graden te draaien als je hem van het ene op het andere moment van 1ms puls naar 2ms puls stuurt. Ook wordt maar eens in de +-20ms een puls van de Arduino (of elke andere controller) naar de servo gestuurd. Dit is dus maar 50 keer per seconde! Jij kan dan wel mooi elke 500us je positie aanpassen maar dat is compleet nutteloos. De servo ziet nog steeds maar elke 20ms een nieuwe waarde.

En hoe sneller je de servo van A naar B wilt krijgen juist met hoe minder tussenstappen je af kunt. Wil je in 1 seconde van 0 naar 180 zullen wij het al prima als vloeiende beweging zien als je dit is 10 stappen van 18 graden doet.

Maw, leuk dat je de Arduino dus zo hard bezig houdt maar je schiet er niets mee op 


Timo

[ThijsN]

@Timo: Mooie voorbeelden. Delay() is inderdaad niet zo geschikt voor complexe code met verschillende parrallele taken.
Volgens mij is er nog een klein foutje in je voorbeeld geslopen.

Je zegt

Stel nu dat we in code iedere minuut iets willen doen. Dan wordt dat ik code:
 

Code: [Selecteer]

unsigned long vorigeMillis = 0; //Wanneer is de laatste keer dat we iets gedaan hebben?
const unsigned int Interval = 1000; //Om de hoeveel tijd (met welk interval) willen we de taak doen?

Volgens mij betekent dit dat de code elke seconde uitgevoerd wordt, en niet elke minuut. 1000ms is immers 1sec, en niet 60sec.

Hetzelfde geldt natuurlijk voor het andere voorbeeld:10 sec ipv 10 minuten.

Of begrijp ik het verkeerd.

Groet,

Thijs

[Reinout van Rees]

Timo: kijk, dat soort zaken heb ik inderdaad over het hoofd gezien. Ik wist niet dat de servo maar eens per 20ms wordt geupdated. Dan is mieren in de marge met microseconden flink nutteloos, klopt    Ok, is er ergens een webpagina waar dit soort zaken genoemd worden? Daar kan ik nog flink wat van leren, dan.

20ms per stapje. Oh, dan snap ik nu ook waarom ik het nog wat schokkerig vind. Met 180 graden in 360 ms zit je op een halve graat per ms wat de servo haalt. Per 20 ms interval haalt een servo dan 10 graden.

Als ik de servo in een seconde rustig 60 graden wil laten verplaatsen voor een seinarm kom je op een gewenste beweging van 0.06 graad per ms. En dus 1.8 graad per 20ms.

Conclusie is dan dat in die 20 seconde de servo in ongeveer 3ms naar de juiste plek gaat en 17 ms blijft staan en dan weer verder gaat.

Ah! Dat verklaart wel het licht trillerige gedrag. Kennelijk valt dat in de praktijk nauwelijks op? Of worden het gedrag beter met duurdere servo's? Lijkt me dat je vooral met het 20ms interval blijft zitten.

Reinout

[gvandersel]

Reinout,

Je benadert de servo verkeerd. Om de servo te verdraaien van 0^o naar 180^o moet de puls, die iedere 20 ms herhaalt wordt, verandert worden van 1 ms naar 2 ms. 50 keer per seconde kan je de stand van een servo aanpassen. Hoeveel je de puls verandert is aan jouw, maar je hebt 1000 usec. voor 180^o. Laat der servo eens iedere 20msec. een stapje maken en kijk hoe hij dan draait. Vergroot vervolgens de stappen en kijk hoe dat draait.
Maar blijf bij de basis: x stap(pen) per 20 msec.

Groet,

Gerard van der Sel.

[Reinout van Rees]

Ik geef met m'n huidige "micros()" oplossing de arduino veel rekenwerk te doen en vertel de servo library te vaak wat z'n optimale stand op dat moment is. Klopt. Maar ik ga er wel van uit dat de servo library dan zelf degene is die elke 20ms de laatste actuele waarde doorgeeft.

In andere woorden: misschien heb ik te gedetailleerd 4 keer binnen 20ms een nieuwe waarde gegeven, maar als de servo volgens zijn eigen 20ms timer een waarde wil wegschrijven, gebruikt hij dan de laatste waarde?

Als ik maar één maal per 20ms één waarde aan de servo zou geven zou dat dus soepeler gaan? Vanavond ga ik ermee testen.

Reinout

[Timo]

Of begrijp ik het verkeerd.

Oeps, nee, je begrijpt het prima! Heb de code in de voorbeelden aangepast met een factor 60   

@Reinout, een snelle zoekopdracht naar servo puls levert al wat mooie voorbeelden op. 20ms is eigenlijk de standaard maar de meeste servo's kunnen ook wel iets sneller de volgende puls krijgen. Maar hoe snel hangt af van de servo. De Servo library in Arduino doet het in ieder geval elke 20ms. (Of om precies te zijn, iedere 20ms OF de som van alle pulsewifth van alle attached servo's. Net welk langer is maar meestal zal dat 20ms zijn.)

Maar ik ga er wel van uit dat de servo library dan zelf degene is die elke 20ms de laatste actuele waarde doorgeeft.

Dat klopt. Je schrijft nu gewoon vaak naar een variabele en de servo lib lees/gebruikt deze maar eens per 20ms. Die 20ms komt van een timer interrupt.

Als ik maar één maal per 20ms één waarde aan de servo zou geven zou dat dus soepeler gaan?

Nee, zou hetzelfde moeten gaan. Immers stuurt de servo library de servo nog steeds naar de zelfde posities elke 20ms. Maar je geeft de Arduino een stuk minder te doen. Met stapjes in de us range is het best wel lastig om twee of meer servo's tegelijk te laten bewegen. Het uitvoeren van de taak (updaten van de servo) begint namelijk al aardig in de range van je interval te lopen.

Maar goed, zelf vind ik de servo's wel soepel genoeg aan te sturen. op de adServo update ik de servo elke 20ms (of veelvoud daarvan voor hele trage bewegingen). Als je de boel gekoppeld hebt via veerstaal enz valt het denk ik al minder op. (En grote kans dat de speling in de stangen groter is dan de stapgrote van de servo.) Als ik kijk naar huidige servo decoders (en die sturen het immers op dezelfde manier aan) zie ik geen geschok in de bewegingen. Wel wil je het liefst de boel (wissel, sein etc) zo verbinden dat de servo de grootst mogelijke uitslag moet maken voor de gewenste beweging (zo klein mogelijke arm).

Wil je het geschok nog verminderen zou je voor een tragere servo kunnen gaan. Helaas is dat wel gelijk een stuk meer zoeken / meer betalen. Servo's worden juist gebouwd om snel te zijn omdat dat voor de gebruikelijke toepassingen (RC modellen enzo) juist wenselijk is. Zelf gebruik ik nu SG92 servo's. Deze zijn digitaal (geen gejitter) en hebben een snelheid van 100ms per 60 graden ofwel 300ms voor full swing.

Wat nog een optie zou kunnen zijn voor tragere servo's is door deze op een lagere voedingsspanning te zetten. Meeste servo's vinden dat geen probleem. Zijn ze misschien iets minder krachtig maar dat is waarschijnlijk niet erg. Ik zou dan wel een weerstand (100k+) in de signaal lijn tussen servo en Arduino opnemen zodat de servo zich niet gaat proberen te voeden vanuit de (hogere spanning van de) signaal lijn.


Timo

[smits66]

Hoi Volgers

Ben gisteravond nog even bezig geweest met de AAMS sturing via I²C

De sturing werk naar behoren, via de I²C kan ik nu 4 blokken ,twee wissels,  vier seinen sturen, de motor regelingen werken ondertussen ook, nog niet voor 100% maar ik werk veder aan een oplossing.

Om verdere verwarring te voorkomen , noem ik het geen master of slave meer, maar AAMS centrale, AAMS blokkaart, AAMS Wisselkaart,(Wisselkaart moet ik nog maken testversie),enz.

AAMS blok kaart programma.

Code: [Selecteer]

// I2C AAMS Blokkaart code (NANO)
#include <Wire.h>

char I2CByte;

const byte Blok1Pin = 8;  // Blok 1
const byte Blok2Pin = 12; // Blok 2
const byte Sein1rPin = 4; // Sein 1 rood
const byte Sein1gPin = 5; // Sein 1 groen
const byte Sein2rPin = 2; // Sein 2 rood
const byte Sein2gPin = 3; // Sein 2 groen
const byte Wissel1rPin = 6; // Wissel 1 rechtdoor
const byte Wissel1aPin = 7; // Wissel 1 afbuigend
const byte PinPwm = 9; // Snelheids regeling pwm
const byte PinIn1 = 10; // Trein cw
const byte PinIn2 = 11; // Trein ccw

boolean CwRichting = 0;
boolean CcwRichting = 1;

void setup()
{

  pinMode(Wissel1rPin, OUTPUT);
  pinMode(Wissel1aPin, OUTPUT);
  pinMode(Blok1Pin, OUTPUT);
  pinMode(Blok2Pin, OUTPUT);
  pinMode(Sein1rPin, OUTPUT);
  pinMode(Sein1gPin, OUTPUT);
  pinMode(Sein2rPin, OUTPUT);
  pinMode(Sein2gPin, OUTPUT);
  pinMode(PinPwm, OUTPUT);
  pinMode(PinIn1, OUTPUT);
  pinMode(PinIn2, OUTPUT);
  pinMode(13, OUTPUT);

  digitalWrite(13, LOW);

  Wire.begin(5); // Stelt de communicatie met de master in.
  Wire.onReceive(receiveEvent); // Iets ontvangen van de Master. // <<<<<<<<<
  Wire.onRequest(requestEvent); // Stuur een 5 naar de Master.
 
  setBaanvakStatus(0,1);
}
void loop()
{ //  De loop word niet gebruikt, in plaats daarvan word een Event gebruikt.
}
void receiveEvent(int howMany)
{
  while (Wire.available())
  {
    char I2CByte = Wire.read();

    if (I2CByte == 'A')
    {

      setBaanvakStatus(1, 0); // BloK 1 Vrij geven.

    }
    if (I2CByte == 'a')
    {

      setBaanvakStatus(1, 1); // Blok 1 Bezet melden.

    }
    if (I2CByte == 'B')
    {

      setBaanvakStatus(2, 0); // Blok 2 Vrij geven.

    }
    if (I2CByte == 'b')
    {

      setBaanvakStatus(2, 1); // Blok 2 bezet melden.

    }
    if (I2CByte == '|')
    {

      setWissel(1, 0); // Wissel 1 Rechtdoor.

    }
    if (I2CByte == '/')
    {

      setWissel(1, 1); // Wissel 1 Afbuigend.

    }
 
    // snelheds regeling voor de baanspanning Pwm

    if (I2CByte == '0') {

      if (CwRichting == 0) {

        for (int t = 200; t >= 10; t--) {

          delay(600);
     
          setLocSpeed(1, t, CwRichting);
        }
      }
        if (CwRichting == 1) {

          for (int t = 200; t >= 10; t--) {

            delay(600);

            setLocSpeed(1, t, !CwRichting);
          }
        }
    }
   
    if (I2CByte == '1') {

      if (CwRichting == 0) {

        for (int t = 10; t <= 200; t++) {

          delay(750);

          setLocSpeed(1, t, CwRichting);

        }
      }
     
      if (CwRichting == 1) {

        for (int t = 10; t <= 200; t++) {

          delay(750);

          setLocSpeed(1, t, !CwRichting);

        }
      }
    }
  }
}

  void requestEvent() {

    Wire.write(5); // Stuur een 5 naar de Master.
  }

  void setLocSpeed(byte loc, byte Snelheid, bool Richting) {

    boolean inPin1 = LOW;
    boolean inPin2 = HIGH;

    if (Richting == 1) {

      inPin1 = LOW;
      inPin2 = HIGH;
    }
    else {

      if (Richting == 0) {

        inPin1 = HIGH;
        inPin2 = LOW;
      }
    }

    if (loc == 1) {

      digitalWrite(PinIn1, inPin1);
      digitalWrite(PinIn2, inPin2);
      analogWrite(PinPwm, Snelheid);
    }
  } // Einde functie setLocSpeed

  void setBaanvakStatus(byte Blok, bool Status) {

    if (Blok == 1) {

      if (Status == 1) {

        digitalWrite(Blok1Pin, LOW); // Blok 1 Bezet.

        // Zet de seinen goed
        digitalWrite(Sein1rPin, HIGH);
        digitalWrite(Sein1gPin, LOW);

      }
    }

    if (Blok == 1) {

      if (Status == 0) {

        digitalWrite(Blok1Pin, HIGH); // Blok 1 Vrij.

        // Zet de seinen goed
        digitalWrite(Sein1rPin, LOW);
        digitalWrite(Sein1gPin, HIGH);
      }
    }
    if (Blok == 2) {

      if (Status == 1) {

        digitalWrite(Blok2Pin, LOW); // Blok 2 Bezet.

        // Zet de seinen goed
        digitalWrite(Sein2rPin, HIGH);
        digitalWrite(Sein2gPin, LOW);

      }
    }
    if (Blok == 2) {

      if (Status == 0) {

        digitalWrite(Blok2Pin, HIGH); // Blok 2 Vrij.

        // Zet de seinen goed
        digitalWrite(Sein2rPin, LOW);
        digitalWrite(Sein2gPin, HIGH);
      }
    }
    if (Blok == 0) {

      if (Status == 1) {

        digitalWrite(Blok1Pin, LOW);
        digitalWrite(Blok2Pin, LOW);

        // Zet de seinen goed
        digitalWrite(Sein1rPin, LOW);
        digitalWrite(Sein1gPin, HIGH);

        digitalWrite(Sein2rPin, LOW);
        digitalWrite(Sein2gPin, HIGH);
      }
    }
    if (Blok == 0) {

      if (Status == 0) {

        digitalWrite(Blok1Pin, HIGH);
        digitalWrite(Blok2Pin, HIGH);

        // Zet de seinen goed
        digitalWrite(Sein1rPin, LOW);
        digitalWrite(Sein1gPin, HIGH);

        digitalWrite(Sein2rPin, LOW);
        digitalWrite(Sein2gPin, HIGH);
      }
    }
  } // einde functie setBaanvakStatus

  void setWissel(byte Wnummer, bool Wrichting) {

    if (Wnummer == 1) {

      if (Wrichting == 0) {

        digitalWrite(Wissel1rPin, HIGH);
        delay(750); // Normaal staat de waarde op 500)
        digitalWrite(Wissel1rPin, LOW);
      }
    }

    if (Wnummer == 1) {

      if (Wrichting == 1) {

        digitalWrite(Wissel1aPin, HIGH);
        delay(750); // Normaal staat de waarde op 500)
        digitalWrite(Wissel1aPin, LOW);
      }
    }
  } // einde functie setWissel

@Timo

Bedankt voor je input 

Het millis commando begreep ik al een beetje (controle led), waar ik niet kan achterbomen is  hoe ik meerdere millis commando's in een loop kan  programmeren , Wissel, Optrekken/afremmen enz.

En nu we het over pin namen hebben, wat is de taak van SlavePinx ?

SlavePinx word gebruikt om de communicatie tussen AAMS blokkaart(x)  en  AAMS centrale zichtbaar te maken, bij elk commando wat ik naar de AAMS Blokkaart stuur zal de AAMS Blokkaart een ontvangstbevestiging terug sturen naar de AAMS centrale.

Ik snap dat een slave tijdens normaal gebruik geen ander adres hoeft te krijgen. Maar wat als je later (als je al 10+ slave modules hebt) opeens toch nog een aanpassing maakt aan de software? Ga je dan:

Als ik het goed heb kan ik 127 slave units met de I²C  gebruiken.
Als ik de software van de AAMS Blokkaart aanpas hoef ik het adres niet te veranderen, komt er een AAMS Blokkaart bij met een nieuw adres, het enigste waar ik een nieuw adres bij moet zetten is in de AAMS centrale.

- Module aan PC
- Programmeren
- Volgende module aan PC
- Programmeren
- Enz

Zoals het bovenstaande lijstje werkt de AAMS sturing via I²C ook , usb stekker in de nano doen, programmeren, volgende nano enz.

Onderstaand word de AAMS Blokkaart aangeroepen.

Code: [Selecteer]

Wire.begin(5); // Stelt de communicatie met de AAMS centrale in.
  Wire.onReceive(receiveEvent); // Iets ontvangen van de AAMS centrale.
  Wire.onRequest(requestEvent); // Stuur een Adres(5) naar de AAMS centrale en maak dat zichtbaar door een LED.
 

Code: [Selecteer]

void requestEvent() {

    Wire.write(5); // Stuur een adres(5) naar de AAMS centrale.
  }

De AAMS Blokkaart word vanuit de AAMS Centrale aangestuurd via een  Wire.onReceive(receiveEvent)

Deze routine word in de setup aangeroepen.
De loop routine word ook niet direct gebruikt.

Code: [Selecteer]

 
  setBaanvakStatus(0,0);
}
void loop()
{
}
void receiveEvent(int howMany)
{
Voor zo ver ik weet kan de millis commando alleen in de loop gebruikt worden, als ik het verkeert heb hoor ik dat wel.

Wat ik begrepen heb van het receiveEvent commando is:

Dat de AAMS Centrale een commando stuurt er in de AAMS Blokkaart een Event word aangeroepen bv. setBaanvakStatus(1,0) deze uitvoert en direct een ander commando kan worden uitgevoerd voordat de vorige commando klaar is.

Het lijkt er sterk op dat een delay(200)  zonder dat de Arduino moet wachten tot de delay(200) is afgelopen andere commando's kan uitvoeren, ik ga dit nog verder testen voordat ik de conclusie trek dat een delay() geen vertragende invloed heeft op de Arduino in een receiveEvent structuur.

Als ik het verkeert begrijp hoor ik dat wel.

Voor het serial data tussen PC en master gedoe (en dit kan je dan eigenlijk ook gebruiken op de slaves...)

Ik snap deze opmerking niet helemaal

De gedachte achter deze sturing is om met de computer de AAMS Centrale aan te sturen en de centrale neemt de communicatie tussen de diverse AAMS kaarten voor zijn rekening, de AAMS Blokkaarten, Wisselkaarten, enz  werken vervolgens als zelfstandige sturingen die dan bepaalde data (bezet melding) terugsturen naar de AAMS Centrale die deze data weer naar computer stuurt.

Ook wil ik deze sturing kunnen gebruiken met een terminal programma al dan niet via usb(serieel) of via bluetooth.
De seriële communicatie en bluetooth communicatie kan ik met deze sturing gebruiken.



Mocht ik jou post verkeert begrepen hebben hoor ik dat graag.
Nogmaals bedankt voor je hulp.

Mvg Paul