Zelfbouw decoders: vraag aan de loconet experts

[AP3737]

Dank voor de mail. Dat lijkt helder.

Heb je een logic analyzer? Dat was één van de beste aankopen die ik afgelopen jaren heb gedaan. Sinds ik dat ding heb, test ik daarmee al mijn software (en hardware) uitvoerig. Ik loop dan vaak tegen dingen aan die ik zo niet verwacht had.

Groet, Aiko

[bask185]

Ik heb er wel een, al 5 jaar. Hij zit nog steeds in het plastic  . De laatste keer dat ik er een gebruikte was iets van 8j terug om een I2C bus te monitoren. Ik dacht dat die van mij 5V tollerant was, ik durf daar niet zo maar een loconet of rs485 bus aan te hangen zonder extra elektronica.

[bask185]

Ik wilde al een lange tijd een paar van die dingen afmaken en op een plankje schroeven. Ik bedacht me nu iets vet slims, om gewoon geen plankje te pakken maar wat tape te gebruiken. If it works...

Ik heb afgelopen week de RJ12s er op gezet en vanavond een aangepast programma er in geschoten. De enige aanpassing is dat elke melder om de 10s alle 'states' toggle't van stand.



In dit fimpje zie je eerst 5 bezetmelders die exact tegelijk hun 16 statussen willen opsturen. Je ziet dat dat niet helemaal goed gaat. Halverwege het filmpje trek ik er 1 tussen uit en dan doen de overige 4 het wel goed.
<a href="https://www.youtube.com/v/b3mqEoR5gBw" target="_blank" class="new_win">https://www.youtube.com/v/b3mqEoR5gBw</a>

Nu zijn 5 x 16 melders die in dezelfde milliseconde (en misschien wel microseconde, het begin althans) verstuurd moeten worden ook wel erg uitzonderlijk. Als ik naar een normale iTrain baan kijk, dan heb ik er wel vertrouwen in dat de throughput meer dan toereikend is. En ik vind het toch netjes dat 4 nagenoeg identieke apparaten die op bijna exact hetzelfde tijdstip willen versturen er toch uit kunnen komen.

Wat code betreft, heb ik dit lapje wat ik continu aanroep

Code: [Selecteer]

void updateOccupancyStatus()
{
    static uint8 index ;

    if( io[index].newState != io[index].oldState )
    {
        LN_STATUS status ;
        uint8     type      = io[index].type ;
        uint8     address   = io[index].address ;
        uint8     state     = io[index].newState ;

        if( type == ACCESSORY ){status = LocoNet.requestSwitch( address, 1, state ) ;
                                status = LocoNet.requestSwitch( address, 0, state ) ; }
        else                   {status = LocoNet.reportSensor(  address,    state ) ; }
                                //status = LocoNet.reportSensor(  address,    state ) ; }

        if( status == LN_DONE ) // if message has transmitted succesfully...
        {
            io[index].oldState = io[index].newState ; // ...update status
   
            if( ++ index == nInputs ) index = 0 ;     // and go to next object
        }
    }
    else
    {
        if( ++ index == nInputs ) index = 0 ; // if object's state has not changed, go to next object.
    }
}
Telkens als een melder van state verandert, moet die de bus op. Dat doe ik dan zo snel als mogelijk. Na het aanroepen van het verzenden bekijk ik de status. En is die dan LN_DONE, dan verhoog ik de index naar de volgende bezetmelder. Zo wordt er geen bezetmelder overgeslagen.

Ik ben alleen nog aan het bedanken, wat nog handig is om te testen.

Hoewel ik niet denk dat het zal helpen, is om een vaste interval toe te voegen tussen iteraties van die functie. Ik dacht als ik bijvoorbeeld om de 10ms of zelfs 20ms die functie aanroept, dat het dan misschien beter zal gaan. Het kan ook niet echt kwaad om die tijd er tussen te zetten, dus baadt het niet, schaadt het niet.

Ik denk ook een kleine tijds differentiatie toevoegen van enkele milliseconde. Ik dacht misschien als apparaat 1 op 10000ms stuurt en apparaat 2 op 10010ms (en dit voor alle 7) dat het dan misschien veel beter gaat.

En in plaats van 16 melders per keer, wil ik alle 7 apparaten slechts 1 melder laten sturen.

Mvg,

Bas

[Bert55]

Je maakt mooi spul Bas maar dat plakband vind ik persoonlijk een beetje jammer voor de uitstraling.

[AP3737]

Hi Bas

Leuk 

Nu zijn 5 x 16 melders die in dezelfde milliseconde (en misschien wel microseconde, het begin althans) verstuurd moeten worden ook wel erg uitzonderlijk.

Hmm, daar ben ik niet zo zeker van. Op mijn eigen baan heb ik tussen de 60 en 70 (zelfbouw) terugmelders (RS-Bus). Als de terugmeld bus actief wordt (spanning op de bus is aan, centrale geeft aan dat hij ready is), sturen alle terugmelders zo snel mogelijk de huidige status (bezetmelding, wissels) terug. De RS-Bus is een polling bus, dus dat gaat wel goed. Loconet is echter CSMA/CD, en dan zou het wel eens niet goed kunnen gaan. Daarom zou ik bij Loconet altijd een kleine vertraging (afhankelijk van het Loconet adres??) inbouwen.

Je geeft aan dat je test met 5 hardware devices, en per hardware device 16 software melders. Dat is volgens mij toch wat anders dan 80 hardware melders, verspreid over een lange bus. In dat laatste geval zou je op 80 plaatsen CSMA/CD toepassen, en nu op "slechts" 5. Bij CSMA/CD speelt de looptijd van het signaal namelijk ook een rol: hoe langer het duurt tussen het versturen van een signaal en het detecteren van dat signaal, hoe groter de kans op collissions. Als je slechts een heel korte bus hebt, dan is de kans op collisions veel kleiner.

Als je het echt goed wil testen, dan zou je toch eens een scoop op de bus moeten zetten. Daarnaast zou je de loconet bekabeling lang moeten maken (200 meter?), en de decoders over de bus verspreiden.

Even wat hardop rekenen en een getallen voorbeeld (ik hoop dat ik me niet verreken en een factor 1000 mis zit  )
Lichtsnelheid is 300000 km/s = 300km/ms = 300m/us.
De snelheid van een electrisch signaal in een koperen geleider is ongeveer 0,7 x de lichtsnelheid. Dus in 1us legt het signaal ongeveer 200m af. De Loconet spec zegt, dat je binnen 2us nadat je carrier free detecteert, moet beginnen met zenden. Je hebt dus (bij 200m kabel) een "onzekerheids interval" van 3us waarbinnen collissions kunnen voorkomen. In de praktijk zal deze tijd waarschijnlijk hoger zijn, omdat je hard/software misschien niet snel genoeg is (een 328 ISR kost meerdere us).
Ik zou daarom precies willen weten hoe snel de hard/software is, dus een scoop en logic analyzer gebruiken om te meten. Een redelijke combinatie USB scoop/analyser kost by Ali 60 Euro, dus dat valt best mee.

[Duikeend]

erg leuk om te volgen! helaas mis ik de kennis om mee te doen maar lees het graag 

Je maakt mooi spul Bas maar dat plakband vind ik persoonlijk een beetje jammer voor de uitstraling.

daar komt hij wel achter als over een tijdje die tape helemaal vergaan is en vastgekoekt is aan zijn printjes 

[meino]

Bas,

Ik ken de CAN specs niet goed genoeg om daar iets specifieks over te kunnen zeggen. Maar het aloude Ethernet is mij iets beter bekend. Dat werkt ook met CD (colection detection). Daar is het voorgeschreven dat als een node een collision detecteert, dat hij een random tijd moet wachten voor hij het opnieuw gaat proberen. Dat is om er voor te zorgen dat er geen race conditie ontstaat tussen twee of meer nodes die op het zelfde moment willen zenden. Zit dat wel goed in je code? Vijf zenders die op het zelfde moment willen zenden vind ik niet veel. Ik werk ook met de CAN bus en heb bij het opstarten wel meer nodes die tegelijkertijd gaan zenden. Tot nu toe geen problemen gezien, maar ik werk dan wel met standaard CAN bus kaartjes waar de kaart het hele gebeuren afhandelt.

Groet Meino

[bask185]

Dat plankje was ook niet echt mooi hoor  . Ik had ff snel iets nodig om ze bij elkaar te houden, m'n kid sliep al dus dat betekent geen accuboor. Ik denk dat ik ze alsnog op het plankje zet. Ik moet er alleen rekening meehouden dat mijn pogopins er op gaan voor updates.

Daar is het voorgeschreven dat als een node een collision detecteert, dat hij een random tijd moet wachten voor hij het opnieuw gaat proberen

Dit is volgens mij ook de enige manier waarop je identieke apparaten die gelijktijdig dingen gaan verzenden, toch in goede banen kan geleiden.

Ik denk sws dat ik alle apparaten ook hun beginstand laat opsturen, waarbij ik een adres afhankelijke opstart vertraging inbouw. En tevens wanneer een ik een status binnen krijg die != aan LN_DONE dat ik eventjes wacht met een random tijd. Het start adres kan je in arduino's randomSeed() functie proppen.

Ik heb 20 melders totaal liggen, dus ik vlam nog even door  .

Code: [Selecteer]

void updateOccupancyStatus()
{
    static uint32 interval = 1 ;                        // default interval of 1ms

    REPEAT_MS( interval )                               // best macro ever, creates an interval
    {
        static uint8 index ;

        if( io[index].newState != io[index].oldState )
        {
            LN_STATUS status ;
            uint8     type      = io[index].type ;
            uint8     address   = io[index].address ;
            uint8     state     = io[index].newState ;

            if( type == ACCESSORY ){status = LocoNet.requestSwitch( address, 1, state ) ;
                                    status = LocoNet.requestSwitch( address, 0, state ) ; }
            else                   {status = LocoNet.reportSensor(  address,    state ) ; }
                                    //status = LocoNet.reportSensor(  address,    state ) ; }

            if( status == LN_DONE )
            {
                io[index].oldState = io[index].newState ;
   
                if( ++ index == nInputs ) index = 0 ;

                interval = 1;                             // if status is OK, maintain 1ms interval
            }
            else
            {
                interval = random( 5, 50 ) ;              // in event of collission, wait with random interval
            }
        }
        else
        {
            if( ++ index == nInputs ) index = 0 ;
        }
    }
    END_REPEAT
}

Tijd voor middagwandeling 

Mvg,

Bas

[meino]

Het start adres kan je in arduino's randomSeed() functie proppen.

Dat lijkt me een goed idee. De random() functie is niet erg random, wel bruikbaar.

Oh ja, nog wat, op welke snelheid stuur je de CAN aan. De MCP kaartjes die ik gebruik werkten voor geen meter op 1Mbit, dus staat bij mij de bus op 500Kbit.

Groet Meino

[bask185]

Het is loconet, meino. Geen Can. Ben wel van mening dat Can beter of eigenlijk makkelijker is. Loconet draait op ik dacht 16knl nog iets bps uit mn hoofd. iig niet zo snel als 500k 

[reinderlf]

LocoNet is 16k5 baud, niet erg snel, voordeel is wel dat je makkelijk aftakkingen kan en mag maken

CAN is zeker een mooi systeem (een auto zit er vol mee), dan wordt al die collision stuff geregeld in hardware Nadeel is wel dat het relatief duur is (qua componenten) t.o.v. andere bussen.
Voor de meeste tranceivers "mag" je "maar" tot 32 nodes.

Er zijn wel wat apparaten met een CAN bus, maar die hebben allemaal een eigen standaard vermoed ik.
Z21 heeft CAN, Marklin CS heeft CAN, ECoS link is ook CAN gok ik en dan is er nog LCC.
Nu kun je dat in theorie wel mixen op een bus, maar dan moet je wel een node hebben die dat allemaal snapt, misschien ben je dan beter af met een gateway naar een meer common systeem zoals LocoNet.

[bask185]

Ik heb een toepassing gevonden voor...  een goto  .
 

Code: [Selecteer]

void setup()
{
    LocoNet.init(LNtxPin) ;

    loadEEPROM() ;

    randomSeed( io[0].address ) ;                                        // <---
    startupDelay = random( 1, 1000 ) ;                                   // <---

    for( int i = 0 ; i < nInputs ; i ++ ) input[i].begin() ;

    pinMode(13, OUTPUT) ;
}

void loop()
{
    waitStartDelay : if( millis() <= startupDelay ) goto waitStartDelay ; // <---
   
Ik moet hier een macro voor maken voor in m'n macros.h 

Code: [Selecteer]

#define startupDelay( interval ) PIGS_CAN_FLY: if( millis() <= interval ) goto PIGS_CAN_FLY;
Ik vind loconet wel erg fijn omdat die kabels zo makkelijk zelf te maken zijn.  Dat kost zo weinig

Mvg,

Bas

[Karst Drenth]

@Bas

ipv zelf van alles en nog wat zelf (proberen) te bedenken, zou je ook de LocoNet-PE eens goed kunnen doorlezen. Daar staat precies in wat je moet doen en laten mbt het verzenden van pakketjes... ook wanneer je een carrier detecteerd, wanneer een collision, wat dan te doen en hoe dat op te lossen c.q. moet retry-en.

Overigens, zelf als je dat uit die LocoNet-PE allemaal implementeert, krijg je nog steeds bij een "groot" systeem, dat het voorgeschreven aantal retry's bij collision, niet voldoende is en je dus toch pakketjes gaat missen.

Grtzz,
Karst, met inmiddels 20 jaar ervaring in deze materie

[bask185]

Dat is pas de volgende stap. Deze decoders gebruiken de open source mrrwa library van Alex Shepperd en dit draadjes gaat precies daar over.

[meino]

Code: [Selecteer]

    waitStartDelay : if( millis() <= startupDelay ) goto waitStartDelay ; // <---
Ik moet hier een macro voor maken voor in m'n macros.h 

BS;

Code: [Selecteer]

while( millis() <= startupDelay ){}
Doet het zelfde en is nog korter en duidelijker. Ken u klassieken, zeker nooit https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf gelezen.
Alleen slechte programmeurs hebben het goto statement nodig.

Groet Meino