Arduino analoge(!) modelbaan sturing

[smits66]

Hoi Timo

Bedankt voor je input.

Voor zo ver ik het heb kunnen zien, zit er geen verbinding tussen de Gnd van de  SX-bus en de Gnd van de outputs 3 t/m 14, ik zal er nog eens naar kijken.
In het schema is de Gnd door gezet naar de outputs 3 t/m 13.

Word nog verder uitgezocht.

Mvg Paul

[gvandersel]

Ik denk dat je je schema nog eens moet nakijken. Nu zit de +5V (VCC) aan de emitters van alle transistoren. Deze krijg je zo nooit open.
Bovendien zitten de ontkoppelcondensatoren heel ongebruikelijk aan de +5V (VCC).

Groet,

Gerard van der Sel.

[Timo]

Gerard, je kijkt fout  Links boven loopt de lijn van alle emitters naar P26 en P17 maar niet niet aan Vcc (loopt er alleen over heen). Nu moet ik ook zeggen, het is ook lastig te zien. Dat is de reden dat er voor de GND lijn (en vaak ook voor andere power lijnen) alleen gebruik gemaakt van symbolen zodat je niet alle GND lijnen hoeft te tekenen.

@Paul, door Gerards aanwijzing heb ik wel een fout gezien. De hele reden dat jij denk dat ze gescheiden zijn van elkaar.  Het lijkt me sterk dat alle emitters van de transistors alleen naar P26 en P27 lopen. Ik durf te wedden dat ze namelijk gewoon aan GND liggen. Dit wordt extra versterkt door het feit dat de ontkoppelcondensatoren van het kirstal ook met deze lijn verbonden zijn. Deze zitten eigenlijk altijd naar GND. Dus ik zou het nog eens doormeten 


Timo

[smits66]

Hoi volgers,


@Timo, Gerard

Bedankt voor je input

Timo

 Je hebt helemaal gelijk  ,de gnd van de sx-bus en de output zijn met elkaar verbonden (tiny koperbaan)

Ik heb het schema in tweeën gedeeld voor de overzichtelijkheid, ik ben nog bezig met het processor gedeelte, de output gedeelte is wel klaar.

Schema : Selectrix funktie-decoder 66821 deel 2



De Blus diodes heb ik nog niet erbij getekend, volgende revisie.

Mvg Paul Smits

 

[Timo]

Hehe  Ik zou alleen even de labels aanpassen. Nu hebben alle torren het label "Page 1" en dat zal gelezen worden als dat al die pinnen aan elkaar zitten (zowel door mensen als de software). Beter is dus hier nuttige namen voor te pakken (iets als OUT1_1, OUT1_2, OUT2_1 enz). Zelfde voor GND maar daarvoor gok ik dat de software al een standaard label heeft (met mooi het GND symbool ). En veel mensen (ik ook) hebben de voorkeur om de GND lijnen zoveel mogelijk omlaag te tekenen. Iets dat de onderste rij torren nu niet heeft. Maakt het namelijk erg makkelijk om het schema te lezen (samen met GND symbool).

Waar zit je nog mee voor uC deel? Weet niet wat de rest van de DIP-switches doen maar gok dat deze ook gewoon naar de uC lopen.


Timo

[smits66]

Hoi Volgers,

@Timo

Bedankt voor de input.

Ik heb geluisterd naar schoolmeester Timo   en het schema van de stuurtorren heb ik aangepast en de blusdiodes geplaatst.

Schema Deel 1:



Schema Deel 2:



Ik heb de Selectrix functie-decoder printplaat naar een schema omgezet, er kunnen nog kleine foutjes in zitten, ik denk echter dat dit schema de juist is.

Het ging mijn meer om te laten zien dat Selectrix uitbreidingen simpel te maken zijn tegen de helft of meer van de kosten van de originele Selectrix decoder of andere Selectrix onderdelen.

Ik wil dit schema verder gaan uitwerken om het geschikt te maken voor de Arduino processorboard en de Selectrix bus.

Een van de schakelingen die ik wil ontwerpen is een analoge motorsturing gestuurd door Selectrix, dit als aanvulling op het AAMS sturing.
Het zal wel veel voeten in de aarde hebben, maar ja, het is een hobby het hoeft niet gisteren af te zijn.

Het lijkt mij wel handig als ik mijn complete modelspoor baan kan sturen met ITrain of Rocrail, dus ook het AAMS systeem, voor er opmerkingen geplaatst worden dat dat systeem al bestaat (Dinamo), echter Dinamo werk niet samen met Selectrix, ik wil blijven rijden met Selectrix.

Voor de duidelijk niveau 0 is de digitale baan met een dubbel of enkel spoor naar niveau 1 kopstation,  niveau 1,2,3 is de analoge baan gestuurd via AAMS.

Het volgende projectje is om de bezetmelder print om te zetten naar schema.

Mvg Paul 

[gvandersel]

Paul,

Kijk eens in mijn bouwdraadje. Vooral de foto's van onder de baan. Alle elektronica daar is zelfbouw. Ik knutsel al met de SX_bus sinds vorige eeuw. Er staat een listing van een SX-bus interface op mijn website (www.vandersel.nl of wereldbolletje lnks). Het schema van de interface is niet correct. Als ik de stippen volg, dan zit D hard vast aan de +5V. Overigens benieuw naar de waarde van de weerstenden.

Groet,

Gerard van der Sel.

[smits66]

Hoi, volgers.

De vakantie/zomer seizoen is helaas weer voorbij, dat geeft mij weer de gelegenheid om aan de AAMS verder te werken,
ik wil nog een handsturing voor het AAMS systeem ontwerpen waarmee ik treinen kan bedienen met de hand door middel van het AAMS systeem.

Ik moet dat nog verder uitzoeken, de voortgang hou ik bij in dit draadje.
Ook met het selectrix gedeelte wil ik verder gaan.

@ Gerard

De D zit niet aan de +5V maar op de +12V.
K1 is de aansluiting van de 12V~ van de trein trafo.

Als het goed is staan de diodes goed, de selectrix functie-decoder schakelt de wissel-spoel via de +12V

R1 tot en met R8 = 2200 ohm (Weerstanden aan de basis van de transistor)

R1 en R2 = 10K ohm (In schema deel 1)

Mvg Paul

[smits66]

Hoi volgers,

Na een geruime tijd weer even mijn topic updaten.

Ik ben na een lange stop, weer bezig geweest met AAMS.

Ik kom vaak niet toe aan een update, ook ben ik met teveel dingen bezig (hobby modelspoor) waardoor ik het overzicht verlies en meerdere projecten tegelijk proberen te ontwerpen, denk aan selectrix, AAMS enz., ik moet mij dan weer eens stil zetten zodat ik me weer kan focussen op hetgeen waar ik origineel mee bezig ben.

Ik stop daarom ook met het selectrix en andere niet AAMS projecten en wil me volledig focussen op AAMS.

De eerste AAMS sturing is complex geworden zowel softwarematig als hardwarematig, het werk prima maar het moet eenvoudiger kunnen dacht ik.

Ik ben een nieuwe sturing gaan ontwerpen, softwarematig eenvoudiger(geen library's en een overzichtelijk programma) en elektro technisch eenvoudiger(simpele elektronica, en meer functies).
Ik ben helemaal opnieuw begonnen met het ontwerp, het leek mij een betere keuze dan het eerste ontwerp te versimpelen.

De nieuwe sturing is elektronisch simpele maar wel met meer mogelijkheden.

De functies:

1. Twee blokken.
2. Twee seinen.
3. Een wissel.
4. Een loc sturing (pwm)
5. I²C met lcd display en communicatie via I²C.
6. 4 analoge poorten beschikbaar (uno)  of 6 analoge poorten (nano).


De twee blokken kunnen afzonderlijk gestuurd worden of, als blok 1 bezet is, is blok 2 vrij.
Afhankelijk van de keuze van het blok relais kun je de sein beelden via de relais sturen en kun je de vier seinpoorten voor iets anders gebruiken bv. twee wissels, of vier extra blokken.
Het is daardoor een flexibele sturing geworden.

Door vier onafhankelijke gestuurde leds kunnen er meerdere seinbeelden getoond worden ,Blok sein x2, inrijsein 1x, uitrijsein 1x, bloksein met voor sein 1x enz.

Door de keuze van transistoren kunnen de wissels als paar gestuurd worden of een enkele wissel gestuurd worden. (kop spoor)

De sturing is op een breadboard gebouwd, daardoor kan ik deze sturing goed testen en aanpassen.

De gebouwde sturing.



Totale overzicht van de sturing.



Het arduino programma.

Code: [Selecteer]

/*
 * Arduino analoge modelbaan stuuring.
 * Nieuwe versie Bloksturingarduino v0.1
 *
 * Writen by Paul Smits
*/

#include <Wire.h>              // library voor I2C
#include <LCD.h>               // library voor een standaard LCD display.
#include <LiquidCrystal_I2C.h> // library voor 12c LCD display

/***** Global vars ***********************************************/
// Define I2C Address where the PCF8574A is

#define BACKLIGHT_PIN     3 // zet de backlight pen op 3

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

char incomingByte;       // 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 int ledPin =  13; // Pin nummer LedPin
const int blok1Pin = 8; // Pin nummer Blok 1
const int blok2Pin = 12; // Pin nummer Blok 2
const int sein1rPin = 4; // sein 2 Rood
const int sein1gPin = 5; // sein 2 Groen
const int sein2rPin = 2; // sein 1 rood
const int sein2gPin = 3; // sein 1 Groen
const int wissel1rPin = 6; // Wissel 1 Rechtdoor
const int wissel1aPin = 7; // Wissel 1 Afbuigend

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

//Trein 1

int PWMA = 9;  // Snelheids regeling trein 1
int AIN1 = 10; // Rechtsom trein 1
int AIN2 = 11; // Linksom trein 1

int r = 0;

boolean ledState = LOW;

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

void setup() {

  lcd.begin (16, 2);  // stelt de lcd driver in op 16 characters en twee regels.
  // 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.

  // Zet het onderstaande tekst op het lcd display

  lcd.setCursor(2, 0); // zet de cursor op het eerste character op de eerste regel
  lcd.print("Arduino Uno");
  lcd.setCursor(1, 1);
  lcd.print("L298  M-Sturing");

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

  pinMode(blok1Pin, OUTPUT);
  pinMode(blok2Pin, OUTPUT);
  pinMode(sein1rPin, OUTPUT);
  pinMode(sein1gPin, OUTPUT);
  pinMode(sein2rPin, OUTPUT);
  pinMode(sein2gPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(wissel1rPin, OUTPUT);
  pinMode(wissel1aPin, OUTPUT);
  pinMode(ledPin, OUTPUT);

  Serial.begin(9600); // Open een serial verbinding op 9600 baud.

  baanvak(0, 1); // Meld alle blokken bezet bij het starten.

  menu();
}
void loop() {

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

  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis > Interval) {

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

    previousMillis = 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.

  }

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

    switch (incomingByte) {

      case 'A': // Blok 1 vrijgave

        Serial.println("Blok 1 : Vrij");

        // Parameters : baanvak( blok, status) status, 0 vrij, 1 bezet.

        baanvak(1, 0);

        lcd.home ();
        lcd.setCursor(0, 0);
        lcd.print("Blok 1: Vrij");

        menu();

        break;

      case 'a':  // Blok 1 bezet melding

        Serial.println("Blok 1 : Bezet");

        baanvak(1, 1);

        lcd.home ();
        lcd.setCursor(0, 1);
        lcd.print("Blok 1: Bezet");

        menu();

        break;

      case 'b': // Blok 2 bezet melding.

        Serial.println("Blok 2: Bezet");

        // Parameters : baanvak(blok, status)

        baanvak(2, 1); // Blok 2 is bezet melding.

        lcd.home ();
        lcd.setCursor(0, 1);
        lcd.print("Blok 2: Bezet");

        menu();

        break;

      case 'B':// Blok 2 vrijgave

        Serial.println("Blok 2: vrij");

        baanvak(2, 0); // Blok 2 is vrij gegeven

        lcd.home ();
        lcd.setCursor(0, 1);
        lcd.print("Blok 2: vrij");

        menu();

        break;

      case '|': // Wissel word rechtdoor gesteld.

        wissel(1, 0);

        lcd.home ();
        lcd.setCursor(0, 1);
        lcd.print("Wissel 1 : Rechtdoor");

        menu();

        break;

      case '/': // Wissel word afbuigend gesteld.

        wissel(1, 1);

        lcd.home ();
        lcd.setCursor(0, 1);
        lcd.print("Wissel 1 : Afbuigend");

        menu();

        break;

      case '1': // Optrekken trein.

        Serial.println("Locomotief trekt op.");

        if (r == 0) {

          int cw = 1; // Richting locomotief is linksom optrekken.

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

            locomotief (1, t, cw);

          }
        }

        else {

          if (r == 1) {

            int cw = 0; // Richting locomotief is rechtsom optrekken.

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

              locomotief (1, t, cw);
            }
          }
        }

        menu();

        break;

      case '0': // Afremmen trein.

        Serial.println(" Locomotief remt af.");

        if (r == 0) {

          int cw = 1; // Richting locomotief is linksom afremmen.

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

            locomotief (1, t, cw);
          }
        }

        else {

          if (r == 1) {

            int cw = 0; // Richting locomotief is rechtsom afremmen.

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

              locomotief (1, t, cw);
            }
          }
        }

        menu();

        break;

      case'<': // De rijrichting van de locomotief is linksom

        r =  1;

        Serial.println("Rijrichting linksom.");

        break;

      case'>': // De rijrichting van de locomotief is rechtsom.

        r =  0;

        Serial.println("Rijrichting rechtsom.");

        break;

      case '9': //Trein linksom en rechtom noodstop.

        locomotief (1, 0, 0);
        locomotief (1, 0, 1);

        Serial.println("Noodstop geactiveerd");

        menu();

        break;

      case '#':

        baanvak(0, 0);

        menu();

        break;

      case '*':

        baanvak(0, 1);

        menu();

        break;
    }
  }
}

void menu() {

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

}

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(AIN1, inPin1);
    digitalWrite(AIN2, inPin2);
    analogWrite(PWMA, 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) {

    Serial.println("wissel 1 rechtdoor");

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

  if (wnummer == 1) {

  }
  if (wrichting == 1) {

    Serial.println("Wissel 1 afbuigend");

    digitalWrite(wissel1aPin, HIGH);
    delay(750);
    digitalWrite(wissel1aPin, LOW);
  }
}
 
Scherm afdruk test programma, werk verder goed.



Uiteindelijk word de baan gestuurd door een gambas programma (een soort visual basic programmeertaal)

Scherm afdruk gambas programma in ontikkeling.



Wat moet er nog bij gebouwd worden.

1.: I²C  communicatie tussen de verschillende blok sturingen.
2.: Bezet meldingen via de analogepoort.
3.: Wissel sturing voor zware belasting (schaduw station meerdere wissels tegelijk sturen)
4.: Bluetooth communicatie tussen pc en sturing
5. Barebone Arduinio, geen programma's uploaden wel communicatie tussen Arduino en pc.

Aan het schema van de sturing en de barebone Arduino word nog gewerkt.

Mvg Paul

[T.Spat]

Leerzaam draadje

Heb sinds kort ook een Arduino in mijn bezit, aangespoord door wat techeuten
bij mijn vrijwilligerswerk Even nieuwe materie, wel interessant.

Het fenomeen van 10000 projecten tegeijk beginnen.... zeer bekend
*kijkt naar chaos om mij heen *

Die prikbordjes zijn idd erg fijne dingetjes voor snel een bult aansluitingen maken,
ben zelf geen held met solderen, dus errug handig

Mvg,

Tis

[smits66]

Hoi Tis

Bedankt voor je reactie

Ik denk dat het bezig zijn met meerdere projecten mens eigen is , daarom moet je jezelf even stil zetten en de focus op het eerste project zetten.

Leuk om te horen dat je met een Arduino aan het experimenteren gaat, het is geen ingewikkelde materie, en er is genoeg over te vinden op het internet.

Wat wil je eigenlijk gaan ontwerpen, als ik dat vragen mag

mvg Paul 

[Timo]

Hoi Paul,

Ziet er weer leuk uit, vooral ook het programma! Ga je deze code ook nog openbaar maken? Je zou er over kunnen denken om GitHub te gebruiken. Dat is het ook niet zo lastig om steeds een up to date versie online te zetten.

Mag ik toch weer met een kritische blik op je post ingaan?  Dit wordt dan weer een lange post en ik bedoel het echt goed! Je bent goed bezig maar het is zo zonde om werk voor niets te doen. Dus echt bedoelt als tips! Ik hoop wel dat je ze een voor een even na zou willen lopen (en misschien reageren).

Eerst op je punten:

1.: I²C  communicatie tussen de verschillende blok sturingen.

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...

3.: Wissel sturing voor zware belasting (schaduw station meerdere wissels tegelijk sturen)

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...

4.: Bluetooth communicatie tussen pc en sturing

Mag ik vragen waarom je dit zou willen?

5. Barebone Arduinio, geen programma's uploaden wel communicatie tussen Arduino en pc.

Wat bedoel je met barebone? Als je bedoelt een losse ATmega chip zou ik zeggen, pak een Arduino Pro Mini. Voor het geld van een Arduino Pro Mini kan ik het zelf aan losse onderdelen echt niet maken. Losse chip kost +-€1,30 en een complete Arduino Pro Mini €1,50...

Een programma zal je altijd op moeten zetten...

Nu over de code. Zoals ik al aan gaf zou ik nu al beginnen met iedere module als node ta gaan zien in een I2C netwerk. Als je dit later moet aanpassen ben je echt meer tijd kwijt dan dit nu al te doen.

Voor de pin definities is het inderdaad nuttig om ze als const te definiëren. Maar je mag ze ook als byte definiëren, scheelt weer ruimte

Je namen zijn (meestal) wel duidelijk maar je zou jezelf helpen door meer met de naam standaard mee te gaan. Dus const wel laten beginnen met hoofdletters (LedPin, Blok1Pin) om aan te geven, kan ik niet wijzigen. En juist normale variabele niet (zoals je nu wel hebt gedaan met Interval, ookal zou je die waarschijnlijk eerder als const willen definiëren  )

Maar variable namen als PWMA, AIN1, previousMillis en r zijn nogal vaag (en de eerste gaan ook niet mee in de naam standaard). Voor de motorcontroller zou ik dan veranderen in

Code: [Selecteer]

const byte PinPwmA = 9;
const byte PinAin1 = 10;
const byte PinAin2 = 11;

De previousMillis is voor eht knipperen van de led, om dat gelijk duidelijk te maken doe ik dat ledMillis noemen. Omdat eht interval maar 500 is zou je ook ruimte kunnen besparen door het als unsigned int ledMillis te definiëren. Doordat je er nu een long, en geen unsigned ling, van hebt gemaakt heb je namelijk nu een error in je programma geschreven

Variabele r zegt niets, noem deze gewoon richting. Of, aangezien het maar twee states kent zou een duidelijke zijn om er bool richtingLinks van te maken. Nu maak je namelijk r ook 1 (dus true) als je linksom bedoelt. Er gewoon richting van maken zou ik dan niet doen, je weet dan niet gelijk wat de true en false ervan betekend. Door er richtingLinks van te maken wel

Doorgaand daarop zou in de functie locomotief (wat ik niet echt de lading van de functie vind dekken overigens, zou ik eerder setLocSpeed van maken) zou het kunnen worden setLocSpeed(byte loc, byte snelheid, bool richtingLinks) worden. Je werkt op een microcontroller, het kiezen van het juiste type variabele is nodig, je hebt niet oneindig ruimte. Byte en bool zijn hier groot genoeg.

Eigenlijk geld dat ook voor baanvak (setBaanvakStatus ?). baanvak(byte blok, bool status);

En daar kom ik dan tegen

// Voor elk blok moet een routine schrijven.

Mm, als je dat soort dingen op schrijf moet je je gaan bedenken of dat niet makkelijker kan. En dat kan super eenvouding! Gebruik arrays  Als je voor alles waar je er meer dan één van hebt een array aan maakt wordt het leven echt een stuk eenvoudiger. Dus SeinPinR[], SeinPinG[] en BlokPin enz. Hele functie (tot oneindig aantal blokken) is dan:

Code: [Selecteer]

void setBaanvakStatus(byte blok, bool status) {
 
  // Zet de parameters van de functie baanvak (blok, status)
  // Blok: 1 waarde blok kan van 1 tot zoveel blokken nodig zijn worden gebruikt.
  // Status: 0 vrij, 1 bezet.
 
  //voor alle blokken
  if(blok == 0){
 
  for(byte i = 0; i < sizeof(BlokPin); i++){
digitalWrite(BlokPin[i], !status); //zet blok goed

//zet zein goed
digitalWrite(SeinPinR[i], status);
digitalWrite(SeinPinG[i], !status);
  }
  }
  //specifiek blok
  else{
digitalWrite(BlokPin[blok - 1], !status); //zet blok goed

//zet zein goed
digitalWrite(SeinPinR[blok - 1], status);
digitalWrite(SeinPinG[blok - 1], !status);
  }
}

Zelfde voor eigenlijk alle andere functies. Als je dan ook nog
#define VRIJ 0
#define BEZET 1

Aanmaakt krijg je duidelijke code als setBaanvakStatus(1, VRIJ); waarvan je, zelfs als je je niet verdiept hebt in de code, gelijk kunt zeggen wat het doet

De grote lappen tekst wil je tussen F() zetten. Dit scheelt heeeeeeel veel geheugen. Dus Serial.println(F("Arduino analoge modelbaan sturing: Motorsturingen en blok meldingen")); enz

In de switch doe je nogal dubbel. Eigenlijk eindig je elke case met menu() (printMenu() zou duidelijker zijn. Again, beter duidelijke naam dan paar tekens minder typen ) Ik zou deze dus gewoon onder de switch zetten

Nu we toch bij de switch zijn, zo met letters voor elk blok ga je wel hard door je mogelijkheden heen. Zou het niet makkelijker zijn om steeds 2 bytes van de PC naar de Arduino te sturen. Waarbij eerste aangeeft wat voor type commando het is en het tweede voor wat het nodig is? Bijvoorbeeld  b 1 om blok 1 vrij te zetten en B 5 om blok 5 bezet te maken?

De switch voor alle blokken zou dan zo simpel zijn als

Code: [Selecteer]

switch(commando){
case 'b': //blok vrij
Serial.print(F("Blok: "));
Serial.print(nummer);
Serial.println(F(" : Vrij"));

//update het baanvak
setBaanvakStatus(nummer, VRIJ);

lcd.home ();
lcd.setCursor(0, 1);
lcd.print(F("Blok "));
lcd.print(nummer);
lcd.print(F(": Vrij"));

break;
case 'B': //blok vrij
Serial.print(F("Blok: "));
Serial.print(nummer);
Serial.println(F(" : Bezet"));

//update het baanvak
setBaanvakStatus(nummer, BEZET);

lcd.home ();
lcd.setCursor(0, 1);
lcd.print(F("Blok "));
lcd.print(nummer);
lcd.print(F(": Bezet"));

break;
En tada, klaar voor 255 blokken...

Dit

Code: [Selecteer]

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

            locomotief (1, t, cw);

          }
Kan je nog van een koude kermis thuis laten komen als je meer dan 1 trein tegelijk wilt laten rijden. Dat kan nu namelijk niet... Met delay reageert de Arduino even nergens op, dus ook niet op een noodstop bijvoorbeeld. Ook kan je geen twee treinen tegelijk laten optrekken enz. Maar goed, misschien staat dit nog op de planning? Is namelijk niet de eerste keer dat ik het je laat weten 

Zelfde voor de wissels

Code: [Selecteer]

  if (wrichting == 0) {

    Serial.println("wissel 1 rechtdoor");

    digitalWrite(wissel1rPin, HIGH);
    delay(750);
    digitalWrite(wissel1rPin, LOW);
Je wil de delay gewoon nooit gebruiken...

Voor de wissels heb ik in mijn hoofd wel iets moois zitten maar krijg het zo snel niet op papier  Aangezien het misschien ook handig is niet meer dan 1 wissel tegelijk aan te sturen zat ik te denken om een buffer van om te zetten wissels te maken en die dan af te lopen. En dan op te splitsen in een setWissel() en een updateWissel() functie waarbij de eerste ze alleen toevoegt aan de buffer en de laatste netjes met een millis() timer ze een voor een langs loopt....

Maar goed, als er niet onwijs veel wissels zijn kan je ook een millis per wissel doen:

Code: [Selecteer]

unsigned int wisselMillis[sizeof(WisselAfbuigenPin)]; //Wanneer is de bekrachtiging begonnen?
bool wisselActive[sizeof(WisselAfbuigenPin)]; //Is de wissel nu bekrachtigd?

const unsigned int WisselInterval = 750; //Tijd in ms om wissel te bekrachtigen. Lijkt me al best lang

void setWissel(byte nummer, bool afbuigen){
digitalWrite(WisselRechtPin[nummer], !afbuigen);
digitalWrite(WisselAfbuigenPin[nummer], afbuigen);

wisselActive[nummer] = true;
wisselMillis[nummer] = millis();
}

void updateWissel(){
unsigned int currentMillis = millis();

for(byte i = 0; i < sizeof(WisselAfbuigenPin); i++){
if(wisselActive[i]){
if(currentMillis - wisselMillis[i] >= WisselInterval){
digitalWrite(WisselRechtPin[i], LOW);
digitalWrite(WisselAfbuigenPin[i], LOW);
wisselActive[i] = false;
}
}
}
}

Waarbij je dus updateWissel() in je loop moet aanroepen.

En om alles flot te houden, zet je baut rate gewoon lekker hoog 115200 zou prima moeten werken.


Okay, weer mijn excuses voor zoveel kritiek  Maar ik probeer het hiermee echt makkelijker te maken voor jou! En mja, dit schrijven heeft me ook meer dan een uur gekost.... Dus ik hoop dat je het wel nuttig vindt 


Timo

[smits66]

Hoi Timo

Bedankt voor je input, ik waardeer dat ten zeerste.

Even een korte reactie, is vanavond clubavond, morgen zal ik een uitgebreide reactie geven.

I²C

Dat klopt, dat is nog steeds de bedoeling, volgens mij geeft het geen problemen om een lcd en/of andere i²C tegelijk te gebruiken.
Er komt maar een lcd in het systeem.

Een master voor het system en de rest zijn slave units.

De code voor de master zal er ongeveer zo uitzien.

Code: [Selecteer]

//i2c Master Code(UNO SMD)

#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

void setup()
{
    pinMode(8,OUTPUT);
    pinMode(9,OUTPUT);
 
  Serial.begin(9600);
  Serial.println("Arduino test programma : I2C communicatie");
  Wire.begin();
  delay(1000);
}
void loop()
{     
      Wire.beginTransmission(5);
      Wire.write('H');
      Serial.println("zend een H naar de Slave");
      digitalWrite(8,HIGH);
      digitalWrite(9,LOW);
      Wire.endTransmission();
     
      delay(2000);
     
      Wire.beginTransmission(5);
      Wire.write('L');
      Serial.println("zend een L naar de Slave");
      digitalWrite(8,LOW);
      digitalWrite(9,HIGH);
      Wire.endTransmission();
     
      delay(2000);     
}
De code voor de slave zal er ongeveer zo uitzien.

Code: [Selecteer]

/i2c Slave Code(UNO 2)

#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

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

void loop()
{
}

void receiveEvent(int howMany)
{
  while(Wire.available())
  {
    char c = Wire.read();
   
    if(c == 'H')
    {
      digitalWrite(13,HIGH);
     
    }
    else if(c == 'L')
    {
      digitalWrite(13,LOW);
     
    }
  }
}


Relais.

De relais kunnen rechtstreeks zonder flyback diode aan een Arduino poort gehangen worden, of dat verstandig is weet ik niet , ik denk het eigenlijk niet, ik heb het al een paar keer gedaan , niet expres, maar de poorten zijn nog heel.

In deze opstelling zit er een kleine transistor(bc547) voor het relais, ik ben inderdaad een flyback diode vergeten te plaatsen, de poorten doen het in ieder geval nog steeds.

Voor grote schakel vermogens wil ik een solidstate relais gebruiken.

Het is met dit ontwerp wel de bedoeling om de wissels per paar te stellen.

Voor de wisselsturing  gebruik ik transistoren van het type BD681, BD136 enz.

Bluetooth.

Om een flexibel systeem te maken wil ik Bluetooth gebruiken( het blijft een terminal sturing met de pc, laptop, tablet, smartphone) voornamelijk word de pc ervoor gebruikt.

Barbone Arduino

Dat houd in een atmega 328 chip en crystal, voeding op een printplaat, no more, no less.
Aan een Arduino pro mini heb ik even niet aan gedacht, bedankt voor je input, barebone arduino is in dat geval inderdaad niet nodig.

Morgenavond geef ik op de rest een reactie, ik ben blij dat je me wil helpen, alvast bedankt daarvoor.

Zowel de hardware en de software zijn een proefopstelling om het een en het ander te kunnen uittesten, zonder ingewikkelde programma's en elektronica, alles is op deze manier snel te realiseren en aan te passen.

Mvg Paul

[Timo]

Hoi Paul,

Ook even snel antwoord van mij dan.

De relais zouden misschien wel direct aan de Arduino kunnen als ze weinig stroom nodig hebben. Kan type niet lezen dus kan het niet opzoeken. De fly back diode is alleen wel echt een must (tenzij deze al ingebouwd zit maar dat is zelfde zo). Bij het afschakelen ontstaat er even een hoge spanning over de spoel en die voer je nu af via de input clamping diodes van de ATmega. Daar zijn ze alleen niet echt op gebouwd dus daar wil je niet op vertrouwen. Bij gebruik van een transistor is het ook aan te raden omdat je de transistor ook erg op de proef stelt zo.

I2C met één display aan de master is geen probleem. Ik zat meer te denken, het is wel een probleem als je aan een slave ook een display wilt hangen. Dat kan niet zo makkelijk. Dit omdat het display al een slave is en alleen aangestuurd kan worden door een I2C master. Zou je dit willen zou je naar een multi master opstelling moeten gaan en gat lijkt me in dit geval echt te node-loos  ingewikkeld.... (Node  sorry voor de woordgrap)

Maar ik zou als ik jou was nu al beginnen met het opsplitsen van master en slave programma. Het is extra werk om dat later pas te doen. Ook al bouw je nu eerst een systeem met maar één slave.

Bluetooth, mja, voor de tablet misschien handig. Maar ik persoonlijk (en dat kan je natuurlijk zelf anders willen) zou het pas later inbouwen, eerst het Serial voor elkaar krijgen. Het moet ook goed te doen zijn later in te bouwen omdat je alleen de master hoeft aan te passen. En volgens mij laten de meeste Bluetooth modules zich al redelijk makkelijk als serial bridge banaderen dus dat is dan makkelijk.

Barebone, dan had ik het inderdaad goed ingeschat. En ja, voor het bedrag van een Arduino Pro Mini kan ik het zelf echt niet meer barebone opbouwen. Vandaar dat ik graag gewoon een print maak waarop je een Arduino Pro Mini kan prikken.

En tja, voor het snel realiseren is het handig om de code iets flexibeler te maken. het scheelt immers veel tijd als je niet hele blokken code moet toevoegen voor iedere wissel enz die je toe wilt voegen... 


Timo

[smits66]

Hoi Timo,

Het lukte vanavond niet om nog uitgebreid te reageren op je post.

Ik ben vanavond bezig geweest met het opruimen van mijn ontwikkel/hobby plekje, er slingerde wat Arduino's uno, nano's, mega div. shields steekboardjes, doorverbind draadjes, elektronika onderdelen enz,   je begrijp het al ik ben er langer mee bezig geweest om uit te zoeken dan ik dacht.

Even het volgende:

De treinsturing waar ik nu mee bezig ben, is niet meer dan een terminal besturing van de modelbaan, er komen niet meer functies bij per Arduino, het is nu meer ontwikkeld als een Blokkaart met locomotief sturing per blok, als extra kun je er bv wissels mee schakelen, daar wil ik een aparte sturing voor maken.

Dit ontwerp is bedoeld om bv. bij een uitwijk spoor ingezet te worden compleet met seinen, of een klein station, door het aanpassen van de functies kun je de configuratie van deze blokmodule veranderen.

Er zal dan ook niet meer dan 1 trein per blok rijden, bv. blok 1 vrij trein stopt op spoor 1, blok 1 word bezet gemeld en spanningsloos gemaakt, op spoor 2 kan de doorgaande trein gewoon doorrijden,of de trein van links of recht komt maakt dan niet uit, vandaar de relais in het ontwerp.

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

Het ontwerp is in de basis, gebaseerd op het van Mekeren bloksysteem, en heeft misschien ook wel wat weg van Dinamo.

Dit moet dan ook een Arduino blok-gestuurde modelbaan-sturing  worden.

Het Programma per Arduino (pro) uno,  is niet erg uitgebreid, een klein programma is voldoende.

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.

Kort samen gevat , dit ontwerp is voor een blok-gestuurde Arduino modelbaan-sturing.

Morgen (hoop ik ) een verdere reactie op jou post te geven.

Mvg Paul