Rangeerpuzzel (Inglenook) met Arduino besturing

[Timo]

Nee hoor Cees, 1 versie voldoet. Deze moet, in tegenstelling tot de versie van Walter, dan wel kloppen. Maar zodra je deze naar de andere kant flipt blijft deze gewoon kloppen. Zou nogal onhandig zijn als je voor elk onderdeel twee footprints zou moeten hebben.


Timo

[Cees Baarda]

Kijk, die had ik nog niet gevonden/gebruikt in KiCad (Flip). Dat maakt je leven weer wat plezieriger. Scheelt een aardige klus in de footprint editor.

Cees

[Timo]

Welkom in de wereld van double sided PCB's  De sneltoets, mocht je die nog niet gevonden hebben, is gewoon F. Zonder een functie als deze zou het maken van een dubbelzijdige printplaat wel erg lastig worden.

Heb overigens gevonden dat er best veel RJ12 connectoren bestaan... Wisselend van lipje boven en lipje onder etc. Dus daar zit de fout in de library. De footprint zelf is dus niet fout, maar ij hort niet bij deze connector 


Timo

[gvandersel]

Zelfde met de kleine transistors (sot-92). Daar roteren basis, emiter en collector eveneens. In Kicad zijn een stuk of 8 varianten te vinden.

Groet,

Gerard van der Sel.

[Timo]

Maar van de so-92 zijn de pinnummers wel altijd gelijk. Alleen de plaatsing van de pads verschilt een beetje. Maar iedere footprint moet gewoon werken, misschien met een beetje buigen van de pootjes. Dit omdat de pinnummers van een so-92 vast liggen 


Timo _{(die vanavond ook weer KiCad opstart om een Phono pre-amp op een PCB te krijgen  )}

[Cees Baarda]

Zo, na een tijdje minder aandacht voor dit baantje, weer eens een update>

Ik ben nu zo ver, dat er nieuwe zaken geprogrammeerd moeten worden. Om te beginnen de Arduino voor servo-aansturing. In de eerste versie had ik de eindstanden van de wissels hard gecodeerd in de sketch. Niet zo handig natuurlijk, maar ik was nog niet zo ver om dat anders te doen. Inmiddels ben ik met wat proeven bezig. 1 daar van is gebruik maken van de methode uit de MARDEC van NTeering. Een terminalprogramma is dan de hulp bij het instellen van de eindstanden. Nadeel; als je met een MAC werkt doet het terminalprogramma geen kleurtjes, zoals Nico had voorzien. Dat moet anders kunnen. Naast Arduino bestaat er ook het programma Processing. Als ik dat programma kon gaan gebruiken als de terminal, zou dat voor mij leuk zijn. Na een poosje fröbelen met dat programma en bedenken van een manier van communiceren (protocol vind ik een te groot woord) ben ik nu zover dat ik een servo van positie kan veranderen op mijn beeldscherm. Het schermpje van processing zou er uit kunnen zien als in onderstaande afbeelding:

Met de knopjes kun je in stappen van 1, 5 en 10 graden de servoarm verdraaien. Ik heb de standen groen en rood genoemd analoog aan de knoppen op bijv. een Intellibox. Dan is dat gelijk duidelijk.
Cancel betekent voor mij, de actie afbreken - er moet dan een code naar de Arduino, die dat duidelijk maakt.
Bewaar (OK) zal tegen de Arduino gaan zeggen deze stand op te slaan in EEPROM.
Zolang je de verticale rij knoppen bedient gaat er alleen een commando om de servo te verzetten naar de Arduino.

Ik zal proberen het instellen in een filmpje te zetten.

groet Cees

[Timo]

Kijk, dat lijkt mij al een heel stuk makkelijker dan via terminal. Ook al heb ik zelf een hekel aan Java  Misschien nog iets toevoegen om van servo/stand te wisselen? En een invulbox voor de stand? En was een slider met + en - knop niet makkelijker geweest?

En kom je een beetje uit met hele graden? Naar mijn mening is dat altijd nogal een grove schaal geweest voor wissels. Anders zou je nog over kunnen stappen op halve graden.


Timo

[Cees Baarda]

@Timo

Ook al heb ik zelf een hekel aan Java 

Dat was nou net de reden om geen velden en menu's te maken. Slider had ook leuk geweest, maar de implementatie was me te ingewikkeld.
Wat ik nu doe, gaat als volgt:
- de Arduino stuurt het commando: ik wil van servo1 de 'groene' stand ingesteld hebben.
- Processing fungeert dan als potmeter of 'stappen zetter', de gebruiker kijkt zelf of de stand voldoet en klikt dan OK
- dan vraagt de Arduino om de 'rode' kant te doen
- Processing is weer de regelaar
- Daarna volgt nog de snelheid
- de Arduino begint dan met het volgende servo, enz.

Kom ik met die graden uit?
Ik denk het niet, maar als proof of concept voldeed dit. Aangezien ik jouw library voor de servo's gebruik zal ik waarschijnlijk overstappen op de stapjes voor die library. Voorlopig is het me alleen te doen om de 2 servo's van mijn eerste printje te kunnen instellen.

Het voordeel van Processing is dat het meer dan een terminal kan zijn. (Er gaan trouwens gewoon strings heen en weer.) Ik werd getriggerd door een opmerking van Nico over gebrek aan ruimte in de Arduino Uno t.b.v. MARDEC. Door het vele gebruik van teksten naar de terminal was de Arduino snel vol. Processing geeft je dan de mogelijkheid een deel van de teksten daarheen te verhuizen, zodat je meer ruimte overhoudt voor leukere dingen. Misschien is het zelfs mogelijk om een deel van de instelprocedures naar de computer te verhuizen. Dat zeg je eigenlijk ook al met:

Misschien nog iets toevoegen om van servo/stand te wisselen?

groet Cees

[Timo]

Hehe, dat snap ik. 

Processing geeft je dan de mogelijkheid een deel van de teksten daarheen te verhuizen, zodat je meer ruimte overhoudt voor leukere dingen.

Dat is dan ook meer "zoals het hoort". Altijd al zonde gevonden om bergen karakters op te slaan op een kleine uC.

En inderdaad, het PC-einde de boel laten bepalen. Maakt het aan de Arduino zijde ook alleen maar makkelijker. Deze hoeft nu alleen state-less opdrachten uit te voeren als "geef huidige postitie servo 1 groen", "servo y, ga naar positie x", "sla x op als positie rood voor servo y" enz. Dan is het bijvoorbeeld ook makkelijk om eventueel een andere Arduino met scherm als "instel device" te bouwen bijvoorbeeld 


Timo

[Cees Baarda]

In post #80 heb ik een filmpje beloofd. Je kunt hem hier bekijken.

Wat zie je daar allemaal? Allereerst mijn testopstelling uit mijn eerste post. Een schakeling voor 2 wissels met relais voor het polariseren van het hartstuk. Het geheel wordt hier met de hand bediend door 2 schakelaars, die je ook kunt vervangen door 2 uitgangen van een decoder. Met deze werking ben ik tevreden.
Niet tevreden was ik met hoe ik e.e.a. toen heb opgelost met het zetten van de wisselstanden in de servo-sturing.  Ik had toen de eindstanden en de draaisnelheid hard gecodeerd in de Arduino. Dat is voor mij nu opgelost met deze hardware/software combinatie. Processing op de computer fungeert als bediening van de programmeermodus in het Arduino programma.
De software in de Arduino is hier al eens voorbijgekomen en is gebaseerd op de AdServo oplossing van Timo Engelgeer. Voor de programmeermodus en communicatie met Processing moest ik de code nog maken.
Om de programmeermodus in te komen heb ik een wat lastige methode die werkt, maar ook tegenstaat: houd de programmeerknop op de Arduino ingedrukt en start de processing-sketch. Doordat de Arduino herstart bij het ontstaan van een seriële verbinding en de test op de programmeerknop in Setup() staat, kom je in de programmeersituatie zoals in het filmpje. Hoe ik dat anders/eenvoudiger kan doen ben ik niet uitgekomen.

Het wordt nu tijd om e.e.a. onder het baantje te bouwen en eens te gaan rijden met de wisselsturing. Daarna zijn de "ontkoppelaars" aan de beurt.

groeit Cees

[Cees Baarda]

Een aanvulling op de vorige post:

In de Arduino wordt de programmeermodus in setup() geactiveerd:

Code: [Selecteer]

void setup()
{
...
...
  if (digitalRead(progKnop) == 0)
  {
    ....
    ....
   digitalWrite(LED, HIGH);
   servoInstellen();
  }

Dan komt het volgende aan bod:

Code: [Selecteer]

void servoInstellen()
{
  String tekst = "";
  for (byte servoNummer = 0; servoNummer < NrServos; servoNummer++)
  {
    // local variables
    boolean done = false;
    boolean wiggel = false;
   
    // stuur commando naar processing (evt. terminal)
    tekst = "SS " + String(servoNummer + 1, HEX) + String(" ");
    Serial.println(tekst);
    Serial.flush();

    // zet servo in de middenstand
    wisselServos.gotoPos(servoNummer,servoMid);
    wisselServos.update();
    while (!done)
    {
      while (Serial.available() > 0)
      {
        // De te ontvangen string bevat altijd: "CCCCC xxx yyy zzz" en wordt afgesloten met \n
                                              // de delen worden gescheiden door een spatie
                                              // CCCCC maximaal 10 karakters, hier gebruiken we er 2
                                              // xxx een int (10 .. 1012) voor een eindstand rood van de servo
                                              // yyy een int (10 .. 1012) voor een eindstand groen van de servo
                                              // zzz een int () voor de servosnelheid
                                              // De commando's kunnen zijn:
                                              // "SK" = skip deze servo
                                              // "SA" = save de meegestuurde waarden
                                              //        en save de ingestelde snelheid
                                              // "SR" = set servo in de stand xxx
                                              // "SG" = set servo in de stand yyy
                                              // "SW" = set wiggelen servo aan
                                              // "SD" = servo speed down
                                              // "SU" = servo speed up
        String commando = "";
        char comm[10];
        int aantal;
        aantal = Serial.readBytesUntil(' ', comm, 10);
        int standGroen, standRood, val3;
       
        for (int i = 0; i < aantal; i++)
        {
          commando = commando + String(comm[i]);
        }
     
        // look for the 3 next valid integers in the incoming serial stream:
        standGroen = Serial.parseInt();
        standRood = Serial.parseInt();
        val3 = Serial.parseInt(); // reserved, not used in this sketch
   
        // wacht op newline, dan zijn we aan het eind van een zin
        if (Serial.read() == '\n')
        {
          commando.toUpperCase();
          if (commando == "SG")
          {
            wisselServos.gotoPos(servoNummer, standGroen);
          }
          if (commando == "SR")
          {
          wisselServos.gotoPos(servoNummer, standRood);
          }
          if (commando == "SK")
          {
            done = true;
          }
          if (commando == "SA")
          {
            wisselServos.setEndPos(servoNummer, 0, standGroen);
            wisselServos.setEndPos(servoNummer, 1, standRood);
            //bewaar ze in EEPROM
            EEPROM.write(EEServoDirs + (servoNummer*2), (standGroen / 4));
            EEPROM.write(EEServoDirs + (servoNummer*2) + 1, (standRood / 4));
            servoSpeed_t servoSpeed = wisselServos.getSpeed(servoNummer);
            EEPROM.write(EEServoSpeedStep + servoNummer, servoSpeed.step);
            EEPROM.write(EEServoSpeedInterval + servoNummer, servoSpeed.interval);
            done = true;
          }
          if (commando == "SW")
          {
            wisselServos.gotoEndPos(servoNummer,0);
            wiggel = true;
          }
          if (commando == "SD")
          {
            wisselServos.speedDown(servoNummer);
          }
          if (commando == "SU")
          {
            wisselServos.speedUp(servoNummer);
          }
        }  // end if (Serial.read()
      } // end while (Serial.available(
      if (wiggel == true)
      {
        wiggelServo(servoNummer);
      }
      wisselServos.update();
    }  // end while (!done)
  } // end for-loop 1
  // We're done setting up. Let processing now.
  tekst = "XX " + String(255, HEX) + String(" ");
  Serial.println(tekst);
  Serial.flush();
  digitalWrite(LED,LOW);
} //end servoInstellen()

void wiggelServo(int i)

{
  if(!wisselServos.isActive(i)) //only change endPos after detached to wait @ endPos
  {   
    if(wisselServos.isAtEndPos(i, 0))
    {
        wisselServos.gotoEndPos(i, 1);
    }
    else if(wisselServos.isAtEndPos(i, 1)) 
    {
        wisselServos.gotoEndPos(i, 0);
    }
  }
}


De sketch in Processing (± 380 regels code) doet de rest zoals getoond in de film. Die code is nog niet voorzien van commentaar, dus die publiceer ik later of maak er een download van.

groet Cees

[Timo]

Hoe ik dat anders/eenvoudiger kan doen ben ik niet uitgekomen.

Aangezien de knop indrukken en dan Prcessing starten met je andere hand misschien wat lastiger is zou je ook kunnen gaan voor Processing starten, dan knopje indrukken en even de reset knop indrukken. Voorwaarde is dan wel dat je PRocessing sketch niet in de stress schiet als deze niet gelijk contact heeft

Je code zou ik alleen nog wat aanpassen. Vooral, laat String zo snel mogelijk vallen. Het is traag, omslachtig en vraagt heeeeel veel geheugen (iets waar menig persoon zijn sketch door heeft laten crashen door een aantal String objecten aan te maken). De regel

Code: [Selecteer]

tekst = "SS " + String(servoNummer + 1, HEX) + String(" ");
Vraagt bijvoorbeeld nu belachelijk veel geheugen doordat je werkt met drie String objecten!

Ook check je niet of wat je binnen krijgt correct is. Bijvoorbeeld de int's. Als deze niet komen en je krijgt een 0 terug dan voer je dit zonder nadenken uit. Nu is 0 instellen natuurlijk niet heel erg maar goed. Maar als er 30000 van gemaakt wordt voer je dit ook uit

En duurt een als SG nu niet erg lang? Of stuur je vanuit processing dan loze data mee voor xxx, yyy en zzz?

En zzz lijkt je als nog niet te gebruiken, correct?

Code: [Selecteer]

// wacht op newline, dan zijn we aan het eind van een zin
        if (Serial.read() == '\n')
Lijkt me niet zo handig. Wat als deze nooit komt? Of als het een ander character is? Wil je dan echt alles weggooien?

Ik heb de code iets aangepast, vooral wegens de String. De checks heb ik geladen, om dat goed te doen zou ik de hele code overhoop moeten gooien....  Zou ik zelf nog wel voor gaan.

Code: [Selecteer]

void servoInstellen(){
  for (byte servoNummer = 0; servoNummer < NrServos; servoNummer++){
    bool done = false;
    bool wiggel = false;
   
    Serial.print(F("SS"));
    Serial.print(servoNummer + 1, HEX);
    Serial.println(" "); //<--- deze kan deze ik wel weg, de '\n' lijkt me genoeg?
   
    // zet servo in de middenstand
    wisselServos.gotoPos(servoNummer,servoMid);
    wisselServos.update();
   
    while(!done){
      //wachten op serial
      while(Serial.available())
      { 
        // De te ontvangen string bevat altijd: "CCCCC xxx yyy zzz" en wordt afgesloten met \n
        // de delen worden gescheiden door een spatie
        // CCCCC maximaal 10 karakters, hier gebruiken we er 2
        // xxx een int (10 .. 1012) voor een eindstand rood van de servo
        // yyy een int (10 .. 1012) voor een eindstand groen van de servo
        // zzz een int () voor de servosnelheid
        // De commando's kunnen zijn:
        // "SK" = skip deze servo
        // "SA" = save de meegestuurde waarden
        //        en save de ingestelde snelheid
        // "SR" = set servo in de stand xxx
        // "SG" = set servo in de stand yyy
        // "SW" = set wiggelen servo aan
        // "SD" = servo speed down
        // "SU" = servo speed up
       
        char command[11]; //een plaats extra voor een '\n'
        byte aantalBytes = Serial.readBytesUntil('', command, 10);
        command[aantalBytes] = '\n'; //altijd eindigen met een '\n'
       
        int standGroen = Serial.parseInt();
        int standRood = Serial.parseInt();
        int servoSpeed = Serial.parseInt();
       
        toUpper(command);
       
        //laten staan omdat je het nu eenmaal stuurt
        if (Serial.read() == '\n')
        {
          if (!strcmp(command, F("SG")))
          {
            wisselServos.gotoPos(servoNummer, standGroen);
          }
          //else if, want als het SG was kunnen we gewoon stoppen met zoeken
          else if (!strcmp(command, F("SR")))
          {
            wisselServos.gotoPos(servoNummer, standRood);
          }
          else if (!strcmp(command, F("SK")))
          {
            done = true;
          }
          else if (!strcmp(command, F("SA")))
          {
            wisselServos.setEndPos(servoNummer, 0, standGroen);
            wisselServos.setEndPos(servoNummer, 1, standRood);
            //bewaar ze in EEPROM
            EEPROM.write(EEServoDirs + (servoNummer*2), (standGroen / 4));
            EEPROM.write(EEServoDirs + (servoNummer*2) + 1, (standRood / 4));
            servoSpeed_t servoSpeed = wisselServos.getSpeed(servoNummer);
            EEPROM.write(EEServoSpeedStep + servoNummer, servoSpeed.step);
            EEPROM.write(EEServoSpeedInterval + servoNummer, servoSpeed.interval);
            done = true;
          }
          else if (!strcmp(command, F("SW")))
          {
            wisselServos.gotoEndPos(servoNummer,0);
            wiggel = true;
          }
          else if (!strcmp(command, F("SD")))
          {
            wisselServos.speedDown(servoNummer);
          }
          else if (!strcmp(command, F("SU")))
          {
            wisselServos.speedUp(servoNummer);
          }
        }  // end if (Serial.read()
      } // end while (Serial.available(
       
      if (wiggel == true)
      {
        wiggelServo(servoNummer);
      }
      wisselServos.update();
    }  // end while (!done)
  } // end for-loop 1

  // We're done setting up. Let processing know.
  Serial.println(F("XX FF"));

  digitalWrite(LED,LOW);
} //end servoInstellen()

//Hele string naar uppercase
void toUpper(&in){
  for(unsigned int i = 0; i < strlen(in); i++){
    in[i] = toupper(in[i]);
  }
 
}


Timo

[Cees Baarda]

Ik hou wel van een beetje spitsroeden lopen.
Ook in de Processing sketch doe ik net alsof mijn Arduino, de MAC en de USB-verbinding perfect hun werk doen. Uiteindelijk moeten er natuurlijk gedegen controles om de hele communicatie heen komen. Ik was begonnen met heen en weer sturen van strings omdat decoderen dan wat eenvoudiger leek. Daarbij ben ik er vanuit gegaan dat per servo de 3 in te stellen waarden steeds heen en weer zouden gaan. Gaandeweg bleek natuurlijk dat op een andere ook manier kan en misschien beter is. Bij het instellen van de snelheid is de oplossing daardoor al anders geworden dan bedacht. Vandaar de inmiddels overbodige 'zzz'.
@Timo ik kan tussen de regels lezen dat je de processing-kant mist. Je krijgt een PB.

Nog te doen (kan wel een paar weken duren, eerst andere prioriteiten):
- Ik stuur pas een 'save'-commando als de hele servo ingesteld is. Tot dat moment bewaart Processing de waarden voor 'groen' en 'rood'. Daarna gaat e.e.a. in de Arduino pas naar EEPROM. Je zou eigenlijk in staat moeten zijn iedere instelling apart over te slaan, terwijl ik nu 'skip servo' heb gedaan. Het is immers niet nodig opnieuw in te stellen als de servo al goed staat. Dat betekent dat de beginsituatie (de twee eindstanden) ook naar Processing moet.
- Overbodige code is nog niet helemaal opgeruimd.
- De communicatie kan anders, daar is de reactie van Timo een grote hulp bij .

[Timo]

  Maar goed bezig hoor Cees!

Wat betreft de communicatie zou ik vooral kijken of je het meer als een parallel proces kunt opzetten icm een soort state machine ipv alles sequentieel afhandelen. Dus misschien ipv de huidige lange commando's ook meer een soort command en payload structuur die heen en weer werkt.

Hopelijk kan ik binnenkort adServo ook weer wat beter oppakken. Ik ben eigenlijk niet zo tevreden met de huidige libraries waar het op draait, zowel ServoExtend als ServoController. Ik wil deze toch wat makkelijker zien te maken. En überhaupt het programma wat meer stroomlijnen en eindelijk DCC! Dat is toch eigenlijk de grootste reden geweest voor adServo nietwaar 


Timo