Draaischijf uit de 3D-printer en met Arduino besturing

[Jozz]

Alles wat ik aan programmeerfuncties bedacht had, moet worden opgeslagen in het EEPROM geheugen van de Arduino.
Elke variabele die moet worden opgeslagen, moet een positie in het geheugen krijgen. Het leek me handig om alvast in een schema vast te leggen:

Code: [Selecteer]

--variable--                --type--   --pos--
 EepromSchemeVersion         ULONG(4)       0
 DCC start address:          UINT(2)        4
 steps per revolution:       LONG(4)       10
 number of tracks:           BYTE(1)       14
 reverse default direction:  BYTE(1)       15
 speed [steps per second]:   UINT(2)       16
 acceleration steps:         UINT(2)       18
Vanaf plek 20 kunnen dan de aansluitspoorposities worden opgeslagen.

Maar er moet ook nog een stappenpositie worden vastgelegd waar het brugspoor moet ompolen. Ik vermoed dat opslaan van één positie voldoende is en de andere positie er precies tegenover ligt.

Of zou het theoretisch voor kunnen komen dat het brugspoor op meer plekken omgepoold moet worden?
Heeft iemand dat?

[bask185]

Of zou het theoretisch voor kunnen komen dat het brugspoor op meer plekken omgepoold moet worden?

Het is afhankelijk van hoe jij je je aansluit sporen bedraad. Als er 2 tegenover elkaar liggen, moeten ze natuurlijk gelijk bedraad worden. Ik denk dat je slechts 2 momenten heb waarop je je ompoolrelais hoeft te schakelen. Je kan net zo makkelijk per spoor de relaisstanden opslaan, kleine moeite.

Misschien needless to say Wat eeprom en settings betreft. Dit is de ideale situatie om een structure toe te passen. Je kan een (naamloze) struct maken en dan maak je 1 object genaamd 'settings' ofzo.

Code: [Selecteer]

struct
{
    uint32_t    version ;
    uint16_t    startAddress ;
    uint32_t    stepsPerRevolution ; // or 'circumreference'
    uint8_t     nTracks ; // zou deze elders opslaan, zie verderop
    uint8_t     defaultDirection ;
    uint16_t    speed ;
    uint16_t    acceleration ;
} setting ;

Om te gebruiken tik je overal 'settings.xxxx' en die kan je als normale variabelen benaderen.

Code: [Selecteer]

// usage

void someFunc()
{
    settings.version = 0xCC33 ;         // write

    int variable = settings.nTracks ;   // read
}


Het opslaan en laden van de settings kan je dan met deze 2 functies doen.

Code: [Selecteer]

// to store
void storeSettings()
{
    int eeAddress = 0x0000 ;
    EEPROM.put( eeAddress, settings ) ;  // stores all settings
}

void loadSettings()
{
    int eeAddress = 0x0000 ;
    EEPROM.get( eeAddress, settings ) ;  // loads all settings 
}
Je hoeft je niet druk te maken om de grootte. put() en get() regelen alles voor je.

Op dezelfde manier kan je ook alle aansluitspoorposities laden en opslaan. Zelf gebuik ik wel eens de MSB bit in een array om een bepaalde stand op te slaan. De overige bits zijn dan voor een adres of een positie. Ik doe dat meestal als ik wisselstraten opsla, but 15 is bij mij dan de stand van de wissel en de andere bits het adres.

Code: [Selecteer]

struct
{
    uint8_t     nTracks ;       // hold the amount of tracks.
    uint32_t    positions[40] ; // choose 40 as maximum limit, may be more.
} tracks ;

// usage
uint32_t getPosition( int index )
{
    return tracks.position[index] & 0x7FFF ; // return all bit but MSB (relay state)
}

uint8_t getRelayState( int index )
{
    return tracks.position[index] >> 15 ;  // return the state bit.
}

void setPosition( uint32_t position, uint8_t relayState )
{
    uint8_t index = tracks.nTracks ;
    //                            position        OR       relayState
    tracks.position[index] = ( position & 0x7FFF ) | ( relayState << 15 ) ;
    tracks.nTracks ++ ;             // increment every time when a track is stored
}

Als je dan gaat inleren dan reset je eerst tracks.nTracks naar 0. En elke keer dat je een spoor opslaat dan hoog je die op. Als je dan klaar bent inleren heeft tracks.nTracks het juiste aantal sporen.

Dan kan je alles in 1 klap opslaan met deze functies. Het eeprom adres van de spooraansluitingen kan je laten berekenen met de sizeof() operator. Ik gebruik hier de grootte van bovenstaande settings om het eerst volgende vrije adres onder de settings te berekenen.

Code: [Selecteer]

// to store in eeprom
void storeTracks()
{
    int eeAddress = sizeof( settings ) ; // I calculate the first free address behind the settings structure
    EEPROM.put( eeAddress, tracks ) ;  // stores all settings
}

void loadTracks()
{
    int eeAddress = sizeof( settings ) ;
    EEPROM.get( eeAddress, tracks ) ;  // stores all settings 
}

En al deze code zou ik in aparte bestandjes dumpen. eeprom.cpp en eemprom.h

Wie weet, is het misschien ook wel handig dat je na het inleren nog aparte aansluitingen kan finetunen. Het zou zuur zijn als je 30 sporen inleert en je moet alles opnieuw doen, omdat 1 spoor net niet helemaal lekker staat.

Code: [Selecteer]

void updatePosition( uint32_t position, uint8_t relayState, uint8_t index )  // index moved to argument
{    //                            position        OR       relayState
    tracks.position[index] = ( position & 0x7FFF ) | ( relayState << 15 ) ;
}

// usage
updatePosition( currentPos, currentRelayState, currentTrack ) ;
// when done update call storeTracks() ; to commit the change to EEPROM

Ik had nog een brainfart. Die komen soms tot me van tijd tot tijd  . Die dcc servo decoders zoals die van DK kan je finetunen door lok adres 9999 aan te sturen. Dan kan je bijvoorbeeld de rijregelknop van je multimaus of... gebruiken om de servo's of in jouw geval de schijf aan te sturen. De lok functies kan je bijvoorbeeld gebruiken om config modes binnen te gaan (F0), de relais kan je togglen (F1) en om een spoor op te slaan (F2). Reset alle posities en home de schijf (F12) Misschien positie finetunen met F3 en F4? F5 huidige spoor updaten? iets in die richting is misschien handig  Ik heb hem zelf nog niet helemaal uitgedacht

Mvg,

Bas

[Jozz]

Dank voor deze enorme hoeveelheid waardevolle tips, Bas!
Hier ga ik zeker wat mee doen. Met zo'n struct wordt het inderdaad veel makkelijker om settings op te slaan en uit te lezen. Weer wat geleerd!

En programmeren met behulp van lok adres 9999 is zeker een goed idee.
Hiervoor zou ik een snelheids-array maken per snelheidsstap (0-27) om de schijf te laten draaien, bijvoorbeeld: 0, 1,2,3,5,10,15,20,30 ... 1800,2000 stappen per seconde.
Dan kan je eerst de schijf nauwkeurig naar de gewenste positie manoeuvreren, en vervolgens met de functies verder configureren inderdaad.

Eigenlijk zou ik qua gewenste snelheid liever het aantal seconden per omwenteling willen instellen, maar daarvoor moet de brug na het vinden van de home-positie, minimaal één keer rond zijn geweest om het aantal stappen voor een complete omwenteling te kunnen vaststellen. En daarvoor zou je eerst de snelheid waarbij de brug nog betrouwbaar draait (zonder overslaan stappen), moeten configureren.

Een OLED schermpje waarop de programmeer-info wordt weergegeven, is dan misschien ook wel erg handig.