[Arduino] Klokje met shift-registers in Simulide

[kitao]

Dit topic geeft een indicatie hoe in zes stappen een klokje/looplicht opgezet zou kunnen worden.
Daarbij is enkel gebruik gemaakt van de software van Simulide en Arduino.
In het echt zou het Simulide gedeelte overgeslagen kunnen worden.
In theorie althans, dit is niet met een echte Arduino getest.

Stap 1.

Om in- en uit te zoomen zonder wieltjes muis , gebruik twee vingers op de touchpad.

Hier te downloaden en meer info :
http://simulide.blogspot.com/     

Het leuke van deze software is dat het o.a. een micro-controller kan simuleren. Een bekende populaire micro is Arduino. Ook daar moet dan software van worden gedownload, de micro zelf hoeft niet aanwezig te zijn.

https://www.arduino.cc/en/Guide/HomePage

Is engels-talig maar eventueel kan je de pagina automatisch laten vertalen naar Nederlands.

Nog een paar linkjes die laten zien hoe je programma's voor de arduino kunt overzetten naar simulide :

YouTube: SimulIDE Arduino Blink Basic

YouTube: SimulIDE 0.0.2 Simulator: Arduino barGraph example

Laad een nieuw sketch in het arduino scherm en klik op file - preferences. Vink verbose output compilation aan. Klik daarna op V verify , je krijgt dan onderin de build-gegevens. Zonder verbose output te vinken krijg je die niet, vandaar. Zoek in de build gegevens naar een hex-file, select en ctrl+C om te kopieren.
Dat ziet er zo uit :

C:\\Users\\kitao\\AppData\\Local\\Temp\\arduino_build_844847/sketch_feb13b.ino.hex

en moet dit worden :

C:\Users\kitao\AppData\Local\Temp\arduino_build_844847\sketch_feb13b.ino.hex

Plak die laatste in een tijdelijk notepadje, is handig als je die nog nodig hebt. Hoewel, het blijkt namelijk dat zolang hetzelfde uno-programma open blijft dit pad niet meer verandert en bovendien heb je die volgens de video maar 1 keer nodig want bij wijziging uno-programma hoef je in Simul enkel op reload te klikken.
Vervolgens in Simul, rechtsklik op de Arduino en klik Load firmware en plak de hex erin en klik Open.

Een iets snellere methode hiervoor komt in een volgende post.

[ Voor 7% gewijzigd door kitao op 16-03-2019 20:13 . Reden: Topic-intro toegevoegd ]

[kitao]

Een snellere en makkelijkere methode om een hex-file in Simulide te krijgen, die staat hier :

https://www.botshop.co.za/2017/02/

In het kort, klik in Arduino software op Sketch, klik op Export compiled Binary.
In die link staat ook een video maar vond dat eerder verwarrend als verduidelijkend.

Er zijn een paar typen Arduino micro-controller units (Mcu), de Uno is het meest gebruikt.

Zet er een programma in, ook wel sketch of code genoemd en de leds komen in beweging.

code:

//  Om de 2 seconden gaat een led branden, er zijn 3 seconden leds
//  Elke led moet 20 seconden voorstellen
int S00 = 10;      // De drie seconden leds
int S20 = 11;
int S40 = 12;

void setup() {                
  // initialize the digital pin as an output.
  pinMode(S00, OUTPUT);   
  pinMode(S20, OUTPUT);  
  pinMode(S40, OUTPUT);    
}
void loop() {
delay(2000);                     // wait for 2 secondS
digitalWrite(S00, HIGH);    // turn the LED on (HIGH is the voltage level)
delay(2000);                     // wait for 2 secondS
digitalWrite(S20, HIGH);    // turn the LED on (HIGH is the voltage level)
delay(2000);                     // wait for 2 secondS
digitalWrite(S40, HIGH);     // turn the LED on (HIGH is the voltage level)
delay(2000);                      // wait for 2 secondS
digitalWrite(S00, LOW);      // turn the LED off by making the voltage LOW
digitalWrite(S20, LOW);      // turn the LED off by making the voltage LOW
digitalWrite(S40, LOW);      // turn the LED off by making the voltage LOW
}

[ Voor 5% gewijzigd door kitao op 17-03-2019 21:46 . Reden: In het kort ]

[Room42]

kitao schreef op zaterdag 16 maart 2019 @ 00:47:
Dat ziet er zo uit :

C:\\Users\\kitao\\AppData\\Local\\Temp\\arduino_build_844847/sketch_feb13b.ino.hex

en moet dit worden :

C:\Users\kitao\AppData\Local\Temp\arduino_build_844847\sketch_feb13b.ino.hex

@kitao Wil je even een TeamViewer starten en je ID en wachtwoord hier posten, dan kan ik even in jouw lokale Temp-folder kijken.

edit:
Ah, je bedoelt dat het path zo genoteerd moet worden. Akkoord

@kitao Misschien goed om voor het eerste filmpje even een introductietekst te schrijven, zodat het duidelijk is wat je nou precies wilt met dit topic. Ik begrijp nu dat het een soort van howto/guide is maar ik dacht echt dat je naar de hex files probeerde te linken.

[ Voor 85% gewijzigd door Room42 op 16-03-2019 01:00 ]

[kitao]

Room42 schreef op zaterdag 16 maart 2019 @ 00:53:
@kitao Wil je even een TeamViewer starten en je ID hier posten, dan kan ik even in jouw lokale Temp-folder kijken.

Ik weet echt totaal niet waar je het over hebt, en dat is geen grap, TV en TF zeggen mij niets. Heb wel je edit gelezen, de opzet is aan het einde van dit voorbereide topic, na slechts 5 postjes, wel duidelijk hoop ik.

Ps\
Bedankt voor de tip, heb een intro toegevoegd

********

Zonder code in de micro gebeurt er niks en dat is meteen het nadeel, wie zelf geen code kan schrijven zal voorbeelden moeten gebruiken.
Daar zijn er wel veel van, zoals op deze website :

https://www.arduino.cc/en/Tutorial/BuiltInExamples

Na verloop van tijd wordt dan vanzelf de basis van programmeren duidelijk of je begint aan een paar lessen daarover, zoals deze bijvoorbeeld :

https://arduino-lessen.nl/

Zelf programmeren heeft wel voordeel, zo kan je je eigen ontwerp maken dat niet in een voorbeeld staat. Programmeren is zoiets als wiskunde, er komt vrijwel geen einde aan en het wordt steeds complexer maar met de basis valt al genoeg mee te maken, zoals een klokje die stap voor stap is opgebouwd.

code:

// Er zijn 3 seconden leds, 3 minuten leds en 3 uren leds
// Elke led moet een bereik van 15 seconden, 15 minuten of 3 uren voorstellen
// Drie leds op een rijtje in de uitstand betekent dat de 'wijzer' tussen de 60 en 15 staat.
// De blinde vlek in deze 'klok' is dus 3 uur.

int t = 1000; // Verander hiermee de Delays in één keer.

int S15 = 4;  int S30 = 5;  int S45 = 6;       // De seconden leds
int M15 = 7;  int M30 = 8;  int M45 = 9;       // De minuten leds
int U15 = 10; int U30 = 11; int U45 = 12;      // De uren leds

void setup() {   // initialize the digital pins as an output.      
  pinMode(S15, OUTPUT) ; pinMode(S30, OUTPUT); pinMode(S45, OUTPUT); 
  pinMode(M15, OUTPUT) ; pinMode(M30, OUTPUT); pinMode(M45, OUTPUT);  
  pinMode(U15, OUTPUT) ; pinMode(U30, OUTPUT); pinMode(U45, OUTPUT);      
}

void loop() {
      for (int u = 1; u < 5; u++) {     // lus voor UREN
        if (u == 1){
          digitalWrite(U15, LOW);       // alle leds uit 
          digitalWrite(U30, LOW);       // positie 1
          digitalWrite(U45, LOW);       // bereik 60-15 
          delay(t);          }           // wait for t seconds
              if (u == 2){
          digitalWrite(U15, HIGH);      // zet led U15 aan, bereik 15-30
          delay(t); }                     // wait for t seconds
              if (u == 3){
          digitalWrite(U30, HIGH);      // zet led U30 aan, bereik 30-45 
          delay(t);  }                   // wait for t seconds
                  if (u == 4){
          digitalWrite(U45, HIGH);      // zet led U45 aan, bereik 45-60 
          delay(t); }                    // wait for t seconds
          
      for (int m = 1; m < 5; m++) {  // geneste lus voor MINUTEN
        if (m == 1){
          digitalWrite(M15, LOW);       // alle leds uit 
          digitalWrite(M30, LOW);       // positie 1
          digitalWrite(M45, LOW);       // bereik 60-15 
          delay(t);          }           // wait for t seconds
              if (m == 2){
          digitalWrite(M15, HIGH);      // zet led M15 aan, bereik 15-30
          delay(t); }                     // wait for t seconds
              if (m == 3){
          digitalWrite(M30, HIGH);      // zet led M30 aan, bereik 30-45 
          delay(t);  }                   // wait for t seconds
                  if (m == 4){
          digitalWrite(M45, HIGH);      // zet led M45 aan, bereik 45-60 
          delay(t); }                    // wait for t seconds
          
      for (int s = 1; s < 5; s++) {  // geneste lus voor SECONDEN
        if (s == 1){
          digitalWrite(S15, LOW);       // alle leds uit 
          digitalWrite(S30, LOW);       // positie 1
          digitalWrite(S45, LOW);       // bereik 60-15 
          delay(t);          }           // wait for t seconds
              if (s == 2){
          digitalWrite(S15, HIGH);      // zet led S15 aan, bereik 15-30
          delay(t); }                     // wait for t seconds
              if (s == 3){
          digitalWrite(S30, HIGH);      // zet led S30 aan, bereik 30-45 
          delay(t);  }                   // wait for t seconds
                  if (s == 4){
          digitalWrite(S45, HIGH);      // zet led S45 aan, bereik 45-60 
          delay(t); } } } }               // wait for t seconds
}

[ Voor 1% gewijzigd door kitao op 16-03-2019 20:24 . Reden: Ps\ ]

[kitao]

Er zijn nu al 9 leds en daar zijn 9 pinnen voor nodig en de Uno heeft ca. 18 pinnen die als output gebruikt kunnen worden dus die zijn snel op.
Om grotere aantallen leds te gebruiken worden er daarom IC's, integrated circuits oftwel chips, toegevoegd.
In deze opstelling heb ik voor de 74HC595 gekozen, waarvan hier meer toelichtingen :

https://www.arduino.cc/re...ons/advanced-io/shiftout/
https://www.arduino.cc/en/Tutorial/ShiftOut
http://artimesdiy.nl/inde...catid=46:lessen&Itemid=76


^{klik voor groter, je komt dan in imgur, klik er nog een keer op}

Led M00 die toch al constant Laag werd gehouden afgekoppeld om er een Latch van te maken want alle pinnen zijn nu vol aan de beneden zijde van de Uno.
Pin 12 is Data en 13 de Clock.
Chip 2 nog niets aan gedaan behalve de ledjes erop gezet, die moet vanaf 9 t/m 12 gaan tellen.
Wou er ook nog een mogelijkheid inzetten om tenminste de uren van tevoren te kunnen instellen zodat er niet tot middernacht gewacht hoeft te worden om de klok gelijk te krijgen. Niet dat de Simulide het zo lang volhoudt, dan is die al lang en breed vastgelopen, meestal houdt die het slechts 5 minuten vol.

Hier een afbeelding hoe chip1 zit aangesloten, chip2 doet nog niks


^{klik voor groter}

code:

// 0011 =  3 = 2^2 - 1
// 0111 =  7 = 2^3 - 1
// 1111 = 15 = 2^4 - 1  etc.
// Met deze benadering valt er een lus te maken.
// pow bleek nodig te zijn om machts te verheffen (in shiftout regel 22) 
// Uren-led U00 blijft net als bij de minuten-led M00 buiten beeld.

int latchpin = 6;     // Pin aangesloten op ST_CP van 74HC595
int clockpin = 13;   //  Pin aangesloten op SH_CP van 74HC595
int datapin = 12;   //   Pin aangesloten op DS    van 74HC595
int t = 1000;      //    Verander hier de snelheid in milli-seconden

void setup() {
  pinMode(latchpin, OUTPUT);    // Zet de pinnen op Output
  pinMode(clockpin, OUTPUT);
  pinMode(datapin,  OUTPUT);
}
void loop() {
  for (int i = 2 ; i < 9 ; i++) { 
    
    digitalWrite(latchpin, LOW);  // Latchpin laag
    shiftOut  (  datapin, clockpin, LSBFIRST,  pow ( 2 , i ) - 1  );
    digitalWrite(latchpin, HIGH); // Latchpin Hoog
    
    delay(t);   }   // delay + einde for-lus
    
    digitalWrite(latchpin, LOW);  // Latchpin laag
    shiftOut  (  datapin, clockpin, LSBFIRST, 0  );  // Alle leds uit
    digitalWrite(latchpin, HIGH); // Latchpin Hoog
    
    delay(t);  
    
}  // return naar void loop

[kitao]

- Voor opbouw deze websites geraadpleegd :
https://www.arduino.cc/en/Tutorial/ShiftOut
http://artimesdiy.nl/inde...catid=46:lessen&Itemid=76
- Datasheet : http://www.ti.com/lit/ds/symlink/sn74hc595.pdf

- Dit schema zit in een virtuele omgeving en om de leds wat feller op de monitor te krijgen, 120 Ohm weerstanden toegepast. In het echt is toch wel minstens 220 Ohm aan te raden, of zoals in de Tutorial 470 Ohm. Daar staat ook iets over een condensator.
- De twee 5 Volt schakelaars onderin betekent niet dat er in het echt extra voeding nodig is.
- De codes in de Tutorial kunnen gebruikt worden als de nummers voor de pinnen latch, data, clock, worden gewijzigd.

[Pow]
Het gebruik daarvan gaf onverwachte gevolgen want er bleek dat bijvoorbeeld 2 kwadraat geen 4 oplevert maar 3.9999 omdat het een float/double is. Vertaald naar een int krijg je dan als resultaat 3 ipv 4. Dit had als bijkomstig gevolg dat ik Q7 van chip2 heb overgeslagen.
In de eerste schakeling heb ik een extra latch-pin erbij gezet, A5. Door deze een puls te geven wordt de data ingelezen op chip2. Op die manier krijgt iedere chip zn eigen data. Led U00 is draadje doorgeknipt, die wou ik namelijk uit laten en kwam toevallig ook beter uit bij het programmeren.


^{klik voor groter, je komt dan in imgur, klik er nog een keer op}


De code daarvan is :

code:

// 0011 =  3 = 2^2 - 1
// 0111 =  7 = 2^3 - 1
// 1111 = 15 = 2^4 - 1  etc.
// Met deze benadering valt er een lus te maken.
// Vreemd is wel dat Q7 constant uit blijft, er gaat ergens een bit verloren (in Simulide althans)
// Verwijder je de for-lus en je schrijft alles regel voor regel uit dan gebeurt dat niet, 
// dus met bijv. shiftOut(datapin, clockpin, LSBFIRST, 3); gaat Q7 wel aan. Dit kwam door Pow.
// Pow bleek nodig te zijn om machts te verheffen (in shiftout regel), zie ook toelichting in post. 
// Uren-led U00 blijft net als bij de minuten-led M00 buiten beeld.
// Extra Latchpin aangesloten, dit bleek wmb de makkelijkste oplossing voor deze opstelling.

int latchpin  =  6;      // Pin aangesloten op ST_CP van 74HC595
int clockpin  = 13;     //  Pin aangesloten op SH_CP van 74HC595
int datapin   = 12;    //   Pin aangesloten op DS    van 74HC595
int latchpin2 = A5;   //    Pin aangesloten op ST_CP van 74HC595 Chip2 
int t = 1000;        //     Verander hier de snelheid in milli-seconden

void setup() {
  pinMode(latchpin,  OUTPUT);    // Zet de pinnen op Output
  pinMode(clockpin,  OUTPUT);
  pinMode(datapin,   OUTPUT);
  pinMode(latchpin2, OUTPUT);
}
void loop() {
    delay(t);
  for (int i = 2 ; i < 9 ; i++) {    // Stuur leds chip1 aan
    digitalWrite(latchpin, LOW);    //  Latchpin Laag
    shiftOut  (  datapin, clockpin, LSBFIRST,  pow ( 2 , i )    ); // Resultaat wordt 2^i - 1
    digitalWrite(latchpin, HIGH); //    Latchpin Hoog    
    delay(t);   }                //     delay + einde for-lus

  for (int i = 2 ; i < 6 ; i++) {     // Stuur leds chip2 aan
    digitalWrite(latchpin2, LOW);    //  Latchpin Laag
    shiftOut  (  datapin, clockpin, LSBFIRST,  pow ( 2 , i )    ); // Resultaat wordt 2^i - 1
    digitalWrite(latchpin2, HIGH); //    Latchpin Hoog
    delay(t);   }                 //     delay + einde for-lus       
    
    digitalWrite(latchpin, LOW);        // Latchpin Laag
    shiftOut  (  datapin, clockpin, LSBFIRST, 0  );  // Alle chip1 leds uit
    digitalWrite(latchpin, HIGH);     //   Latchpin Hoog
    digitalWrite(latchpin2, LOW);    //    Latchpin Laag
    shiftOut  (  datapin, clockpin, LSBFIRST, 0  );  // Alle chip2 leds uit
    digitalWrite(latchpin2, HIGH); //      Latchpin Hoog          
}  // return naar void loop()

Volgende stap is ongeveer hetzelfde schema maar het verschil met de vorige opstelling is dat de data vanuit chip1 Q7' naar de DS-pin doorschuift op chip2. Ook is er dan geen extra Latchpin nodig.

code:

// 0011 =  3 = 2^2 - 1
// 0111 =  7 = 2^3 - 1
// 1111 = 15 = 2^4 - 1  etc.
// Met deze benadering valt er een lus te maken.
// Voor deze sketch heb ik als vorbeeld de functie void blinkAll_2Bytes() gebruikt uit de Arduino Tutorial, code 2.2
// https://www.arduino.cc/en/Tutorial/ShiftOut
// en het bespaart een pin in vergelijking met de vorige opstelling.
// Ipv Pow heb ik nu bit shift toegepast, meer info hier :
// https://forum.arduino.cc/index.php?topic=66146.0 

int latchpin  =  6;      // Pin aangesloten op ST_CP van 74HC595
int clockpin  = 13;     //  Pin aangesloten op SH_CP van 74HC595
int datapin   = 12;    //   Pin aangesloten op DS    van 74HC595
int t = 1000;         //    Verander hier de snelheid in milli-seconden

void setup() {
  pinMode(latchpin, OUTPUT);    // Zet de pinnen op Output
  pinMode(clockpin, OUTPUT);
  pinMode(datapin,  OUTPUT);
}
void loop() {
  delay(t);                                        // Wacht een 'uur'.
  
   digitalWrite(latchpin, 0);                    // Vul chip1 en chip2 met nul.
   shiftOut(datapin, clockpin, LSBFIRST , 0 );
   shiftOut(datapin, clockpin, LSBFIRST , 0 );
   digitalWrite(latchpin, 1);
   
  for (int x = 2; x < 9 ; x++) {            // For-lus voor chip1
    int y = 1 << x;                        //  Bit shift levert een macht van twee (2^x) op.
    y--;                                  //   Verminder 2^x met 1.
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin, LSBFIRST , 0 );   // Vul chip1 met 0.     
    shiftOut(datapin, clockpin, LSBFIRST , y );  //  Vul chip1 met y, de 0 schuift vanuit Q7' door naar chip2.
    digitalWrite(latchpin, 1);
   delay(t);                                   // Wacht een 'uur'.
  }     // Einde eerste for-lus, chip1 zit vol met U00 t/m U07
  
  for (int x = 2; x < 6 ; x++) {           // For-lus voor chip2
    int y = 1 << x;                       // Bit shift levert een macht van twee (2^x) op.
    y--;                                 //  Verminder 2^x met 1.
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin, LSBFIRST , y );     // Vul chip1 met y.
    shiftOut(datapin, clockpin, LSBFIRST , 255 );  //  Vul chip1 met 255, de y schuift vanuit Q7' door naar chip2.
    digitalWrite(latchpin, 1);
   delay(t);                                     // Wacht een 'uur'.
  }    // Einde tweede for-lus , chip1 zit vol met U00 t/m U07 en chip2 zit vol met U08 t/m U11.
  
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin,  LSBFIRST , 0  );   // Uur 0 heeft geslagen, zet de leds uit.
    shiftOut(datapin, clockpin,  LSBFIRST , 0  );
    digitalWrite(latchpin, 1);
    
}   // Return naar void loop.

[kitao]

Dit is dan in principe de laatste stap, de vorige opstelling is samengevoegd met de seconden en minuten.

De tijd zou nu minimaal 09 : 41 : 40 en maximaal 09 : 43 : 19 moeten zijn (in stappen van 100 seconden).

Naar mijn theorie moet delay t op 100000 gezet worden om de werkelijke kloksnelheid te benaderen.
Dit heb ik niet de gehele cyclus van 12 uren getest aangezien Simulide een hekel aan grote delays lijkt te hebben en anderzins het ook niet langer als een minuut of 7 volhoudt.
De gehele cycus lijkt wel soepel en in één tempo te lopen als je de delay bijvoorbeeld op 100 zet.

Sowieso is het dan een leuk loop lichtje   



^{klik voor groter, je komt dan in imgur, klik er nog een keer op}

code:

// De weerstanden zijn afgebeeld als 120 Ohm,in het echt is minstens 220 Ohm te adviseren.
// De klok kan op ieder geheel uur gelijkgesteld worden, stel het is 09:00
// zet dan counter_U op 10 en start de Arduino om 09:00 (Uren 1 hoger, maar niet op 13 zetten, kies dan 1).
// De Q7 van chip2 is 'overgeslagen' omdat dit makkelijker te programmeren bleek.
// Led M00 en U00 zijn niet aangesloten, dit ter indicatie van minuut 60/00 en uur 24/00.

int t = 100;           // Verander hiermee de kloksnelheid (in milliseconden) in één keer.
int counter_U = 1;    //  Counter voor de (12) uren. Bij vooraf INSTELLEN klok, zet deze vanaf 1 T/M 12. Beginstand is 1.
int counter_M = 0;   //   Counter voor de (10) minuten. 

int S00 = 0;  int S10 = 1;   int S20 = 2;   // De seconden leds
int S30 = 3;  int S40 = 4;   int S50 = 5;   // De seconden leds 
int M00 = 6;  int M10 = 7;   int M20 = 8;   // De minuten leds
int M30 = 9;  int M40 = 10;  int M50 = 11;  // De minuten leds    
int latchpin  =  6;      // Pin aangesloten op ST_CP van 74HC595
int clockpin  = 13;     //  Pin aangesloten op SH_CP van 74HC595
int datapin   = 12;    //   Pin aangesloten op DS    van 74HC595

void setup() {   // Zet de pinnen als output.      
  pinMode(S00, OUTPUT) ; pinMode(S10, OUTPUT); pinMode(S20, OUTPUT); 
  pinMode(S30, OUTPUT) ; pinMode(S40, OUTPUT); pinMode(S50, OUTPUT);
  pinMode(M00, OUTPUT) ; pinMode(M10, OUTPUT); pinMode(M20, OUTPUT); 
  pinMode(M30, OUTPUT) ; pinMode(M40, OUTPUT); pinMode(M50, OUTPUT);
  digitalWrite(S00, HIGH);         // S00 aan, deze blijft constant aan.  
  digitalWrite(M00, LOW);         //  M00 uit, deze blijft constant uit.  
  pinMode(latchpin, OUTPUT);     //   Zet de stuurpinnen naar de chips op Output
  pinMode(clockpin, OUTPUT);
  pinMode(datapin,  OUTPUT);   
}
void loop() {
      counter_M++;    // Verhoog de minuten counter met 1
      delay(t);      //     Wacht t seconden  
  for (int s = 1; s < 6; s++) {     // Hier worden de seconden-leds aangezet
    switch (s) {
    case 1: digitalWrite(S10, HIGH); break;
    case 2: digitalWrite(S20, HIGH); break;
    case 3: digitalWrite(S30, HIGH); break;
    case 4: digitalWrite(S40, HIGH); break;
    case 5: digitalWrite(S50, HIGH); break; } // einde switch/case
      delay(t); } // wacht t seconden + einde for-lus
    digitalWrite(S10, LOW);digitalWrite(S20, LOW);digitalWrite(S30, LOW);
    digitalWrite(S40, LOW);digitalWrite(S50, LOW);   // reset de seconden
  if (counter_M == 6) {  // Check of de minuten vol zijn
    digitalWrite(M10, LOW);digitalWrite(M20, LOW);digitalWrite(M30, LOW);
    digitalWrite(M40, LOW);digitalWrite(M50, LOW);  // Reset de minuten
          counter_M = 0;         // reset minuten counter 
          counter_U++;          //  Verhoog de uren counter met 1
      if (counter_U > 1 ) {    //   if-conditie. Na de eerste sec/min ronde,
      Uren();             }   //    spring naar Uren-functie + einde if-conditie voor counter_U.
                      }      //  einde if-conditie voor counter_M
      switch (counter_M) {  // Hier worden de minuten-leds aangezet
      case 1: digitalWrite(M10, HIGH); break;
      case 2: digitalWrite(M20, HIGH); break;
      case 3: digitalWrite(M30, HIGH); break;
      case 4: digitalWrite(M40, HIGH); break;
      case 5: digitalWrite(M50, HIGH); break; } // Einde switch/case
}                     // Return naar void loop

void Uren() {       // Dit is de Uren-functie
     
  for (int u = counter_U ; u < 9 ; u++) {   // For-lus voor chip1
    int y = 1 << u;                        //  Bit shift levert een macht van twee (2^x) op.
    y--;                                  //   Verminder 2^x met 1.
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin, LSBFIRST , 0 );   // Vul chip1 met 0.     
    shiftOut(datapin, clockpin, LSBFIRST , y );  //  Vul chip1 met y, de 0 schuift vanuit Q7' door naar chip2.
    digitalWrite(latchpin, 1);
  if ( u != 8 ) {     // Check of de eerste chip alle U-leds heeft branden, zo ja dan geen return naar void-loop
  return ;      }    //  Einde if-conditie voor u != 8
    }               //   Einde eerste for-lus, chip1 zit vol met U00 t/m U07

  if (counter_U >= 9 && counter_U <= 12) {              // if-conditie om te checken of chip2 chip2 uren-leds moet gaan aanzetten
    for (int u2 = counter_U - 7 ; u2 < 6 ; u2++) {     //  For-lus voor chip2
    int y = 1 << u2;                                  //   Bit shift levert een macht van twee (2^x) op.
    y--;                                             //    Verminder 2^x met 1.
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin, LSBFIRST , y );    //      Vul chip1 met y.
    shiftOut(datapin, clockpin, LSBFIRST , 255 ); //       Vul chip1 met 255, de y schuift vanuit Q7' door naar chip2.
    digitalWrite(latchpin, 1);
  if ( u2 != 5 ) {                              //         Check of de tweede chip 4 U-leds heeft branden, zo ja dan geen return naar void-loop
  return ;       }                             //          Einde if-conditie u2 != 5
  
  }                                          // Einde tweede for-lus , chip1 zit vol met U00 t/m U07 en chip2 zit vol met U08 t/m U11.
  }                                         //  Einde if-conditie counter_U >= 9 && counter_U <= 12

 if (counter_U == 13) {                   //    if-conditie om te testen of er 12 uren zijn verstreken
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin,  LSBFIRST , 0  );   // Het is nu 12 uur, zet de Uren-leds uit.
    shiftOut(datapin, clockpin,  LSBFIRST , 0  );
    digitalWrite(latchpin, 1);
    counter_U = 1;                   // 'Reset' de uren-counter op 1
                      }             //   Einde if-conditie counter_U == 13
 }                                 //    Einde Uren-functie, return naar void loop.

Suggesties ter verbetering van schema en/of code zijn altijd welkom, evenals vragen, het melden van geconstateerde fouten, IRL on-overeenkomstigheden, en etc.
Ben van plan nog een post toe te voegen waarbij de cyclustijd via de seriële monitor wordt getest.
.

[ Voor 0% gewijzigd door kitao op 16-03-2019 17:30 . Reden: spelfout ]

[Damic]

Je kan een mega nemen dan heb je meer pinnen maar ik zou eens kijken naar shift registers heb je maar een paar pinnen nodig.

[kitao]

Damic schreef op zaterdag 16 maart 2019 @ 07:34:
Je kan een mega nemen dan heb je meer pinnen.

Dat heb ik inderdaad overwogen maar wou het zo bereikbaar mogelijk houden voor beginnende electronici, die waarschijnlijk niet meteen een mega in huis hebben gehaald. Ik wou ook nog proberen om er een tweede Uno naast te zetten maar dat mag niet van meneer Simulide.

De 'slechts één micro regel' is ook van toepassing als je bijvoorbeeld van het ene Simulide-bestand naar de ander wil kopieëren. Slepend of klikkend gaat dat namelijk niet en je kunt hooguit voor de optie 'import file' kiezen, maar dat kan alleen als je eerst een eventuele teveel micro wegknipt, inclusief alle daaraan vastzittende bedrading dus. Heb daar tenminste nog geen omweg voor gevonden.

En over beginnend gesproken .... zoals in de tekst ergens staat heb ik voor de laatste stap de functie
void blinkAll_2Bytes()
https://www.arduino.cc/en/Tutorial/ShftOut22
als voorbeeld genomen (staat helemaal onderaan).

Daar wordt de syntax shiftOut(dataPin, clockPin, 0); gebruikt. Ik kreeg daarop een error van 'too few arguments' en moest daar MSBFIRST of LSBFIRST aan toe voegen . Dit terwijl dat programma uit genoemde link wel gewoon draait zonder die toevoeging. (?)

Error Detectie
In de laatste code zit een fout, M00 krijgt in regel 13 de pin toewijzing van 6.
In regel 15 wordt latchpin ook op pin 6 gezet.
In regel 22 wordt M00 tot Output gemaakt.
In regel 26 wordt latchpin ook tot Output gemaakt.

Led M00 zit niet aangesloten, maar toch, dit hoort dus eigenlijk niet zo maar deze fout leek geen enkel effect te hebben toevallig. Dus heb de code (nog) niet gewijzigd. De fout is ontstaan door het samenvoegen van de sec/min code met de uren-code.
.

[ Voor 41% gewijzigd door kitao op 17-03-2019 02:36 . Reden: Error ]

[kitao]

De seriele monitor is toegevoegd en de foutjes in de vorige code zijn hersteld. Die code laat ik liever toch staan aangezien de foutjes toch geen invloed hadden en omdat het ook geen papier verspilt.

De afbeelding hieronder is met delay t = 100; Er komt dan gemiddeld 43.120 in beeld.
Dat klopt volgens mij niet met mijn theorie maar heeft wellicht te maken met de Real Speed van 79% in Simulide. Zet ik de delay op 140 dan wordt het iets van 60.450, het is dus een kwestie van afstellen en hopelijk is dat in het echt niet nodig.

Met een als driehoek gezaagd stukje triplex zou met bijvoorbeeld de 12 uren-leds als de basis en de 100 seconden en 10 minuten als de zijden, en met eventueel de driehoek op zn kop gezet, een grappig klokje gemaakt kunnen worden.

code:

// De weerstanden zijn afgebeeld als 120 Ohm,in het echt is minstens 220 Ohm te adviseren.
// De klok kan op ieder geheel uur gelijkgesteld worden, stel het is 09:00
// zet dan counter_U op 10 en start de Arduino om 09:00 (Uren 1 hoger, maar niet op 13 zetten, kies dan 1).
// De Q7 van chip2 is 'overgeslagen' omdat dit makkelijker te programmeren bleek.
// Led M00 en U00 zijn niet aangesloten, dit ter indicatie van minuut 60/00 en uur 12/00.
// Revisie : Mogelijkheid tot cyclustijd printen toegevoegd en instructies voor Led M00 verwijderd.
// Bron : https://learn.adafruit.com/multi-tasking-the-arduino-part-1/using-millis-for-timing

int t = 100;               // Verander hiermee de kloksnelheid (in milliseconden) in één keer.
int counter_U = 1;        //  Counter voor de (12) uren. Bij vooraf INSTELLEN klok, zet deze vanaf 1 T/M 12. Beginstand is 1. De uren-leds springen pas bij nadat 1 uur is verstreken.
int counter_M = 0;       //   Counter voor de (10) minuten. 
long VorigeMillis = 0;  //    Wordt gebruikt voor de rondetijd
int CC = 0;            //     CyclusCounter om het aantal volledige 12-uurs rondjes te tellen
long cyclustijd = 0;  //      Cyclustijd in milliseconden
int S00 = 0;  int S10 = 1;   int S20 = 2;   // De seconden leds
int S30 = 3;  int S40 = 4;   int S50 = 5;    
int M10 = 7;  int M20 = 8;   int M30 = 9;   // De minuten leds
int M40 = 10; int M50 = 11;                
int latchpin  =  6;      // Pin aangesloten op ST_CP van 74HC595
int clockpin  = 13;     //  Pin aangesloten op SH_CP van 74HC595
int datapin   = 12;    //   Pin aangesloten op DS    van 74HC595

void setup() {   // Zet de pinnen als output.      
  pinMode(S00, OUTPUT) ; pinMode(S10, OUTPUT); pinMode(S20, OUTPUT); 
  pinMode(S30, OUTPUT) ; pinMode(S40, OUTPUT); pinMode(S50, OUTPUT);
  pinMode(M10, OUTPUT);  pinMode(M20, OUTPUT); pinMode(M30, OUTPUT) ; 
  pinMode(M40, OUTPUT);  pinMode(M50, OUTPUT);
  digitalWrite(S00, HIGH);         // Zet S00 aan, deze blijft constant aan.  
  pinMode(latchpin, OUTPUT);      //  Zet de stuurpinnen naar de chips op Output
  pinMode(clockpin, OUTPUT);
  pinMode(datapin,  OUTPUT); 
  Serial.begin(9600);          //     Nodig om de tijd data naar de seriële monitor te versturen. 
}
void loop() {    
      counter_M++;    // Verhoog de minuten counter met 1
      delay(t);      //  Wacht t seconden  
  for (int s = 1; s < 6; s++) {     // Hier worden de seconden-leds aangezet
    switch (s) {
    case 1: digitalWrite(S10, HIGH); break;
    case 2: digitalWrite(S20, HIGH); break;
    case 3: digitalWrite(S30, HIGH); break;
    case 4: digitalWrite(S40, HIGH); break;
    case 5: digitalWrite(S50, HIGH); break; } // einde switch/case
      delay(t); } // wacht t seconden + einde for-lus
    digitalWrite(S10, LOW);digitalWrite(S20, LOW);digitalWrite(S30, LOW);
    digitalWrite(S40, LOW);digitalWrite(S50, LOW);   // reset de seconden
  if (counter_M == 6) {  // Check of de minuten vol zijn
    digitalWrite(M10, LOW);digitalWrite(M20, LOW);digitalWrite(M30, LOW);
    digitalWrite(M40, LOW);digitalWrite(M50, LOW);  // Reset de minuten
          counter_M = 0;         // reset minuten counter 
          counter_U++;          //  Verhoog de uren counter met 1
      if (counter_U > 1 ) {    //   if-conditie. Na de eerste sec/min ronde,
      Uren();             }   //    spring naar Uren-functie + einde if-conditie voor counter_U.
                      }      //     einde if-conditie voor counter_M
      switch (counter_M) {  //      Hier worden de minuten-leds aangezet
      case 1: digitalWrite(M10, HIGH); break;
      case 2: digitalWrite(M20, HIGH); break;
      case 3: digitalWrite(M30, HIGH); break;
      case 4: digitalWrite(M40, HIGH); break;
      case 5: digitalWrite(M50, HIGH); break; } // Einde switch/case
}   // Return naar void loop

void Uren() {  // Dit is de Uren-functie
  for (int u = counter_U ; u < 9 ; u++) {   // For-lus voor chip1
    int y = 1 << u;                        //  Bit shift levert een macht van twee (2^x) op.
    y--;                                  //   Verminder 2^x met 1.
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin, LSBFIRST , 0 );   // Vul chip1 met 0.     
    shiftOut(datapin, clockpin, LSBFIRST , y );  //  Vul chip1 met y, de 0 schuift vanuit Q7' door naar chip2.
    digitalWrite(latchpin, 1);
  if ( u != 8 ) {     // Check of de eerste chip alle U-leds heeft branden, zo ja dan geen return naar void-loop
  return ;      }    //  Einde if-conditie voor u != 8
    }               //   Einde eerste for-lus, chip1 zit vol met U00 t/m U07

  if (counter_U >= 9 && counter_U <= 12) {              // if-conditie om te checken of chip2 uren-leds moet gaan aanzetten
    for (int u2 = counter_U - 7 ; u2 < 6 ; u2++) {     //  For-lus voor chip2
    int y = 1 << u2;                                  //   Bit shift levert een macht van twee (2^x) op.
    y--;                                             //    Verminder 2^x met 1.
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin, LSBFIRST , y );    //      Vul chip1 met y.
    shiftOut(datapin, clockpin, LSBFIRST , 255 ); //       Vul chip1 met 255, de y schuift vanuit Q7' door naar chip2.
    digitalWrite(latchpin, 1);
  if ( u2 != 5 ) {                              //         Check of de tweede chip 4 U-leds heeft branden, zo ja dan geen return naar void-loop
  return ;       }                             //          Einde if-conditie u2 != 5
  
  }                                          // Einde tweede for-lus , chip1 zit vol met U00 t/m U07 en chip2 zit vol met U08 t/m U11.
  }                                         //  Einde if-conditie counter_U >= 9 && counter_U <= 12

 if (counter_U == 13) {                   //    if-conditie om te testen of er 12 uren zijn verstreken
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin,  LSBFIRST , 0  );   // Het is nu 12 uur, zet de Uren-leds uit.
    shiftOut(datapin, clockpin,  LSBFIRST , 0  );
    digitalWrite(latchpin, 1);
    counter_U = 1;                   // 'Reset' de uren-counter op 1
    
//********* Onderstaand codeblokje geeft na één volledige 12-uurs cyclus de rondenummers en de rondetijden.                        ********//
//********* Versturen van data naar de seriele monitor kost tijd, daarom is het beter om dit blokje bij niet-gebruik te commenten. *******//
//********* Dit blokje kan ook verplaatst worden naar de seconden of de minuten-lus.                                                   *******//

    CC++;                                        // Verhoog CyclusCounter met 1
    unsigned long HuidigeMillis = millis();     //  Roept de functie millis() aan en zet de verstreken tijd sinds het starten van de Uno in HuidigeMillis
    cyclustijd = HuidigeMillis - VorigeMillis; //   Bereken de cyclustijd van één ronde. 
    Serial.print("CC ");                      //    Print de letters CC (afkorting voor cycluscounter)
    Serial.print(CC);                        //     Print het nummer in de cycluscounter
    Serial.print("   ");                    //      Print een paar spaties
    Serial.println(cyclustijd);            //       Print de berekende cyclustijd en een wagenterugloop (carriage return).
    VorigeMillis = HuidigeMillis;         //       

//******* Einde ronde tijden codeblokje //          ****************                ****************             ********           *******//                      
                      
                      }               //            Einde if-conditie counter_U == 13
 }                                   //             Einde Uren-functie, return naar void loop.

Zie regel 98
Codeblokje heb ik ingevoegd op regel 35, direkt onder void loop(), en de rondetijden worden 600 bij een delay van 100. (Niet in deze code maar thuis, de code hierboven is hetzelfde gebleven).

Dat lijkt er dan meer op en misschien klopt mijn verwijzing naar real speed 79% niet.
Maar vind dat berekenen persoonlijk niet zo belangrijk en ga weer terug naar mijn vorige bezigheden.

Toch even de telmachine erbij gepakt
60 s x 60 m x 12 u = 43.200
De gemeten 12-uurs cyclustijd was : 43.120
.

[ Voor 2% gewijzigd door kitao op 18-03-2019 04:02 . Reden: Een comment-regel in de code toegevoegd ]

[Mignol]

Als je iets met millis doet, dan is het nodig om unsigned long te gebruiken (VorigeMillis en doe dan ook meteen cyclustijd maar).

Met millis kun je met de nauwkeurigheid van de resonator of het kristal de tijd bijhouden, onafhankelijk van de tijd die je code nodig heeft.

C++:

unsigned long huidigeMillis = millis();
if (huidigeMillis - vorigeMillis >= 1000)
{
  vorigeMillis += 1000;
  Serial.println("alweer een seconde");
}

Het gaat om de regel: vorigeMillis += 1000;
Door met een vast getal op te hogen, blijft het in de pas lopen met de echte tijd van de resonator of het kristal.

Zelfs als de code ergens zou wachten gedurende meerdere seconden, dan wordt het ingehaald totdat het weer in de pas loopt. Een officieel Arduino board heeft vaak een resonator, maar sommige Uno clones hebben een 16MHz kristal. Dan kun je een klok maken die een paar minuten per jaar afwijkt, en dat zonder Real Time Clock.

[kitao]

Mignol schreef op maandag 18 maart 2019 @ 15:15:
Als je iets met millis doet, dan is het nodig om unsigned long te gebruiken (VorigeMillis en doe dan ook meteen cyclustijd maar).

Prima opgemerkt daar zat ik nou net een beetje mee te tobben wat ik in regel 12 en 14 voor type variabele zou geven. Ik heb op de gok maar wat ingevuld en het pakte. Nou ja, helemaal gegokt was het niet, unsigned zou inderdaad beter zijn geweest daar er hier geen negatieve tijden in voorkomen en dus heb je meer bereik. Had dat inderdaad wel beter kunnen doen. Wat de cyclustijden betreft, daar verwachte ik geen enorme getallen in, ca. 45.000 is hoeveel bytes ? Ik hoopte eigenlijk ook op een seconds() functie , zoals millis(), maar kwam die zo gauw niet tegen. Ander punt is dat dit klokje niet op de millis-functie draait maar op delay. De millis-functie is er tijdelijk bijgeplakt enkel en alleen om éénmalig de rondetijden te kunnen meten, zoals je ongetwijfeld al gezien hebt, maar dit ter verduidelijking voor eventuele andere lezers. Daarom had ik comment regel 97 toegevoegd met de tekst dat bij geen gebruik van dit codeblokje, deze beter uitgeschakeld kan worden.

Wat bijvoorbeeld bleek uit de meting met een ingestelde delay van 100 ms, is dat de theoretische perfecte cyclustijd van 60x60x12= 43.200 ms benaderd werd door 43.120 ms. Dat is dus vertaald naar seconden, met een delay van 100.000 ipv 100, een verlies van 80 seconden op iedere twaalf uur. Dat is niet gering, dat betekent een verlies van 1 minuut 20 per halve dag. Maar ja, dat is inclusief dat codeblokje en inclusief virtuele Simulide omgeving. Bovendien zou men na een dag kunnen opmeten wat nu precies de afwijking is en daar de delay op kunnen bijstellen. Maar sowieso, net als bij iedere andere klok zonder Planck-eenheids weergave, er zit altijd een dode hoek blinde vlek in. Bij deze is dat, indien ik mij niet vergis, standaard al 99 seconden en bij een doorsnee elektrische wekker toch ook al minstens 59 seconden aangezien seconden daarop niet weergegeven worden meestal.

en ps\
ik klik net de afbeelding van mn eigen meting nog eens aan en de cyclustijd is geen 43.120 maar 43.210 bij een delay van 100ms, mijn fout.
Dus ipv 80 afwijking te snel is het 10 te langzaam. In theorie. Sorry voor dit gestuntel, ik zei al dat al die berekeningen mij niet zo boeien. Ieder looplicht heeft een tempo en van ieder tempo kan in principe een klok gemaakt worden. De Babyloniërs namen 12 als schaal, hier zijn het 22 ledjes.

Met millis kun je met de nauwkeurigheid van de resonator of het kristal de tijd bijhouden, onafhankelijk van de tijd die je code nodig heeft.

C++:

unsigned long huidigeMillis = millis();
if (huidigeMillis - vorigeMillis >= 1000)
{
  vorigeMillis += 1000;
  Serial.println("alweer een seconde");
}

Het gaat om de regel: vorigeMillis += 1000;
Door met een vast getal op te hogen, blijft het in de pas lopen met de echte tijd van de resonator of het kristal.
Zelfs als de code ergens zou wachten gedurende meerdere seconden, dan wordt het ingehaald totdat het weer in de pas loopt.

Op die manier werd dat inderdaad in Adafruit gebruikt ...
https://learn.adafruit.co...1/using-millis-for-timing
... maar had geen idee dat dit zo werd gedaan vanwege de door jou beschreven reden, bedankt, ik vind dat echt een heel waardevolle toevoeging .

Een officieel Arduino board heeft vaak een resonator, maar sommige Uno clones hebben een 16MHz kristal. Dan kun je een klok maken die een paar minuten per jaar afwijkt, en dat zonder Real Time Clock.

Ik ben eigenlijk bezig met c++ en assembly aan het leren, maar vanwege een leuke klok (maar dan met iets van 132 leds), die ik tegenkwam op dit forum en omdat ik het soms leuk vind om met software te tekenen heb ik dit uitstapje gemaakt. Heb zelf geen Arduino op tafel en ga voorlopig mij ook niet verder verdiepen in de Arduino programmeer taal, twee talen zijn wel genoeg tegelijkertijd. Maar ik weet vrijwel zeker dat andere beginners jouw tips goed kunnen gebruiken. Bedankt voor de reactie

[ Voor 32% gewijzigd door kitao op 18-03-2019 23:45 . Reden: ps\ ]

[jeroen vrij]

Gaat dit werken??

code:

#include <ShiftRegister74HC595.h>

// parameters: (number of shift registers, data pin, clock pin, latch pin)
ShiftRegister74HC595 sr (7, 0, 1, 2); 
 
void setup() { 
}

void loop() {

  // set all pins at once
  uint8_t pinValues[] = { B10101010, B10110010, B00011101, B01110011, B11000110, B1000110, B00000001 }; 
  sr.setAll(pinValues); 
  delay(1000);
}

Hij komt door de compile

[jeroen vrij]

Kreeg een tip uit een ander forum.

#include <Shifty.h>

// Declare the shift register
Shifty shift;

void setup() {
// Set the number of bits you have (multiples of
shift.setBitCount(8);

// Set the clock, data, and latch pins you are using
// This also sets the pinMode for these pins
shift.setPins(11, 12, 8);
}

void loop() {
// writeBit works just like digitalWrite
shift.writeBit(1, HIGH);
delay(500);
shift.writeBit(3, HIGH);
delay(500);
shift.writeBit(1, LOW);
delay(500);
shift.writeBit(3, LOW);

delay(500);
}

[kitao]

jeroen vrij schreef op donderdag 21 maart 2019 @ 01:40:
Gaat dit werken??
Hij komt door de compiler

code:

#include <ShiftRegister74HC595.h>

// parameters: (number of shift registers, data pin, clock pin, latch pin)
ShiftRegister74HC595 sr (7, 0, 1, 2); 
 
void setup() { 
}

void loop() {

  // set all pins at once
  uint8_t pinValues[] = { B10101010, B10110010, B00011101, B01110011, B11000110, B1000110, B00000001 }; 
  sr.setAll(pinValues); 
  delay(1000);
}

Heb nog niet geprobeerd maar als je binair getallen kunt schrijven van 8 digits is al een flinke stap op de goede weg. Heb hier een windows calculator en daar zit module Programmer in, is handig die erbij te houden. Wat ik wel zie in jouw code is o.a. 7 B-getallen dus mijn 1e indruk is, waar is de 8e? Verder zit er een library in (.h) en dat maakt dingen vaak obscuurder. De instructie shiftOut(datapin, clockpin, LSBFIRST , 0 ); bijvoorbeeld schijnt ook meer dingen op de achtergrond te doen als hier valt af te lezen.

Ik ben dit projectje begonnen met 1 chip aan te sluiten en pas daarna de tweede en heb die tweede eerst zelf aan de praat proberen te krijgen, vandaar dat je in stap 5, (met [pow] erin), het uitstapje ziet naar pinA5 voor een extra latchpin. Ik wou geen extra pin dus heb toen een stukje geleend uit de Tutorial.
Wat ik wil zeggen, als je de de andere stappen weglaat en alleen nog kijkt naar stap 4 en 5, het urengedeelte, dan wordt het al een stuk overzichtelijker.

[jeroen vrij]

Hoeveel mA kan zo shuifregister eigenlijk uitgeven per pin.
En als ik er 7 gebruik moeten ze dan een condensator hebben. Op de vcc en ground

[kitao]

jeroen vrij schreef op donderdag 21 maart 2019 @ 08:26:
Hoeveel mA kan zo shuifregister eigenlijk uitgeven per pin.
En als ik er 7 gebruik moeten ze dan een condensator hebben. Op de vcc en ground

Hangt ervan af welk type je neemt natuurlijk, daarom hebben al die IC's hun eigen datasheet.
Op vraag 7 weet ik niet hoor, heb het bij twee gehouden, voor mij was dat in dit projectje voldoende.
Je moet erbij bedenken dat je voor die digitale bouwstenen geen micro nodig hebt. Je kan ook gewoon los op de pinnen van de chip schakelaartjes zetten , of bijv. jumpers en bitcombinaties vanaf 0 t/m 255 erdoorheen voeren. Een zo'n schakelaar gebruik je dan als klok, die dan niet erg snel loopt natuurlijk.

Deze pagina is misschien handig
http://www.leonvanderhorst.nl/74595.htm

[jeroen vrij]

Ze leveren maar 6mA per output
Als ze alle 8 aan staan.
Daar krijg ik me leds toch niet mee aan.

[jeroen vrij]

Wat doet een arduino eigenlijk als ik een pin op LOW zet terwijl hij al LOW staat.
Gaat de arduino dan problemen krijgen
Of laat hij deze pin dan op LOW staan

[Tadango]

Hij laat hem gewoon LOW staan.

[kitao]

jeroen vrij schreef op donderdag 21 maart 2019 @ 10:26:
Ze leveren maar 6mA per output
Als ze alle 8 aan staan.
Daar krijg ik me leds toch niet mee aan.

Die steentjes zijn ook speciaal voor hobby bedoeld, daar hoef je je echt niet druk om te maken of je er wel of geen ledje mee kan aansturen want daar is het juist voor gemaakt, of in ieder geval, daardoor kom je de 74hc595 zo vaak tegen.
Heb er tijd niet naar omgekeken maar op pag.5 par. 7.1 staat een Io van 35 mA.
Per pin is dat volgens mij en dan maakt het volgens mij niet uit of dat er 1 output pin in gebruik is of alle 9.

Bovendien, die chips kosten 2 kwartjes.

En ik noem het steentjes omdat het inderdaad te vergelijken valt met lego-steentjes, de hele 74xx serie kan , zover ik weet en heb ondervonden, allemaal zonder specificatie problemen aan elkaar gekoppeld worden.
Op 5 volt, geen 24.



https://lastminuteenginee...egister-arduino-tutorial/
.

[ Voor 23% gewijzigd door kitao op 21-03-2019 20:00 ]

[jeroen vrij]

Kijk die is duidelijk denk ik.
Dus als ik het zo bekijk zou ik heel makkelijk ook effecten op kunnen schuiven van register naar register.
Bij voorbeeld bij een 8x8x8 kan ik elke 8 rijen
Ofwel een heel vlak op een register zetten.
En zo de effecten over de kubus laten gaan.

[jeroen vrij]

Geld voor een schuifregister hetzelfde als met de arduino.
Dat als de pin op LOW staat dat dit tevens de ground is dan.

[kitao]

jeroen vrij schreef op donderdag 21 maart 2019 @ 20:43:
Kijk die is duidelijk denk ik.
Dus als ik het zo bekijk zou ik heel makkelijk ook effecten op kunnen schuiven van register naar register.
Bij voorbeeld bij een 8x8x8 kan ik elke 8 rijen
Ofwel een heel vlak op een register zetten.
En zo de effecten over de kubus laten gaan.

Ja, wat je ziet is een constante klokstroom die op de 74klokpin staat, de SH_CP.
Die gaat erin en vloeit weer af. Kan zijn dat bij toepassing van een micro die klokpuls-serie niet constant loopt maar enkel bij de instructie shiftOut gaat lopen.

Dan heb je de datastroom, die loopt ook constant door volgens mij, of zou dat kunnen,
en die staat op 74pin DS.
En dan uiteindelijk heb je de 74Latchpin ST_CP.
Die bepaalt of de data wordt ingelezen of niet.
Dus zet je er 10 jaar lang klok en data op de chip en je houdt latch laag dan gebeurt er niks. En hou je die constant hoog dan ook niet omdat de inlezing van data op de pulsflanken van de latch gebeurt. Moet echt een puls hebben indien ik mij niet vergis.

Neem je twee in serie, dan vul je eerst chip1 met data, maar houd er rekening mee, die data komt uiteindelijk in chip2.
Want de volgende vulling gaat ook naar chip1 en deze lading bits drukt de eerste vulling over de rand via Q7' naar DS van chip2. Vol is vol dus het loopt over.

[Afbeelding]


Dit stukje code doet dat

code:

void Uren() {  // Dit is de Uren-functie

  for (int u = counter_U ; u < 9 ; u++) {   // For-lus voor chip1
    int y = 1 << u;                        //  Bit shift levert een macht van twee (2^x) op.
    y--;                                  //   Verminder 2^x met 1.
    digitalWrite(latchpin, 0);
    shiftOut(datapin, clockpin, LSBFIRST , 0 );   // Vul chip1 met 0.     
    shiftOut(datapin, clockpin, LSBFIRST , y );  //  Vul chip1 met y, de 0 schuift vanuit Q7' door naar chip2.
    digitalWrite(latchpin, 1);

Counter_U is gewoon een getal, bijv. 1, het wordt dan net als jouw i-loop

for (int u = 1 ; u < 9 ; u++) { ......... // For-lus voor chip1

int y = 1 << u ; ........... // Bit shift levert een macht van twee (2^x) op.

Binair is het namelijk zo dat 1000 = 8 en 10000=16, dat machten zijn van twee, namelijk 2^3 en 2^4.
Het opschuiven van de 1, van positie 4 naar positie 5 in dit geval, noemen ze bitshift. De u geeft aan met hoeveel posities dat moet gebeuren en de << geeft aan welke kant dat op moet.

y-- is hetzelfde als y = y -1

en daarna komt dit blokje

digitalWrite(latchpin, 0);
shiftOut(datapin, clockpin, LSBFIRST , 0 ); // Vul chip1 met 0.
shiftOut(datapin, clockpin, LSBFIRST , y ); // Vul chip1 met y, de 0 schuift vanuit Q7' door naar chip2.
digitalWrite(latchpin, 1);

En dat vult de chips.
Eerst chip1 met lading1 , dan nogmaals chip1 met een tweede lading waardoor lading1 in chip1 door lading2 weggedrukt wordt naar chip2.

Bijvoorbeeld

shiftOut(datapin, clockpin, LSBFIRST , 157 ); // Vul chip1 met 157.
shiftOut(datapin, clockpin, LSBFIRST , 108); // Vul chip1 met 108, de 157 schuift vanuit Q7' door naar chip2.

dan is lading 1 voor 157 = 1001 1101 en dat zit in chip2 op pin Q0-7
..en is lading 2 voor 108 = 0110 1100 en dat zit in chip1 op pin Q0-7

Verschil Lsb en Msb is of 157 als 1001 1101 wordt ingelezen bij Msb.
of andersom wordt ingelezen bij Lsb, dus als 1011 1001
.

[ Voor 11% gewijzigd door kitao op 22-03-2019 06:59 ]

[kitao]

jeroen vrij schreef op donderdag 21 maart 2019 @ 22:40:
Geld voor een schuifregister hetzelfde als met de arduino.
Dat als de pin op LOW staat dat dit tevens de ground is dan.

Nee, dat hoeft niet.
Je hebt namelijk shift-registers die sinken en anderen die sturen.
Bij de sink-modellen moet de Led-kathode op de Q0-7.
De 74hc595 heeft daar de anodes op zitten.
Die heeft zn uitgangen Q0-7, afhankelijk van welke data die je daaraan hebt meegegeven, gewoon hoog of laag staan maar als zo'n uitgangspin laag is kan er geen stroom in vloeien omdat die poort daar niet op gebouwd is. Zit diode in waarschijnlijk.

Rode pijltje wijst naar rondje naast inkeping, dat is altijd pin1



Pin14 SER heet op de door mij gebruikte IC de pin14 DS.
Lekker verwarrend allemaal maar verschilt nou eenmaal per fabrikant welke namen ze aan de pinnen geven. Het zou trouwens niet mogen voorkomen dat pin14 bij een andere fabrikant ineens geen DS/SER is.
Niet met dezelfde behuizing althans (package).
.

[ Voor 47% gewijzigd door kitao op 22-03-2019 06:32 ]

[jeroen vrij]

Ah ok zou het ook werken als je twee verschillende sr, s in serie zet zeg maar 2 om te sinken en 4 andere