Doel:€250.00
Donaties:€157.50

Per saldo:€-92.50

Steun ons nu!

Laatst bijgewerkt
op 30-06-2020
Algemeen

De stichting

Recente berichten

Frans loodsje et cetera door Noordernet
Vandaag om 10:58:32
Onlangs gespot - gefotografeerd, de foto's door Vislijn
Vandaag om 10:40:10
Ombouw/Pimpen Bolle neuzen door bollen neus
Vandaag om 10:25:31
Toekomst van modeltreinbeurzen? door nkob
Vandaag om 10:15:32
Gezocht: enkelvoudige Loconet servodecoder? door Dirk
Vandaag om 09:40:47
Mat '36 445 door Pauldg
Vandaag om 09:35:08
Mijn eerste H0-modeltreinbaan in aanbouw door Jelmer
Vandaag om 09:26:17
Modelhuis demonteren zonder stukken door Basilicum
Vandaag om 09:23:20
Modeltrein Express eigen productie (nog niet bekend wat!) door Pauldg
Vandaag om 09:11:27
De bouw van mijn modelbaan in Thailand door Wim Vink
Vandaag om 08:59:52
Fotowedstrijd BeneluxSpoor.net door Bob R.
Vandaag om 08:48:29
Digikeijs DR5000 werkt met Raspberry Pi 3? door Martin Domburg
Vandaag om 08:46:27
BNLS-Module: "Rvbr-Btk, Ringvaartbrug Haarlemmermeer nabij Buitenkaag" NS H0 door nighttrain1
Vandaag om 08:28:07
Toon hier je nieuwe (model-) spooraanwinst(en)... door Arjan6511
Vandaag om 07:12:54
Trix 23219 Simplon Orient Express rijtuig binnenverlichting doet het niet door sjoerd74
Vandaag om 06:06:27
Virgin HSL van Las Vegas naar SoCal een ((piep)klein) stapje dichterbij door Daan in Las Vegas
Vandaag om 02:25:51
Kortsluiting DR5000 met meten met een oscilloscoop door Fransx
Vandaag om 00:18:34
NL-baan in Canada door ArjanB
01 juli 2020, 23:26:11
NS Stoomverwarmingswagen door Hans van de Burgt
01 juli 2020, 22:59:39
Havenbaantje, Duitse havenstad, periode 2e wereldoorlog. door AndréDev
01 juli 2020, 22:45:47
NS vanaf 2023 met snellere trein naar Noord-Nederland, ondanks ongeschikt spoor door 44
01 juli 2020, 21:52:08
De HTM Buitenlijner door Gerco van Beelen
01 juli 2020, 21:43:53
Peco rails code 55 of 80 voor ouder materieel? door Klaas Zondervan
01 juli 2020, 21:43:31
Märklin Kombirail 48045 ontspoort in R1-boog door Blausee-Mitholz
01 juli 2020, 20:50:26
NS: intercity Den Haag-Aken in 2025 haalbaar door Remunj
01 juli 2020, 20:20:18
NL baan: Frotterdam in h0 door schienenbus2012
01 juli 2020, 20:18:34
3D printen van niet meer leverbare onderdelen door MOVisser
01 juli 2020, 19:52:06
Doornvliet door Tulpendaal
01 juli 2020, 18:23:48
LS-Models 2020, nieuws van de fabrikant. door LMX
01 juli 2020, 18:11:40
"Bij nader omzien", een Nederlands spoorwegfotoarchief door Dpc Fo
01 juli 2020, 18:01:58
  

Auteur Topic: Arduino en Selectrix  (gelezen 20283 keer)

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3529
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino en Selectrix
« Reactie #30 Gepost op: 17 juli 2015, 11:00:51 »
Zo mail gehad uit China, de print wordt gemaakt. De opmerking van HansQ is verwerkt.  Het spoor is samen met het spoor rechts onder die ook dicht langs de schroef is gegaan gewijzigd. Jullie zien over een paar weken het resultaat.
Dus verder met wat ik nu nog kan doen, de code. Wel hier is het .h file (class definition)
/*
 * SXArduino.h
 *
 *  Created on: 10.07.2015
 *  Version:    0.1
 *  Copyright:  Gerard van der Sel
 *
 *  Changed on:
 *  Version:
 *
 *  interface hardware needed ! see

 Read SX Signal - SX Clock must be connected to Pin2=INT0 and
 SX Data must be connected to Pin4. For triggering a scope, a signal
 can be generated at Pin3 at a defined base address.
 Pin6 can be connected via a 150 ohm resistor to the write line
 of the SX bus
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA


 */

#ifndef SXArduino_H_
#define SXArduino_H_

#include <inttypes.h>

// define arduino pins, ports and bits
#define SX_T0           3     // must be INT1 !!
#define SX_T0_DDR     DDRD
#define SX_T0_PORT   PORTD
#define SX_T0_PORTPIN PORTD3
#define SX_T0_PINREG   PIND

#define SX_T1       5
#define SX_T1_DDR     DDRD
#define SX_T1_PORT   PORTD
#define SX_T1_PORTPIN PORTD5
#define SX_T1_PINREG   PIND

#define SX_D       6
#define SX_D_DDR     DDRD
#define SX_D_PORT     PORTD
#define SX_D_PORTPIN   PORTD6
#define SX_D_PINREG   PIND


// defines for state machine
#define SYNC           0
#define PWR           1
#define ADDR           2
#define DATA           3

#define MAX_DATACOUNT   7     // 7 dataframes in 1 SYNC Channel
#define MAX_DATABITCOUNT 12   // 12 bits in 1 frame

#define MAX_ADDRESS_NUMBER 112   // SX channels

class SXArduino {
public:
SXArduino();
void init(void);
uint8_t get(uint8_t);
uint8_t set(uint8_t, uint8_t);
uint8_t writing();
        uint8_t getPWRBit();
void setPWRBit(uint8_t);
void isr(void);

private:
void readPower(void);
void writePower(void);
void readAdr(void);
void readData(void);
void writeData(void);

uint8_t _baseAdr;                     // base address
uint8_t _dataFrameCount;       // frame counting
uint8_t _address;                     // current address on the bus
uint8_t _state;
uint8_t _bitCount;                    // bit counting

uint8_t _PWRBit;                      // Current state of POWER on track
uint8_t _newPWRBit;               // Command POWER on track

uint8_t _sx_write_address;      // stores address to write to
        uint8_t _sx_write_data;    // data to write
uint8_t _sx_writing;   // active during the actual writing
        volatile uint8_t _sx_write_busy;       // wait to send data, cannot accept new data

uint8_t _clk;
uint8_t _bit;

uint8_t _data;                        // data from the SX-bus (1 adsress)
uint8_t _sxbus[MAX_ADDRESS_NUMBER];   // to store the SX data

/* SX Timing
1   Bit            50 �s
1   Addres        600 �s (= 12 Bit)
1   Telegram       ca. 4,8 ms
1   All            ca.  80 ms (= 16 Grundrahmen) 
0  0  0  1  S   1  A3  A2  1  A1  A0  1 == sync frame of 12 bits
*/
};

#endif /* SXArduino_H_ */

Blijft over de implementatie van de class (.cpp file)
/*
 * SXAduino.cpp
 *
 *  Created on: 16.07.2015
 *  Version:    0.1
 *  Copyright:  Gerard van der Sel
 *
 *  Changed on:
 *  Version:
 *
 *  interface hardware needed !

 Interface SX-bus
 - SX T0 (Clock) must be connected to Pin 3 (IOL, INT1);
 - SX T1 must be connected to Pin 5 (IOL, T1);
 - SX D must be connected to Pin 6 (IOL, AIN0).
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA


 */


#include <Arduino.h>

#include "SXArduino.h"


SXArduino::SXArduino() {
  pinMode(SX_T0, INPUT);      // SX-T0 is an input, no pull up to simulate tri-state
  pinMode(SX_T1, INPUT);      // SX-T1 is also an input
  pinMode(SX_D, INPUT);       // SX-D is also an input when not writing to allow other devices to write
}

void SXArduino::init() {
     // initialize function
     // initialize pins and variables

pinMode(SX_T0, INPUT);      // SX-T0 is an input, no pull up to simulate tri-state
pinMode(SX_T1, INPUT);      // SX-T1 is also an input
pinMode(SX_D, INPUT);       // SX-D is also an input when not writing to allow other devices to write

for (int i = 0; i < MAX_ADDRESS_NUMBER; i++) {
      // reset sx variable to zero
  _sxbus[i] = 0;
}

// start always with search for SYNC
_state = SYNC;
_dataFrameCount = 0;
_bitCount = 0;
_sx_writing = 0;
_sx_write_busy = 0;
_newPWRBit = 2;
_PWRBit = 0;                   // At start no power
}


// Read the bit that indicates if there is power on the track and store it.
// After reading the bit start processing the address.
void SXArduino::readPower()  {
if(_bitCount == 0) {
_PWRBit = (SX_T1_PINREG & _BV(SX_T1_PORTPIN)) > 0;
_bitCount++;
} else {
_bitCount = 0;
_state = ADDR;
}   // end if _bitCount
}

// Write the bit that controls the power on the track if the user want to change it.
// After writing the bit the pin is changed from output to input
 void SXArduino::writePower()  {
if(_bitCount == 0) {
if (_newPWRBit != 2) {
bitWrite(SX_D_DDR, SX_D_PORTPIN, HIGH); // Switch pin to output
bitWrite(SX_D_PORT, SX_D_PORTPIN, _newPWRBit); //  and write the newPWRBit
} else {
_newPWRBit = 2;
bitWrite(SX_D_DDR, SX_D_PORTPIN, LOW); // Switch pin to input
}   // end if _newPWRBit
}   // end if _bitCount
}

// Read the address bits.
// If base-address is read calculate the real address and
// check if we must write
// Proceed to the next stage DATA
void SXArduino::readAdr() {
_bit = (SX_T1_PINREG & _BV(SX_T1_PORTPIN)) > 0;
switch(_bitCount) {
case 2:  // "Trenbit"
_bitCount++;
break;
case 5: // last "Trenbit"
// advance to next state
// we are processing the 7 data bytes (i.e. 7 SX addresses)
_state = DATA; 
_bitCount = 0;
//  _dataFrameCount is 0.
_address = 111 - _baseAdr;
if ((_address == _sx_write_address) && (_sx_write_busy == 1))  {
_sx_writing = 1;
} else {
_sx_writing = 0;
}
break;
case 0:  // A3
bitWrite(_baseAdr, 3, _bit);
_bitCount++;
break;
case 1:  // A2
bitWrite(_baseAdr, 2, _bit);
_bitCount++;
break;
case 3:  // A1
bitWrite(_baseAdr, 1, _bit);
_bitCount++;
break;
case 4:  // A0
bitWrite(_baseAdr, 0, _bit);
_bitCount++;
break;
}  //end switch/case _bitCount
}

// read 12 bits and convert it to a databyte.
// Read 7 databytes to read all data
// After reading 7 data bytes start searching for SYNC
void SXArduino::readData()  {
_bit = (SX_T1_PINREG & _BV(SX_T1_PORTPIN)) > 0;
// continue read _data
// a total of 7 DATA blocks will be received
    // for a certain base-address
switch(_bitCount) {
case 2:  // "Trenn_bits"
case 5:
case 8:
_bitCount++;
break; // ignore
case 11: // Last "Trenn_bit"
// save read _data
_sxbus[_address] = _data;
_bitCount = 0;
_data = 0;
        // increment dataFrameCount to move on the next DATA byte
        // check, if we already reached the last DATA block - in this
        // case move on to the next SX-Datenpaket, i.e. look for SYNC
_dataFrameCount++;
if (_dataFrameCount == MAX_DATACOUNT) {
// and move on to SYNC _state
_dataFrameCount = 0;
_state =SYNC;
}
// calc sx address from baseAdr and dataFrameCount
// _address = (6-_dataFrameCount) * 16 + (15 - _baseAdr)
_address = ((6 - _dataFrameCount) << 4) + (15 - _baseAdr);
// check if we want to write
if ((_address == _sx_write_address) && (_sx_write_busy == 1))  {
_sx_writing = 1;
} else {
_sx_writing = 0;
}
break;
// Read the data bits
case 0:   // D0
bitWrite(_data, 0, _bit);
_bitCount++;
break;
case 1:   // D1
bitWrite(_data, 1, _bit);
_bitCount++;
break;
case 3:   // D2
bitWrite(_data, 2, _bit);
_bitCount++;
break;
case 4:   // D3
bitWrite(_data, 3, _bit);
_bitCount++;
break;
case 6:   // D4
bitWrite(_data, 4, _bit);
_bitCount++;
break;
case 7:   // D5
bitWrite(_data, 5, _bit);
_bitCount++;
break;
case 9:   // D6
bitWrite(_data, 6, _bit);
_bitCount++;
break;
case 10:  // D7
bitWrite(_data, 7, _bit);
_bitCount++;
break;
}  //end switch/case _bitCount
}

// write the 8 databits to the 12 bit frame
// When finished writing report it.
void SXArduino::writeData() {
switch(_bitCount) {
case 11:  // Last "Trenn_bit"
_sx_writing = 0;                             // Stop writing``
_sx_write_busy = 0;                          // Report end
case 2:
case 5:
case 8:  // "Trenn_bits"
bitWrite(SX_D_DDR, SX_D_PORTPIN, HIGH);      // Switch pin to input
break;
// Write the data bits
case 0:  // D0
bitWrite(SX_D_DDR, SX_D_PORTPIN, LOW); // Switch pin to output
bitWrite(SX_D_PORT, SX_D_PORTPIN, bitRead(_sx_write_data, 0));
break;
case 1:  // D1
bitWrite(SX_D_PORT, SX_D_PORTPIN, bitRead(_sx_write_data, 1));
break;
case 3:  // D2
bitWrite(SX_D_DDR, SX_D_PORTPIN, LOW); // Switch pin to output
bitWrite(SX_D_PORT, SX_D_PORTPIN, bitRead(_sx_write_data, 2));
break;
case 4:  // D3
bitWrite(SX_D_PORT, SX_D_PORTPIN, bitRead(_sx_write_data, 3));
break;
case 6:  // D4
bitWrite(SX_D_DDR, SX_D_PORTPIN, LOW); // Switch pin to output
bitWrite(SX_D_PORT, SX_D_PORTPIN, bitRead(_sx_write_data, 4));
break;
case 7:  // D5
bitWrite(SX_D_PORT, SX_D_PORTPIN, bitRead(_sx_write_data, 5));
break;
case 9:  // D6
bitWrite(SX_D_DDR, SX_D_PORTPIN, LOW); // Switch pin to output
bitWrite(SX_D_PORT, SX_D_PORTPIN, bitRead(_sx_write_data, 6));
break;
case 10: // D7
bitWrite(SX_D_PORT, SX_D_PORTPIN, bitRead(_sx_write_data, 7));
break;
}  //end switch/case _bitCount
}


// interrupt service routine (AVR INT1)
// driven by LEVEL CHANGES of the clock signal T0 (SX pin 1)
// LOW: writing
// HIGH: reading and control
void SXArduino::isr() {
     // 4 different states are distinguished
     //     1. SNYC = looking for a SYNC signal
//     2. PWR  = look for PWR bit
     //     3. ADDR = look for base address (0..15)
     //     4. DATA = decode the data-bytes

_clk = (SX_T0_PINREG & _BV(SX_T0_PORTPIN)) > 0;

switch(_state) {
case SYNC:                            // Search for 0 0 0 1
        if (_clk != LOW)  {
_bit = (SX_T1_PINREG & _BV(SX_T1_PORTPIN)) > 0;   // read pin
if (_bit == LOW) {
_bitCount++;
} else {
if (_bitCount == 3) {     // sync bits 0 0 0 1 found
_state = PWR;         // advance to next state
}  // endif _bitCount
_bitCount = 0;            // reset _bitCounter
}  // endif _bit==LOW
}  // endif _clk!=LOW
break;
case PWR:
if (_clk == LOW)  {
writePower();
} else {
readPower();
}  // endif _clk==LOW
break;
case ADDR:
if (_clk != LOW)  {
readAdr();
}  // endif _clk!=LOW
break;
case DATA:
if (_clk == LOW)  {
if (_sx_writing == 1)  {
writeData();
}
} else {
readData();
}  // endif _clk==LOW
}  //end switch/case _state
}

// functions 'accessing' the SX-bus

// Read data from the array, filled by the isr.
uint8_t SXArduino::get(uint8_t ad) {
     // returns the value of a SX address
if (ad < MAX_ADDRESS_NUMBER)  {
   return _sxbus[ad];
} else  {
   return 0;
}
}

// Start writing data to the SX-bus.
// Check if writing or invalid address.
uint8_t SXArduino::set(uint8_t ad, uint8_t d) {
if (_sx_write_busy == 0)  {
if (ad < MAX_ADDRESS_NUMBER)  {
_sx_write_address = ad;
_sx_write_data = d;
_sx_write_busy = 1;
return 0;
}
return 2;    // address out of range
}
return 1;  // don't accept new data
}

// Check if writing is finished
// (A write lasts between 600usec and 80 msec)
uint8_t SXArduino::writing() {
return _sx_write_busy;
}

// Read POWER status from the SX-bus
uint8_t SXArduino::getPWRBit() {
    return _PWRBit;
}

// Write POWER status to the SX-bus and control a connected central.
void SXArduino::setPWRBit(uint8_t val) {
if (val == 0 || val == 1) {
_newPWRBit = val;
}
}
Zo nu nog een paar dagen testen, waarbij ik zelf voor clock (T0) ga spelen en de T1 lijn ook maar bedien.
Hiervoor een kleine sketch geschreven die regelmatig het innerlijk van de isr terugmeld (hiervoor het .h file aangepast)
Hierbij de sketch:
#include "SXArduino.h"

// SX-bus interface
SXArduino SXbus;                 // Get access to the SX-bus

void sxisr(void) {
    // if you want to understand this, see:
    // http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1239522239   
    SXbus.isr();
}

void setup() {
    // put your setup code here, to run once:
    // Serial communication
    Serial.begin(9600);      // open the serial port

    // SX-bus communication
    SXbus.init();
    // CHANGE on INT1 triggers the interrupt routine sxisr (see above)
    attachInterrupt(1, sxisr, CHANGE);
}

void loop() {
    // put your main code here, to run repeatedly:
    Serial.println(SXbus._state);
    Serial.println(SXbus.get(111));
}
Ik heb hier in iedergeval een vraag over, waarom moet het .cpp en .h file in de ide geopend zijn? Zonder die twee kan ik niet compileren.
De directorie structuur is:
sketchSXArduino.ino [file]
libraries  [map]
libraries\SXarduino [map]
libraries\SXarduino\Sxarduino.h [file]
libraries\SXarduino\Sxarduino.cpp [file]
Of te wel wat is er fout ingesteld?

Groet,

Gerard van der Sel.

Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

smits66

  • Offline Offline
  • Berichten: 543
  • Schaal 1:160, Arduino
    • Modelspoor web
Re: Arduino en Selectrix
« Reactie #31 Gepost op: 17 juli 2015, 19:02:02 »
Hoi Gerard,

Ik heb de sketch en de library's gedownload, en proberen te testen, helaas zit er een fout in de library van SXArduino.h

Foutmelding arduino ide " unit8_t SXArduino::_state is private
  unit8_t _state; "

Citaat
De directorie structuur is:
sketchSXArduino.ino [file]
libraries  [map]
libraries\SXarduino [map]
libraries\SXarduino\Sxarduino.h [file]
libraries\SXarduino\Sxarduino.cpp [file]

Ik denk dat het moet zijn (dit geld voor Linux maar ik denk ook voor Windows)

sketch Arduino.ino

/mijn documenten/sketchbook/SXArduino/SXArduino.ino

En de libraries SXArduino.h en SXArduino.cpp in :

/mijn documenten/sketchbook/libraries/SXArduino/SXArduino.h
/mijn documenten/sketchbook/libraries/SXArduino/SXArduino.cpp

Dan kun je gewoon je sketch compileren.

Als je SXArduino print klaar en getest is, wil ik er alvast een bestellen, tenminste als deze print gebruikt kan worden om verschillende selectrix sturingen mee te kunnen maken, dat is wat ik uit je verhaal begrijp.
 
Kan ik misschien goed combineren met mijn Arduino Analoge modelbaan sturing, met de selectrix te kunnen aansturen.(seinen, wissels ,spoorweg overgangen ,locomotieven enz.)

Mvg Paul
Üdvözlet Paul Smits.


bouw draadje "Laubenstein"

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3529
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino en Selectrix
« Reactie #32 Gepost op: 18 juli 2015, 10:00:15 »
Paul,

De sketch is om de library's te testen. Er ziiten zoals geschreven twee wijzigingen in het .h file om het geheel compileerbaar te maken. Deze wijzigingen zijn:
- "private:" uitcommentarieren (// ervoor zetten)
- _state volatile maken (volatile ervoor zetten, zie _sx_writing_busy)
Dan zal het geheel compileren.
Bedankt voor de tips. Ik denk dat ik de fout gevonden heb. Mijn sketch staat op een willekeurige plaats.
Zal de sketch naar de goede plaats verplaatsen.

Groet,

Gerard van der Sel.
« Laatst bewerkt op: 18 juli 2015, 10:02:11 door gvandersel »
Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

Timo

  • Team encyclopedie
  • Offline Offline
  • Berichten: 4670
Re: Arduino en Selectrix
« Reactie #33 Gepost op: 19 juli 2015, 13:50:05 »
Hoi Gerard,

Structuur van alles is erg belangrijk. Arduino gaat er standaard vanuit dat je werkt vanuit je Sketchbook. En daarin de structuur hebt als:
[sketchbook]\[sketchname]\[sketchname].ino

Als je iets include dan kijkt Arduino IDE naar drie plaatsen.
  • De geopende files in de Arduino IDE in hetzelfde scherm. Vandaar dat het dan wel werkte.
  • De library folder in de map van de Arduino IDE. Hierin staan de standaard libraries die komen met de Arduino IDE. Hier hoor je nooit iets in aan te passen om problemen met compatibiliteit en updates te voorkomen.
  • De library folder in je Sketchbook ([sketchbook]\libraries\). Hierin zet je gedownloade en zelf gemaakte libraries. Hoort de structuur [sketchbook]\libaries\[libraryname]\[libraryname].h enz te hebben

Wat me nog opvalt aan de library is dat je niet in zowel de .h als de .cpp #include "Arduino.h" doet. In plaats daarvan include je intypes. Als je gewoon Arduino.h dan is dat niet meer nodig.

En waarom werkt het niet met private? Zelf ben ik overigens geen fan van private zo gebruiken, ik zou gaan voor protected. Dan blijft overerven makkelijk mogelijk.

En als ik zo even snel kijken, horen dan niet nog meer variabele volatile te zijn?



Timo
Verzonden vanaf mijn desktop met Firefox

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3529
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino en Selectrix
« Reactie #34 Gepost op: 19 juli 2015, 17:36:31 »
Directorie structuur is inmiddels goed gezet. Moest in preferences de goede directorie aanwijzen.

Waarom bepaalde variabelen private. Je gebruikt OO termen, dus ik zal eerst een kleine toelichting geven voor de meelezers.
Private: alleen te benaderen van uit de eigen class
Protected: alleen te benaderen vanuit de eigen class en de class die deze class als base class gebruikt (inheretance)
Public: iedereen die de class kan benaderen kan hier bij.

Nu het antwoord: De meeste van deze variabelen en functions zijn  onderdeel van de ISR. Als deze van buiten benaderbaar zijn, kan deze in de war raken. Dus ik zet ze private. Verder heeft Protected zetten geen zin. Ik verwachtniet dat deze class ooit geinherrit wordt. En tenzij de variabelen public staan zijn ze toch niet te benaderen. (Bij instantieren is protected hetzelfde als private.)

Tijdens het testen lees ik wat stuurvariabelen van de ISR om de voortgang te volgen. Inmiddels is _bitCount ook volatile geworden.
Waarom zo weinig variabelen volatile. Volgen arduino.cc hoeven alleen de variabelen die zowel door de ISR als het programma gebruikt worden volatile verklaard te worden. Dus waarom meer.

Groet,

Gerard van der Sel.
Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

Timo

  • Team encyclopedie
  • Offline Offline
  • Berichten: 4670
Re: Arduino en Selectrix
« Reactie #35 Gepost op: 19 juli 2015, 20:56:22 »
Je hebt gelijk dat als een variabele alleen vanuit de ISR benadert wordt dat volatile niet nodig is. Daar had ik eigenlijk niet zo op gelet. Zelf had ik denk ik dan een static variable in de IRS gebruikt maar dit is natuurlijk ook prima  (y)

Dat je private kies ipv protected omdat je denkt dat je class nooit geinherrit wordt is misschien wat kort door de bocht. De makers van de Servo classe hadden ook nooit gedacht dat iemand de classe zou willen erven maar daar wilde ik toch graag dingen aan toevoegen. Nu heb ik dat opgelost door mijn eigen branch te maken maar dit had makkelijk met erving gekund. (Nu dit alleen nog eens netjes op GitHub krijgen....)


Timo
Verzonden vanaf mijn desktop met Firefox

smits66

  • Offline Offline
  • Berichten: 543
  • Schaal 1:160, Arduino
    • Modelspoor web
Re: Arduino en Selectrix
« Reactie #36 Gepost op: 20 juli 2015, 00:36:45 »
Hoi volgers,  Arduino en Selectrix

Hoewel ik nog niet heel erg thuis ben in het programmeren van de Arduino, wil ik een kleine bijdrage leveren om dit project een klein impuls te geven, het is geen programma aanpassing.

Ik heb geprobeerd om een functiedecoder (voor 1 wissel, ik kan er meer tekenen in het schema, echter is het schema voor elke wissel gelijk) te maken die uitwisselbaar is met selectrix

Hiervoor heb ik een selectrix functiedecoder uit elkaar gehaald  :o  om te kijken hoe het werkt, aan de hand van de koperbanen op de functiedecoder heb ik een schema gemaakt van een wisselsturing die op dezelfde manier werkt als de originele selectrix decoder.

Ik wil deze week proberen er een werkende prototype van de Arduino-Selectrix functiedecoder te maken.
Ik moet allen nog bekijken hoe ik deze Arduino-Selectrix functiedecoder een adres kan geven zodat ik met de selectrix cc2000 of via Itrain / Rocrail een adres kan uitlezen.

De processor van de selectrix decoder leest het adres uit aan de hand van 7 input porten via een 7 tal dip-switchen op de print, ik moet nu kijken of ik in de setup van een Arduino sketch een adres kan zetten die de cc2000 kan uitlezen, dit moet via een softwarematige oplossing.

Op de 4-voudige selectrix functiedecoder kun je via aansluiting 1 en 2 een wisselspaning van 12 tot 14 volt zetten, deze word dan gelijkgericht en afgevlakt door de brugcel en condensator,  op de aansluiting 3, 4, 5 sluit je de wissel aan (3 en 5 zijn de spoelen en 4 de gnd)

Het schema :



Hoe werk het?

Ik stuur transistor T1 via de Arduino port aan,  T1 zal in geleiding komen en 1 van de 2 wissel-spoelen aantrekken, na 250 milliseconden (software matig)  zal de Arduino port weer laag worden en zal T1 niet meer geleiden, zodoende kan de wissel-spoel niet verbranden ,minitrix wissels hebben geen eind afschakeling.  (jip en janneke taal)

Is het schema niet correct dan hoor ik dat graag zodat ik het schema kan aanpassen.

Ik wil verschillende selectrix componenten te proberen te ontwerpen voor Arduino-Selectrix geschikt te maken.

voor zo ver mijn bijdrage.

Mvg Paul   ;)
« Laatst bewerkt op: 20 juli 2015, 18:49:39 door smits66 »
Üdvözlet Paul Smits.


bouw draadje "Laubenstein"

Calimero

  • Offline Offline
  • Berichten: 1042
Re: Arduino en Selectrix
« Reactie #37 Gepost op: 20 juli 2015, 05:30:54 »
Zodra er 1 van de torren in geleiding gaat heb je een glas harde kortsluiting (via de diodes).
Groet, Ronald.

smits66

  • Offline Offline
  • Berichten: 543
  • Schaal 1:160, Arduino
    • Modelspoor web
Re: Arduino en Selectrix
« Reactie #38 Gepost op: 20 juli 2015, 06:05:26 »
Hoi, Ronald

Bedankt voor je opmerking .
Ik zie dat de diodes verkeert zitten, dit moeten blus diodes zijn en
moeten parallel over de spoel heen staan, niet in serie met de spoelen.
Ik zal vanavond het schema aanpassen.

Mvg Paul
Üdvözlet Paul Smits.


bouw draadje "Laubenstein"

Calimero

  • Offline Offline
  • Berichten: 1042
Re: Arduino en Selectrix
« Reactie #39 Gepost op: 20 juli 2015, 08:10:52 »
Ik denk ook dat je de CT (center tap) van de spoel aan de plus moet hangen.
Groet, Ronald.

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3529
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino en Selectrix
« Reactie #40 Gepost op: 20 juli 2015, 12:10:34 »
Paul,

Je gaat aardig vlot. Ik ben de software aan het testen. Heb er al wat kleine foutjes uitgehaald, dus deze versie is zeker niet geschikt om in je projecten te gebruiken. Wat beterft programmeren van randapparatuur aangesloten op de SX-bus. Dit is met geen van de door jouw genoemde programma's te doen. Maar kijk even op www.vandersel.nl onder Selectrix -> Download. Hier vindt je twee programma's:
- SX-tester: Hiermee kun je beperkt de SX-bus aansturen. Tevens zijn er twee regeleaars voor locomotieven. (Ook bestaat de mogelijkheid een decoder in SX1 formaat met de CC2000 te programmeren).
- InOut: Leest/bestuurt 8 adressen van de SX-bus in een keer.

Hier kan je wel wat mee denk ik.

Als de librarry af is wil ik er twee voorbeeldjes mee maken. De eerste is een seriële interface volgens het protocol dat jij nu gebruikt (de 66842 seriële interface), het tweede loop ik te denken aan een RGBW aansturing. Dit zal een zelfstandig randapparaat zijn dat op de bus kan worden aangesloten. Hierin komt tevens het programmeren van randapparaten aan bod. Ik wil daar eerst nog even met Karst Drenth over e-mailen, want ik wil zijn commando structuur, zoals hij die in zijn RGBW aansturing voor DCC gebruikt, gaan gebruiken. Ik wil even weten hoe hij daar tegenover staat.

Groet,

Gerard van der Sel.
Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

Timo

  • Team encyclopedie
  • Offline Offline
  • Berichten: 4670
Re: Arduino en Selectrix
« Reactie #41 Gepost op: 20 juli 2015, 13:35:45 »
Beide wilde ik gisteravond plaatsen maar ik had mijn vriendin al te weinig aandacht gegeven  :-X

Inderdaad, zo heb je mooi vuurwerk met de diodes en geen spanning op de uitgang.

Overigens denk ik dat je als blusdiodes ook gewoon 1N4148 kunt pakken.

Voor de transistor zou je ook beetje kunnen zoeken of voor een mosfet gaan, net wat je hebt liggen. Ligt er een beetje aan hoe veel stroom je ze wilt laten schakelen. Als je zelf een print laat maken zijn SMD MOSFETs een mooie keuze. Deze zijn erg goedkoop, kunnen vaak rond de 4A aan en op een gemaakte PCB zijn ze prima te solderen.

Maar Paul, wat voor centrale heb je eigenlijk? De Selectrix bus heeft wel wat maar het heeft ook wel weer zijn beperkingen.


Timo
Verzonden vanaf mijn desktop met Firefox

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3529
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino en Selectrix
« Reactie #42 Gepost op: 20 juli 2015, 14:05:51 »
Paul heeft een CC2000. Naast een handregelaar voor de locomotieven 1 t/m 9, ook de mogelijkheid om locomotieven 1 t/m 9 te programmeren. Heb er zelf jaren mee gereden. Uiteindelijk de centrale afgeschreven toen een van de buz71A voor de zoveelste keer de geest gaf.
Mogelijkheden:
- Rijden van treinen;
- Een SX-bus, welke een kopie van de rails bevat.
Voeding voor treinen en SX-bus is rond de 4A bij 15V ac. Ik heb zelf jaren gereden met een SX-bus power booster, eigen uitvinding ;).
Hierdoor 3,5 A voor treinen en 3,5 A voor de randapparaten.

Groet,

Gerard van der Sel.
Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3529
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino en Selectrix
« Reactie #43 Gepost op: 20 juli 2015, 14:13:02 »
Reactie op schema Paul,

Ik zou niet de GND van de SX-bus gebruiken, maar de GND van de Arduino. Deze zijn in principe gelijk, maar het is een beetje krom een schakeling met een Arduino te besturen en vervolgens de GND van een ander systeem te gebruiken.
Dus de twee SX-bus stekkers kun je uit je schema halen.

Groet,

Gerard van der Sel.
Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

smits66

  • Offline Offline
  • Berichten: 543
  • Schaal 1:160, Arduino
    • Modelspoor web
Re: Arduino en Selectrix
« Reactie #44 Gepost op: 20 juli 2015, 18:48:57 »
Hoi

Iedereen bedankt voor de opmerkingen.

Ik heb het schema aangepast, het zou nu moeten werken (moet ook geen schema's gaan tekenen laat op de avond  :P)



Timo en Gerard,

Ik gebruik de central control 2000 en de loc control 2000 in combinatie met de selectrix computer interface, deze set is via de computer gekoppeld aan Itrain en Rocrail, hoewel ik rocrail nog niet goed werkend heb.

De bezetmelder, functie-decoder en handmatig en halfautomatische trein sturing werkt wel via Itrain, de encoder A + B ben ik nog niet mee bezig, dat komt later.

Gerard , Helaas heb ik niets aan jou programmaatjes deze zijn voor Windows, ik draai Linux op mijn computer.

Ik wacht geduldig af, ik kan de sturing ook testen met de Arduino en later evt selectrix sx bus toevoegen.

Timo,

Ik probeer zo dicht mogelijk bij het originele ontwerp te blijven, bovendien hou ik wel van een robuuste sturing, voor de prijs hoef ik het niet te laten  de BD675 kost 30 a 35 cent de stuk, ik denk dat een mosfet net zo duur of duurder is, de 1n4148 kan ook wel als blus diode gebruiken, echter heb ik nog een stuk of 500, 1N4007 diodes thuis liggen (in schema 1N4004).
Voorlopig ben ik nog niet met een print ontwerp bezig, eerst de sturing goed testen en dan verder ontwerpen.

Mvg Paul
« Laatst bewerkt op: 20 juli 2015, 18:50:51 door smits66 »
Üdvözlet Paul Smits.


bouw draadje "Laubenstein"