S88 en DCC wisseldecoders met Arduino

[1op160]

Ik ben opzoek naar een manier om een lus S88 modules uit te lezen met een Arduino of ESP32.
Iemand die hier ervaring mee heeft of mee kan helpen?

Ook wil ik mijn wissels gaan schakelen met servos.
Ik zag al ergens een manier om 16 servos op 1 Arduino Nano aan te sluiten.
Misschien hier al iemand die dit doet?

[bask185]

Ik ben opzoek naar een manier om een lus S88 modules uit te lezen met een Arduino of ESP32.

Vraag: als je met arduino's S88 bus wilt uitlezen, waarom dan ook niet meteen je s88 ook uitvoeren met een arduino? of nog beter, daadwerkelijk schuifregister ICs zoals de 74hc165. Sommige S88 modules zoals o.a. die van Huib hebben ook echte schuifregister IC's

De S88 'bus' is niks meer dan een reeks schuifregisters. Rudy B heeft een arduino geprogrammeerd om als S88 module te werken. Maar je kan ook S88 vergeten, zelf je modules fabrieken met die 74hc165 chips en dan kan je met de arduino shiftIn() functie al je schuifregister informatie ophalen.

Als je al S88 modules heb ingekocht, kan je ook eerst proberen om met de shiftIn() functie de bits in te klokken. Je hebt kans dat dat al werkt. De timing van de functie komt volgens mij niet overeen met de s88 standaard, maar aangezien je zelf de kloklijn bedient vanuit een arduino, maakt dat in alle waarschijnlijkheid niet eens uit.

En anders kunnen we wat code bedenken waarbij die timing wel klopt  .

Behalve klakkeloos inklokken, is het heel misschien ook nog nodig om de ingelezen data te filteren om eventuele spookmeldingen er uit te vissen. Maar first things first. Test shiftIn() en get your bits!!.

Informatie over de daadwerkelijk s88 timing en pinout ed kan je online vinden.


Wat servo's betreft. Een arduino nano of uno kan met de arduino library 12 servo's aansturen. Een mega iets van veel meer dan dat. Je kan ook een PCA9685 breakout board kopen, die kan 16 servo's aansturen met grotere nauwkeurigheid (niet nodig).

Zoveel servo's per unit is meestal volkomen puntloos omdat je servo kabels kort wilt houden en de kans dat je daadwerkelijk 16 servo's op 1 ding wilt hebben is niet groot. Hoewel ik een N-spoor emplacement nog wel wil geloven. (ik raad overigens MG90 servo's aan, die hebben metalen tandwielen. Een SG90 kan zichzelf vernietigen)

In onderstaande link, heb ik een project waarmee je via Xnet zelf een schakelpaneel kan maken. Dat is totaal niet relevant voor deze vraag. Echter in dat filmpje kan je ook een klein DCC printje zien in dezelfde fashion als dat kleine Xnet printje. In de achtergrond kan je ook een 'IO base' voor een arduino nano vinden.
https://forum.beneluxspoor.net/index.php?topic=106496.msg3222378634#msg3222378634

De meest goedkope, stom simpele en makkelijke oplossing om servo's met een arduino aan te sturen dmv DCC waarbij je heeeel weing hoeft te solderen, is een zo'n IO base + arduino nano + een van mijn DCC shields. En je hebt ook zelf een 5V voeding toe te voegen. Kan ook een buckconverter zijn.

Dit is zo'n nano IO base. Je kan hier direct servo en mijn DCC print op inpluggen.


Software moet ik nog fixen, maar dat is al voor ~90% klaar (moet eigenlijk alleen nog testen). Ik maak ook gebruik van DCC libraries die je op internet vindt.

Het generale idee van die software is dat je een config knopje heb waarmee je net als bij een digikeijs module een setje adressen kan toekennen. Tevens kan je met loc adres 9999 de servo standen inleren en finetunen met de rijregelknop van een handregelaar/app/computer programma. <- gebruikersvriendelijk

Qua commerciele producten raad ik de esu switchpilot 3 aan. Die kost rond de 65€ en kan 8 servo's aansturen. Het is wel minder leuk dan zelf te kutteren met arduino's natuurlijk 

Ik wil komend weekend een filmpje maken met dat DCC printje en dan maak ik een guide van begin tot eind hoe je van niks naar een werkende arduino dcc servo decoder gaat.

Mvg,

Bas

[meino]

Een stukje code (Arduino schets) dat de bezetmelders op de S88 zet. In principe kunnen meerdere Arduino's in een daisy chain gezet worden, maar dat heb ik hier niet gedaan.

Code: [Selecteer]

/*
  A program to accept occupancy detector status from the Canbus
  and set the proper bit in the S88 shift register

  Copyright (C) Meino de Graaf, all rights reserved

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
  as published by the Free Software Foundation, version 2
  of the License.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  email: meino@innerside.demon.nl
*/
#include <CanBus.h>

#define DEBUG 0

//
//  Pin layout is for the Arduino Uno
//

// Connections for S88 bus:
//
// s88 pin 1 Data - Arduino pin 8 = Data_Out to Oommand Station, or pin 7 (Data in) from the previous Arduino in the chain
// s88 pin 2 GND  - Arduino GND
// s88 pin 3 Clock - Arduino pin 2, interrupt 0
// s88 pin 4 PS - Arduino pin 3, interrupt 1
// S88 pin 5 Reset (not used)
// s88 pin 6 V+ - Arduino 5V (not used)
//

// Connections for S88N (RJ45)
//
// RJ45 pin 1 12V/5V   (not used)
// RJ45 pin 2 Data  - Arduino pin 8 = Data_Out to Oommand Station, or pin 7 (Data in) from the previous Arduino in the chain
// RJ45 pin 3 GND   - Arduino GND
// RJ45 pin 4 Clock - Arduino pin 2, interrupt 0
// RJ45 pin 5 GND   - Arduino GND
// RJ45 pin 6 PS    - Arduino pin 3, interrupt 1
// RJ45 pin 7 Reset    (not used)
// RJ45 pin 8 Raildata (not used)
//


#define S88_DATAOUT_PIN     8
#define S88_DATAIN_PIN      7
#define S88_CLOCK_PIN       2
#define S88_PS_PIN          3

#define S88_CLOCK_INTERRUPT 0
#define S88_PS_INTERRUPT    1

const int nrOfOccDetectors = 6 * 16;

#if (DEBUG)
typedef struct
{
  char  *description;
} CDT;   // Structure describing an attached Current Detector

//
//  We have implemented here 5 banks of S88 occupancy detectors
//
volatile CDT occDetector[nrOfOccDetectors] = {
  {"S4"},                     //  1.01
  {"S6-2"},                   //  1.02
  {"S11-1"},                  //  1.03
  {"S5"},                     //  1.04
  {"S19A (W4+W5)"},           //  1.05
  {"S11-2"},                  //  1.06
  {"S8-1"},                   //  1.07
  {"S6-1"},                   //  1.08
  {"S1"},                     //  1.09
  {"S2-1"},                   //  1.10
  {"S3A"},                    //  1.11
  {"W8+W9"},                  //  1.12
  {"S8"},                     //  1.13
  {"S9-1"},                   //  1.14
  {"S10A-1"},                 //  1.15
  {"S7A"},                    //  1.16
  {"S5-1"},                   //  2.01
  {"S1-1"},                   //  2.02
  {"S12-1 (W6)"},             //  2.03
  {"S12-2 (W7)"},             //  2.04
  {"S19-2"},                  //  2.05
  {"S19-1"},                  //  2.06
  {"S2-1 (W12)"},             //  2.07
  {"S9-2"},                   //  2.08
  {"S4A"},                    //  2.09
  {"S10A-2"},                 //  2.10
  {"S3A-1"},                  //  2.11
  {"S4-1"},                   //  2.12
  {"S7A-1"},                  //  2.13
  {"W1"},                     //  2.14
  {"W2+W3"},                  //  2.15
  {"W10+W11"},                //  2.16
  {"S10B-1"},                 //  3.01
  {"S10B-2"},                 //  3.02
  {"S10C-1"},                 //  3.03
  {"S10C-2"},                 //  3.04
  {"S10D-1"},                 //  3.05
  {"S10D-2"},                 //  3.06
  {"S7B+S7C (LSe)"},          //  3.07
  {"S3B+S3C (LSe)"},          //  3.08
  {"S3B+S3C (LSb)"},          //  3.09
  {"S7B+S7C (LSb)"},          //  3.10
  {"not used"},               //  3.11
  {"not used"},               //  3.12
  {"not used"},               //  3.13
  {"not used"},               //  3.14
  {"not used"},               //  3.15
  {"not used"},               //  3.16
  {"TO-01"},                  //  4.01
  {"TO-02"},                  //  4.02
  {"TO-03"},                  //  4.03
  {"TO-04"},                  //  4.04
  {"TO-05"},                  //  4.05
  {"TO-06"},                  //  4.06
  {"TO-07"},                  //  4.07
  {"TO-08"},                  //  4.08
  {"TO-09"},                  //  4.09
  {"TO-10"},                  //  4.10
  {"TO-11"},                  //  4.11
  {"TO-12"},                  //  4.12
  {"TO-13"},                  //  4.13
  {"TO-14"},                  //  4.14
  {"TO-15"},                  //  4.15
  {"TO-16"},                  //  4.16
  {"TO-17"},                  //  5.01
  {"TO-18"},                  //  5.02
  {"TO-19"},                  //  5.03
  {"TO-20"},                  //  5.04
  {"TO-21"},                  //  5.05
  {"TO-22"},                  //  5.06
  {"TO-23"},                  //  5.07
  {"TO-24"},                  //  5.08
  {"TO-25"},                  //  5.09
  {"TO-26"},                  //  5.10
  {"not used"},               //  5.11
  {"not used"},               //  5.12
  {"not used"},               //  5.13
  {"not used"},               //  5.14
  {"not used"},               //  5.15
  {"not used"},               //  5.16
  {"B-14"},                   //  6.01
  {"B-15"},                   //  6.02
  {"B-16"},                   //  6.03
  {"B-12"},                   //  6.04
  {"W-4"},                    //  6.05
  {"W-5"},                    //  6.06
  {"W-6"},                    //  6.07
  {"W-7"},                    //  6.08
  {"W-8"},                    //  6.09
  {"W-8"},                    //  6.10
  {"not used"},               //  6.11
  {"not used"},               //  6.12
  {"not used"},               //  6.13
  {"not used"},               //  6.14
  {"not used"},               //  6.15
  {"not used"}                //  6.16
};
#endif //DEBUG

volatile byte pendingStates[nrOfOccDetectors];
volatile byte dataRegister[nrOfOccDetectors];
volatile long clockTicks = 0;

CanBus *canBus;

void setup()
{
#if (DEBUG || CANBUS_DEBUG || CANBUS_DEBUG1)
  Serial.begin(115200);
  while (!Serial);
  Serial.println("Starting S88 interface");
  Serial.flush();
#endif //DEBUG

  //
  //  Intialize the dataRegister
  //
  memset(pendingStates,0,nrOfOccDetectors);
  memset(dataRegister,0,nrOfOccDetectors);

#if (DEBUG)
  Serial.println("Setup 1");
  Serial.flush();
#endif

  //
  //  Setup the input/output pins and the interrupts for the S88 communication
  //
  //pinMode(S88_CLOCK_PIN, INPUT_PULLUP);
  //pinMode(S88_PS_PIN, INPUT_PULLUP);
  pinMode(S88_DATAIN_PIN, INPUT_PULLUP);
  pinMode(S88_DATAOUT_PIN, OUTPUT);
  digitalWrite(S88_DATAOUT_PIN, LOW);
  attachInterrupt(S88_CLOCK_INTERRUPT, clock_Int, RISING);
  attachInterrupt(S88_PS_INTERRUPT, PS_Int, RISING);

#if (DEBUG)
  Serial.println("Setup 2");
  Serial.flush();
#endif

  //
  //  Setup and start the CanBus communication
  //
  canBus = new CanBus(S88_INTERFACE_ID, nullptr, new Mcp2515(10)); // Only a receiver
  canBus->setMsgReceiver(OCC_DT, occDtReceiver);
#if (DEBUG)
  Serial.println("Setup 3");
  Serial.flush();
#endif
  canBus->begin();

#if (DEBUG)
  Serial.println("Setup done");
  Serial.flush();
#endif
}

void loop()
{
  //
  //  Are there messages on the CanBus?
  //
  canBus->heartBeat();
}

//
//  A function that executes whenever a message is received from the Canbus
//  It's purpose is to analyze the received event Occupancy detector and
//  update the proper element in the semaphore table or turnout table.
//
void occDtReceiver(unsigned char aMsgLen, OCC_DT_MSG *msgData)
{
  if (msgData->address < nrOfOccDetectors)
  { 
    pendingStates[msgData->address] = msgData->state;
   
#if (DEBUG)
    Serial.print("[occDtReceiver] ");
    Serial.print("occId: ");
    Serial.print(occDetector[msgData->address].description);
    Serial.print(" adress: ");
    Serial.print(msgData->address);
    Serial.print(" bank: ");
    Serial.print(((msgData->address)/16)+1);
    Serial.print(" detector: ");
    Serial.print(((msgData->address)%16)+1);
    Serial.print(", occState: ");
    if (pendingStates[msgData->address] > 0)
      Serial.println("OCCUPIED");
    else
      Serial.println("FREE");
#endif //DEBUG
  }
  else
  {
#if (DEBUG)
    Serial.print("[occDtReceiver] invalid occId: ");
    Serial.println(msgData->address);
#endif   
  }
}

void PS_Int()
{
  //
  //  Load the detector states in the data register
  //
  memcpy(dataRegister,pendingStates,nrOfOccDetectors);

  clockTicks = 0;     //  reset index in the dataRegister
}

//
//  Set the state of the next detector on the output pin
//
void clock_Int()
{
  digitalWrite(S88_DATAOUT_PIN, dataRegister[clockTicks]);
  //
  //  If we are chained to additional detectors, reads a bit from the chain and
  //  store it in the current, just written, position
  //
  //  Delay makes reading output signal from next Arduino in chain more reliable.
  //delayMicroseconds(2);
  //dataRegister[clockTicks]=digitalRead(S88_DATAIN_PIN);
  clockTicks = (clockTicks + 1) % nrOfOccDetectors; // Goto next bit in dataRegister
}
Groet Meino

[bask185]

Ik had per toeval nog een plaatje van mijn DCC contraption op mijn werk PC staan. Zeer minimalistisch 

[1op160]

Wow, Bas en Meino,   

Bedankt voor jullie uitgebreide antwoorden. 

Ze overrompelen mij een beetje met termen waarvan ik wel ongeveer begrijp wat er staat en hoe het in theorie in elkaar zit.
Maar (foutje van mijn kant dat ik dat niet vooraf heb verteld) mijn kennis op het gebied van elektronica is "beperkt".
Van beroep ben ik programmeur maar ben eigenlijk nooit bezig met hardware.
Ik programmeer ook niet in java of C. Dus code voor Arduino's is voor mij geen moedertaal.
Al kan ik het prima lezen en aanpassen natuurlijk.

Ik ben er wel van overtuigd dat ik de juiste mensen gevonden heb. 

Misschien moet ik iets meer informatie geven waarom ik deze vraag heb gesteld.

Het lijkt mij mooi om zelf software te maken om de modelbaan mee aan te sturen.
Ja, ik weet dat er al heel veel software is. Maar ieder zijn hobby, het lijkt mij mooi om ook dit deel van de hobby zelf te maken.

Daarnaast ben ik van mening dat wanneer de software slimmer is er ook minder hardware nodig is.
En software en hardware moeten volgens mij ook veel makkelijker kunnen zijn voor gebruikers die niet willen of kunnen nerden.
Er zijn genoeg mensen die niet zelf een Adruino sketch gaan schrijven of zelf in een sketch aanpassingen voor instellingen gaan doen.
 
Misschien is het helemaal niet haalbaar. Maar met wat hulp  lijkt het mij mooi om componentjes te maken die iedereen voor een paar euro kan kopen (of namaken voor de nerds). Daar een standaard Arduino Nano (of iets vergelijkbaars) op kan klikken. En daarna via een simpele wizard kan installeren zonder ingewikkelde stappen. Next, next, next, Finish. Decoder of terugmelder klaar.
En daarna moet de besturingssoftware maar slim genoeg zijn.

Misschien is dit onhaalbaar en dan... (of tot die tijd...) wil ik proberen om met Arduino's te gaan nerden en deze te laten werken als "standaard" decoders.

Bas, dat laatste printje wat je liet zien.
Als ik het goed begrijp komt daar DCC in... en kan daarna de Arduino op de signaal pin de DCC lezen.
De PCA9685 waar je het over had is inderdaad wat ik zelf ook gevonden had om 16 servo's mee te kunnen bedienen.
(goed punt of je dat ook echt moet willen, maar het kan).

Nu lijkt het mij mooi om bijvoorbeeld via PCBWay 1 printje te maken die jouw DCC-in (noem ik het maar even) combineert met de PCA9685.
En dan met insteek headers waar je een Arduino Nano op kan prikken. En mocht dat nodig zijn ook al met buckconverter erop.
Gewoon 1 print waar alleen nog de Nano op hoeft.
Hoe haalbaar denk je dat dit is?

Of heb ik helemaal jouw verhaal niet goed begrepen heb en is dit er al?
 
Iets vergelijkbaars zou ik uiteindelijk ook als bezetmelders willen... maar goed... 1 ding tegelijk. 

[Joz]

Gewoon 1 print waar alleen nog de Nano op hoeft.
Hoe haalbaar denk je dat dit is?

Dat is heel goed haalbaar. Maar zoals eerder gemeld is het het beste om je servo's zo dicht mogelijk bij je decoder te houden. Ik gebruik zelf maximaal 1 verlengkabeltje van zo'n 30cm, en in dat geval heb je genoeg aan zo'n 10 servo's per decoder. Dat kan één Arduino Nano makkelijk aan, zeker als je in je sketch bijvoorbeeld een queue inbouwt waarmee er maar één servo tegelijk om kan gaan en daarna afgeschakeld wordt.
Daarom zou ik die PCA9685 gewoon helemaal vergeten, een extra Nano zal niet duurder zijn?

Mijn oplossing ziet er zo uit: DCC aanluiting, 10 servo-aansluitmogelijkheden, 5V voedingsaansluiting en 3 knopjes waarmee de servo-standen eenmalig ingesteld kunnen worden. Een volgende versie heeft de servo-aansluitingen per 3 en 4 met wat tussenruimte gegroepeerd, omdat 10 servo-stekkertjes strak naast elkaar niet echt fijn is.

[bask185]

Ik heb eerder een ander shield gemaakt waaronder ik een buck converter kon solderen. Zo'n shield prik je dan tussen de base en de nano. Hij was alleen voor Rs485 bestemd. Het is iets minder soldeer werk dan bovenstaande oplossing en je hebt een onboard buckconverter + gelijkrichter. Je kan dan het geheel ook meteen voeden vanuit de DCC bus.

Het grootste voordeel is dat je maar 2 draden hoeft aan te sluiten en je hoeft niet al die headers te solderen daar je gewoon dat IO shield kan blijven gebruiken. Dit is mijn idee van 'minimalisme'.


Dan heb je wel zo'n leuk torentje  Dat kleine zwarte ding dat is een 3A buck converter van <1€ en die zit onder dat shield (hoewel ik die 3A niet helemaal geloof, maar wie weet  )

Al kan ik het prima lezen en aanpassen natuurlijk.

Dit alleen al is 

Nu lijkt het mij mooi om bijvoorbeeld via PCBWay 1 printje te maken die jouw DCC-in (noem ik het maar even) combineert met de PCA9685.
En dan met insteek headers waar je een Arduino Nano op kan prikken. En mocht dat nodig zijn ook al met buckconverter erop.

Die buckconverters zijn makkelijk, het zijn 4 soldeer contacten en je soldeert zo'n ding plat tegen een print. Een lineare regulator is veel meer arbeid. Bovendien raken die snel over verhit met servo's. Buck = must have. Ik zou die PCA echt vergeten, echt onnodig. 12 servo's direct op de arduino werkt prima.

En daarna via een simpele wizard kan installeren zonder ingewikkelde stappen

Het makkelijkste wat ik in dit opzicht ooit bereikt heb, was een zipje samenstellen waarin o.a. avrdude.exe zit (het programma waarmee je .hex bestanden in een arduino flasht) en een .hex (= programma voor arduino) en een .bat script. De .hex in de arduino krijgen was zo simpel als dubbelklikken op upload.bat.

Ik moest alleen nog iets toevoegen dat je de comport kan selecteren (die was hard-gecodeerd in het .bat script). Maar ik was niet zo goed in de bat-nees taal 

Dit werkt op elke windows PC en je hoeft niks te installeren. Slechts zipje downloaden, arduino in pluggen, klikken op upload.bat en klaar is Kees programmeren.


Wat terugmelders betreft. Je bent misschien wel of niet bekend met okkies, stroom detectie printjes die je op een arduino kan steken. Okkies hebben 1 nadeel, het is veel soldeer werk. Solderen is ruk, alleen doen indien nodig 


Dit printje is een Mosfet versterker voor spoelwissels. Alweer totaal irrelevant voor deze vraag  . Dit printje heb ik laten bestucken door JLCPCB. Mijn punt: een bestuckte okkie-like print, is een erg goed idee en zeer makkelijk uitvoerbaar.


Ik heb zelf ook een 'filosofie' omtrent spoorse zaken. Ik geloof in een 1 bus systeem zoals BiDib of loconet (B) waarbij je schakeldecoders en terugmelders op dezelfde bus kan aansluiten. DCC is dan beperkt tot het spoor en je treintjes. Je kan bijvoorbeeld met Rs485 (waar ik al shields voor heb) ook zoiets maken, maar dat is ietsjes meer werk  .

Voor die mosfet print had ik deze loconet controller print gemaakt. Mijn idee was een viertal printen, 1 universele loconet controller, 1 mosfet print, 1 servo print en een stroomdetectie print. Alle drie de printen zouden op dezelfde controller passen. En je kan bijvoorbeeld een weerstandsdeler gebruiken zodat de controller kan herkennen op welk van de drie printen hij aangesloten zit. Dan heb je slechts 1 enkel programma nodig wat spoelen, servo's of terugmelders kan aansturen.

Daar een standaard Arduino Nano (of iets vergelijkbaars) op kan klikken

Dit idee had ik dus helemaal uitgewerkt, maar je zit met 1 ding en dat is: die headers moeten gesoldeerd worden. Tenzij je dat kan uitbesteden, zou ik hier eigenlijk niet aan beginnen. Het was daarom dat ik die minimalistische printjes heb gemaakt. Als ik alleen al die shield headers voor een Nano moet solderen, heb ik eigenlijk al geen zin meer desonanks het maar 3 minuten werk is.

Ik heb deze week een handcontroller print besteld met: atmega328 + crystal,  Ch340 circuit + micro USB connector en loconet circuit. Dat ding is dus een soort arduino en dan met loconet interface. DCC circuit stelt ook geen ruk voor duzzz

How 'bout een controller met zowel loconet als DCC (voor ieder wat wils) waarmee je dus spoelen, relais, terugmelders, servo's en schakelaars kan aansturen? Ik kan die servo connectors ook laten bestucken met 2x3 SMD headers. Dus alles bestuckt behalve de screw terminals. 1 programma voor alles (minder werk dan het lijkt). Status ledje, config knopje.. USB interface eventueel? Anyways dat zijn mijn gedachtes.

Dus... maar beginnen met een nano shieldje? 

Mvg,

Bas

[1op160]

Mijn oplossing ziet er zo uit: DCC aanluiting, 10 servo-aansluitmogelijkheden, 5V voedingsaansluiting en 3 knopjes waarmee de servo-standen eenmalig ingesteld kunnen worden. Een volgende versie heeft de servo-aansluitingen per 3 en 4 met wat tussenruimte gegroepeerd, omdat 10 servo-stekkertjes strak naast elkaar niet echt fijn is.

Hoi Jozz, dit lijkt wat hardware betreft erg prettig.
Heb je deze print zelf ontworpen? Of is deze ergens te koop?
En heb je daar ook een sketch bij voor?

[1op160]

Bas je antwoord is weer op level "eindbaas"... 
In grote lijnen kan ik je volgen.

Die eerste toren die je laat zien is op zich geen gekke oplossing.

Het grootste voordeel is dat je maar 2 draden hoeft aan te sluiten en je hoeft niet al die headers te solderen daar je gewoon dat IO shield kan blijven gebruiken. Dit is mijn idee van 'minimalisme'.

Ik zou uiteindelijk de voorkeur hebben aan iets wat bijvoorbeeld via PCBWay besteld kan worden en al helemaal gesoldeerd is.    (volgens mij kan je daar prints met componenten gesoldeerd bestellen).

Ik zou die PCA echt vergeten, echt onnodig. 12 servo's direct op de arduino werkt prima.

Ja, 12 is ook meer dan genoeg.

Het makkelijkste wat ik in dit opzicht ooit bereikt heb, was een zipje samenstellen waarin o.a. avrdude.exe zit (het programma waarmee je .hex bestanden in een arduino flasht) en een .hex (= programma voor arduino) en een .bat script. De .hex in de arduino krijgen was zo simpel als dubbelklikken op upload.bat.

Dit zou al een super mooie tussenoplossing zijn om het voor veel mensen makkelijker te maken.
Voor mij zou het niet erg lastig zijn om hier een wizard voor te maken die ook de comport kan vinden en die laatste stappen ook makkelijk maakt.

Ik heb zelf ook een 'filosofie' omtrent spoorse zaken. Ik geloof in een 1 bus systeem zoals BiDib of loconet (B) waarbij je schakeldecoders en terugmelders op dezelfde bus kan aansluiten.

Dit zou geweldig zijn... schakeldecoders en terugmelders, alles hetzelfde... en dan zou mijn voorkeur uitgaan naar het TCP protocol.
Dan werkt elke schakeldecoder en terugmelder als een PC in een LAN netwerk.
Kan ook met netwerkkabels aan elkaar verbonden worden... helemaal makkelijk en in alle lengtes verkrijgbaar.

[bask185]

Loconet (en tevens BiDib) is praktisch een soort LAN. Alleen zonder het router gedeelte. Elk apparaat kan vrijwillig of gevraagd berichten op de bus zetten. En alle apparaten luisteren naar de berichten en kunnen iets doen als ze een bericht interessant vinden. Er zit ook collision detection/avoiding in gebakken.

(XpressNet werkt dan met RS485 en dat werk op basis van pollen. XpressNet kent echter geen terugmelders en je kan nooit meer aansluiten dan 31 apparaten, deze bus is ook echt ontworpen voor handregelaars en schakelpaneel dingetjes.)

Wat misschien iets makkelijk is, is om CAN bus gebruiken, Je kan namelijk kant en klare can bus shields voor arduino's kopen. Meino heeft dat gedaan voor Kranenberg. Je kan even googelen naar 'canbus komt naar kranenberg'. Of je PB't Meino

Kan ook met netwerkkabels aan elkaar verbonden worden... helemaal makkelijk en in alle lengtes verkrijgbaar.

Die zes polige platte telefoon kabels met RJ12 connectoren (XpressNet & Loconet) vind ik zelf makkelijk. Die kan je op maat knippen en connectoren er op krimpen. Dat kan welliswaar ook met die RJ45 dingen, maar die aders goed in die jacks krijgen, is wat lastiger. Nu zijn die Kant en klaar  Rj45 kabels ook niet echt duur ofzo, dus zeker geen slecht idee  .
Ik meen dat de CAN bus aansluiting op een Z21 en ook op een ZIMO centrale ook met RJ45 is uitgevoerd. En BiDib en S88n terugmelders zijn ook met RJ45 uitgevoerd.

Ik zou uiteindelijk de voorkeur hebben aan iets wat bijvoorbeeld via PCBWay besteld kan worden en al helemaal gesoldeerd is.    (volgens mij kan je daar prints met componenten gesoldeerd bestellen).

Volgens mij kunnen die dat idd doen. Zelf laat ik dus dingen bij jlcpcb bestucken. Ik heb ook een filmpje hier op BNLS staan hoe je daar een bestuckt ding moet bestellen, maar dan moet je wel met KiCad overweg kunnen....

Alleen niet alles kan ook bestuckt worden, wel veel. Die lange shield headers bijvoorbeeld is volgens mij niet een van die dingen. Volgens mij kan je die bedrijven ook dit handwerk voor je laten doen. Maar als je toch laat bestucken, is het imo dus beter om meteen die atmega328 en crystal ook meteen te bestucken zodat je geen shield toren hoeft te maken.

Je zit ook aan kosten en aantallen gebonden. (Hoewel het nog steeds goedkoper om 5 loconet terugmelders te laten bestucken dan er ook maar 1 te kopen). Een print aan 2 kanten bestucken kost meer, en dat handwerk kost natuurlijk ook meer. En zoals je zelf ook kan bedenken, meer printen -> lagere kosten per print. Bij JLCPCB hebben ze ook basic en extendend componenten. Voor elke niet extended component betaal je per batch 3$ meer. Als je al 5 extended componenten heb, ben je alleen al 15$ aan extra fees kwijt. Voor 5 printen niet echt rendabel (€3,- per print extra), voor 50 printen geen big deal (€0,30 per print)

In de basic stock list zit o.a. de atmega328, bijbehorend crystal en de 6n137 optocoupler (gebruiken we meestal voor DCC interface), 5v/3v3 spanningsregulators en alle condensators (geen elco's!), weerstanden en diodes die je nodig heb. Ze hebben ook een redelijke range aan buck converter ICs (nodig voor servo voeding tenzij je extern wilt voeden) in het basic assortiment.

Mvg,

Bas

[Joz]

Heb je deze print zelf ontworpen? Of is deze ergens te koop?
En heb je daar ook een sketch bij voor?

Deze print heb ik zelf ontworpen met EasyEDA (https://easyeda.com/nl Std Edition) Dit werkt erg prettig samen met JLCPCB, zeker als je eventueel ook met componenten wilt laten bestucken, dan is het vrij makkelijk om de componenten uit het "basic" assortiment te kiezen.

Een sketch heb ik ook, maar die is niet geschikt om te delen. Ik ben geen (nette) programmeur. Ik heb gewoon hier en daar wat stukjes code gekopieerd en samengeplakt 

Groeten, Jos

[bask185]

Ik heb even gauw een programma uit mijn mouw geschud.

Je kan deze sketch zelf niet compileren omdat je mijn servoSweep library en de Nmra DCC library nodig heb. De laatste kan je ook via de library manager in de arduino IDE installeren.

Die servo sweep library laat servo's geleidelijk 1 graad opschuiven per keer, zo kan je de draaisnelheid regelen. Je kan ook min en max posities opgeven, of je wilt dat de servo afschakelt na draaien (wenselijk voor wissels) en je kan optioneel een punstuk relais gebruiken die halverwege de slag omgaat.

Een zo simpel als mogelijk basis programma ziet er zo uit:
Probeer het eens te lezen, zou ik zeggen (men vertelt me dat ik duidelijke code klop  )

Code: [Selecteer]

#include "src/servoSweep.h"
#include "src/NmraDCC.h"

NmraDcc  Dcc ; // declare DCC object

const int myAddress = 20 ;
const int nServo    = 4 ;

ServoSweep servo[nServo] =              // declare  servo array with 4 elements
{
    ServoSweep( 3, 45, 135, 1, 10 ) ,// pin, min, max, turn off after turning, 10ms interval between degrees.
    ServoSweep( 4, 45, 135, 1, 10 ) ,
    ServoSweep( 5, 45, 135, 1, 10 ) ,
    ServoSweep( 6, 45, 135, 1, 10 /* relay pin optional*/) ,
} ;

void notifyDccAccTurnoutOutput( uint16_t Addr, uint8_t Direction, uint8_t OutputPower ) // called from DCC library when a turnout is set
{
    if( OutputPower == 0 ) return ;   // often you receive 2 times the same packet, this is ment to control the pulse length for coil drives. We don't use this.

    for( int i = 0 ; i < nServos ; i ++ )
    {
        if( Addr == myAddress + i )        // check if recveived address matches with any of my 4 servo's in this case 20-23
        {
            servo[i].setState( Direction ) ; // set one of the servo's in a direction
        }
    }
}

void setup()
{
    Dcc.pin(0, DCC_PIN, 1);
    Dcc.init( MAN_ID_DIY, 10, CV29_ACCESSORY_DECODER | CV29_OUTPUT_ADDRESS_MODE, 0 );

    for( int i = 0 ; i < nServos ; i ++ )
    {
        servo[i].begin() ;
    }
}

void loop()
{
    Dcc.process();

    for( int i = 0 ; i < nServos ; i ++ )
    {
        servo[i].sweep() ; // keep updating all servo motors
    }
}
Met een klein beetje meer werk, kunnen we dit allemaal configureerbaar maken. Dan kan je adres en servostanden inleren en dat slaan we dan op in EEPROM geheugen zodat de arduino bij uitzetten alles onthoudt. Ik moet thuis even kijken of ik dat programma nog kan vinden.

Mvg,

Bas

[1op160]

Deze print heb ik zelf ontworpen met EasyEDA (https://easyeda.com/nl Std Edition) Dit werkt erg prettig samen met JLCPCB, zeker als je eventueel ook met componenten wilt laten bestucken, dan is het vrij makkelijk om de componenten uit het "basic" assortiment te kiezen.

Een sketch heb ik ook, maar die is niet geschikt om te delen. Ik ben geen (nette) programmeur. Ik heb gewoon hier en daar wat stukjes code gekopieerd en samengeplakt 

Hoi Jos,

Ik wil uiteindelijk ook is gaan kijken naar het maken van prints.
Bedankt voor je tip.
Ik zocht vandaag naar een adapter van S88 naar RJ45.
Vragen ze gewoon 8 euro voor... Bizar.
Misschien dat ik dat is zelf ga proberen... Is ook niet heel complex.

Als je de sketch niet wilt delen moet je dat ook niet doen hoor.
Maar ik oordeel niet...    Bij het maken van code voor een Arduino ga ik ook zo te werk als jij omschrijft 

En Bas, ook bedankt voor je sketch...
Is prima leesbaar.
Ik raak hier wel geïnteresseerd door.

[meino]

Dit zou geweldig zijn... schakeldecoders en terugmelders, alles hetzelfde... en dan zou mijn voorkeur uitgaan naar het TCP protocol.
Dan werkt elke schakeldecoder en terugmelder als een PC in een LAN netwerk.
Kan ook met netwerkkabels aan elkaar verbonden worden... helemaal makkelijk en in alle lengtes verkrijgbaar.

Daar heb ik ooit ook aan gedacht, maar ik ben redelijk gepokt en gemazeld in het gebruik van TCP/IP en toen besloten dat er toch wel wat issues mee zijn. Je krijgt met adressering problemen te maken dus moet je ook zaken al DHCP of ARP implementeren. Ik ben bang dat de overhead toch iets te heftig is voor de huidige PIC's of Arduino's. Lees mijn Canbus draadje.

Groet Meino

[1op160]

Misschien een domme noob vraag.
Ik kwam dit printje tegen:
https://www.dccinterface.com/product/arduino-model-railway-dcc-interface/


On one side of the board is a 3 way connector

Pin 1 – + 5v – Connect this to a 5V source ( or the 5v pin on the Arduino )

Pin 2 – – GND – Connect this to the power source GND ( or the GND pin on the Arduino if you are using the Arduino as a power source )

Pin 3 – Ard – Connect this to an Arduino External Interrupt pin – the most commonly used pin is D2 – most libraries will use this pin.

The other 2 pin connector is the DCC input.


Zou ik wanneer pin 1 en 2 op een eigen power source zitten (dus niet op een Arduino)...
Meerdere Arduino's naar het DCC signaal op pin 3 kunnen laten "luisteren" ?