Arduino project 4-bit counter

[darkvortex]

Voor een project op school moet ik een programmeerbaar lichtje maken, dit doe ik voor een groot deel met een arduino.

Het gedeelte van de arduino moet binair tellen van 0 tot 15 (dit over 4 lijnen):



dit gedeelte heb ik al voor elkaar gekregen met volgende code;

code:

void setup()
{
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  
}

void loop() 
{
  // stap 1 0000
  digitalWrite(12, LOW);
  digitalWrite(11, LOW);
  digitalWrite(10, LOW);
  digitalWrite(9, LOW);  
  delay(1000); 

   // stap 1 0001
  digitalWrite(12, HIGH);
  digitalWrite(11, LOW);
  digitalWrite(10, LOW);
  digitalWrite(9, LOW);  
  delay(1000); 
  
     // stap 2 0010
  digitalWrite(12, LOW);
  digitalWrite(11, HIGH);
  digitalWrite(10, LOW);
  digitalWrite(9, LOW);  
  delay(1000); 
  
     // stap 3 0011
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(10, LOW);
  digitalWrite(9, LOW);  
  delay(1000); 
  
     // stap 4 0100
  digitalWrite(12, LOW);
  digitalWrite(11, LOW);
  digitalWrite(10, HIGH);
  digitalWrite(9, LOW);  
  delay(1000); 
  
     // stap 5 0101
  digitalWrite(12, HIGH);
  digitalWrite(11, LOW);
  digitalWrite(10, HIGH);
  digitalWrite(9, LOW);  
  delay(1000); 
  
     // stap 6 0110
  digitalWrite(12, LOW);
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);
  digitalWrite(9, LOW);  
  delay(1000); 
  
     // stap 7 0111
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);
  digitalWrite(9, LOW);  
  delay(1000); 

   // stap 8 1000
  digitalWrite(12, LOW);
  digitalWrite(11, LOW);
  digitalWrite(10, LOW);
  digitalWrite(9, HIGH);  
  delay(1000); 
  
     // stap 9 1001
  digitalWrite(12, HIGH);
  digitalWrite(11, LOW);
  digitalWrite(10, LOW);
  digitalWrite(9, HIGH);  
  delay(1000);
 
    // stap 10 1010
  digitalWrite(12, LOW);
  digitalWrite(11, HIGH);
  digitalWrite(10, LOW);
  digitalWrite(9, HIGH);  
  delay(1000);

   // stap 11 1011
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(10, LOW);
  digitalWrite(9, HIGH);  
  delay(1000); 
 
    // stap 12 1100
  digitalWrite(12, LOW);
  digitalWrite(11, LOW);
  digitalWrite(10, HIGH);
  digitalWrite(9, HIGH);  
  delay(1000);  
  
     // stap 13 1101
  digitalWrite(12, HIGH);
  digitalWrite(11, LOW);
  digitalWrite(10, HIGH);
  digitalWrite(9, HIGH);  
  delay(1000); 
  
     // stap 14 1110
  digitalWrite(12, LOW);
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);
  digitalWrite(9, HIGH);  
  delay(1000); 
  
     // stap 15 1111
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);
  digitalWrite(9, HIGH);  
  delay(1000); 
}

Maar het doel is eigenlijk om twee programma’s af te lopen, in het eerste geval bovenstaand programmaatje en wanneer een schakelaar wordt omgeschakeld moet het eerste programma stoppen en moet het tweede programma in werking treden.

code:

int knop = 2; //knop naar volgende stap
int schakelaar = 3; // loop of stap per stap
int uitgang1 = 12; // adres uitgang 1
int uitgang2 = 11; // adres uitgang 2
int uitgang3 = 10; // adres uitgang 3
int uitgang4 = 9;  // adres uitgang 4

int toestand = 0;  // toestand van de schakelaar
int toestand2 = 0; //toestand van de knop


/*
Bovenstaand geven we onze inputs/outputs een benaming,
Onderstaand zeggen we of het een input is of output.
*/

void setup() {
  pinMode(knop, INPUT);
  pinMode(schakelaar, INPUT);
  pinMode(uitgang1, OUTPUT);
  pinMode(uitgang2, OUTPUT);
  pinMode(uitgang3, OUTPUT);
  pinMode(uitgang4, OUTPUT);
}

void loop(){
 
toestand = digitalRead(schakelaar); //de toestand van de schakelaar wordt bekeken.

  if (schakelaar == HIGH) //is de toestand van de schakelaar 1 dan volgt een loop.
{
   // stap 0 0000
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, LOW);  
  delay(1000); 

   // stap 1 0001
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, LOW);  
  delay(1000); 
  
     // stap 2 0010
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, LOW);  
  delay(1000); 
  
     // stap 3 0011
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, LOW);  
  delay(1000); 
  
     // stap 4 0100
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, LOW);  
  delay(1000); 
  
     // stap 5 0101
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, LOW);  
  delay(1000); 
  
     // stap 6 0110
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, LOW);  
  delay(1000); 
  
       // stap 7 0111
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, LOW);  
  delay(1000); 

       // stap 8 1000
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, HIGH);  
  delay(1000); 
  
       // stap 9 1001
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, HIGH);  
  delay(1000);
 
    // stap 10 1010
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, HIGH);  
  delay(1000);

   // stap 11 1011 
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, HIGH);  
  delay(1000); 
 
    // stap 12 1100
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, HIGH);  
  delay(1000);  
  
     // stap 13 1101
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, HIGH);  
  delay(1000); 
  
       // stap 14 1110
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, HIGH);  
  delay(1000); 
  
       // stap 15 1111
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, HIGH);  
  delay(1000); 
}
 else
{
//programma 2 komt hier 
}
}

Het tweede programma doet het zelfde als het eerste programma maar om naar de volgende stap te gaan wordt geen delay gebruikt maar een drukknop.

Hier komt het probleem ook aankloppen, ik weet niet juist hoe ik het voor elkaar krijg om met een drukknop van stap 0000 naar 0001 kan gaan.

Ik ben er me ook van op de hoogte dat m'n programma nogal groot is voor wat het maar doet, maar dit is voor mij het simpelst en meest verstaanbaar.
Moest iemand een alternatieve manier aanbieden dan zie ik dat graag.

[Damic]

Teller gebruiken en loop want elke keer je wacht dan doet ie ook niets en volgens mij moet die simpeler kunnen.

[Verwijderd]

Kijk eens goed naar regel 28 en 30. Welke variabel evalueer je met de if statement?


Geen idee of het werkt (geen Arduino hier) maar zo klein moet het ongeveer kunnen:

C:

void loop() 
{
    byte bitmask = 1;
    for (byte i=0; i<16; i++) {
        for (byte k=0; k<4; k++) {
            digitalWrite((k + 9), ((i & (bitmask << (3 - k))) > 0)?HIGH:LOW);
        }
        delay(1000);
    }
}

[darkvortex]

code:

toestand = digitalRead(schakelaar); //de toestand van de schakelaar wordt bekeken.
if (toestand == HIGH) //is de toestand van de schakelaar 1 dan volgt een loop.

Even ge-edit, ik denk dat het zo beter is, niet?

[Infant]

De code kan inderdaad een stuk korter, maar je vraagt nu hoe je met een druk knop naar een volgende stap kan gaan.

Je wilt dat je programma wacht en niks doet totdat je een knop in drukt. Een schakelaar uitlezen is je al gelukt, dus nu alleen de knop nog:

C:

//Knop uit lezen.
knoppie = digitalRead(knop);
//Zolang de knop HIGH, niks doen.
while(digitalRead(knop) == HIGH){};

Als je dit tussen elke stap zet, zou het aardig moeten werken. (Verbeterd door Sissors hieronder.)

Wat while(voorwaarde) doet, is steeds kijken of de voorwaarde waar is. Als dat zo is, gaat hij doen wat er in de while loop staat, en dat is hier niks. Dus gaat hij nog een keer kijken of de voorwaarde waar is.
Dit doet hij net zolang totdat je een knop indrukt.

[ Voor 3% gewijzigd door Infant op 26-01-2014 11:49 ]

[Sissors]

Als je het zo doet moet je of knoppie = ... in the while loop zetten, of

code:

while(digitalRead(knop) == HIGH){};

Maar zoals het er nu staat leest hij maar één keer de knop.

[kitao]

Ik vraag me af of je al bekend bent met de arduino-site ?
Veel voorbeelden kun je daar vinden, niet alleen qua programmeren maar ook voor het aansluiten
http://arduino.cc/en/tutorial/button
http://arduino.cc/en/Reference/While
http://arduino.cc/en/Reference/if
http://arduino.cc/en/Tutorial/Pushbutton

[ Voor 7% gewijzigd door kitao op 25-01-2014 15:49 . Reden: link toegevoegd ]

[darkvortex]

Bedankt voor de info, ik test alles maandag op school en laat weten hoe het ging.
Ook bedankt voor de links kitao, ik had ze al eens bekeken maar wist niet hoe ik alles samen moest brengen.

[kitao]

Geen dank, ik leer er zelf van.
Zo snap ik iets niet in jouw code, wil je nu gebruik maken van 2 switches of heb je aan 1 genoeg ?

int knop = 2; //knop naar volgende stap
int schakelaar = 3; // loop of stap per stap
int toestand = 0; // toestand van de schakelaar
int toestand2 = 0; //toestand van de knop

Op jouw tekening staat namelijk maar 1 voorwaarde aangegeven en van daaruit heb ik verder gezocht. Dat deed ik niet om jouw schoolopdracht over te nemen maar zoals ik al zei om er zelf van te leren en als je het goed naloopt dan heb jij er ook iets aan. Neem je het hiernavolgende klakkeloos over dan ligt daarvoor de verantwoording bij jou.
Verder schrijf je dit :

Het tweede programma doet het zelfde als het eerste programma maar om naar de volgende stap te gaan wordt geen delay gebruikt maar een drukknop.

Als je een programma wil onderbreken en gewoon weer hetzelfde wil laten doen dan hoef je enkel de resetknop in te drukken. Daarom heb ik gezocht naar een combinatie van een up- en downcounter.

Ik heb eerst gegoogled op "binairy counter on arduino" en dat was meteen raak want dat gaf deze site:
http://www.multiwingspan.co.uk/arduino.php?page=led5
Dit gecombineerd met deze :
http://arduino.cc/en/tutorial/button
En van die twee heb ik deze code gemaakt:

C++:

/*** Dit programma maakt de keuze tussen binair optellen of aftellen door het
indrukken van een knop. Let wel, het schakelt niet meteen om maar maakt eerst z'n cyclus af.
***/

int ledPin[] = {7,8,9,10};
const int buttonPin = 4;        // pin that the button is attached to
// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status
int del=500 ;                // bepaal de snelheid door de waarde van del aan te passen

void setup()
{
  for (int i =0;i<4;i++) // use an array to store the list of Arduino pins that are connected to LEDs.
  {
    pinMode(ledPin[i], OUTPUT);
  }
}

void loop()
{
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {
    for (byte counter =15;counter>0; counter--) // Aftellen
    {
      displayBinary(counter);
      delay(del);
    }
  }

  else { 
    for (byte counter =0;counter<=15; counter++) // Optellen
    {
      displayBinary(counter);
      delay(del);
    }
  }
}

void displayBinary(byte numToShow)
{
  for (int i =0;i<4;i++)
  {
    if (bitRead(numToShow, i)==1)
    {
      digitalWrite(ledPin[i], HIGH);
    }
    else
    {
      digitalWrite(ledPin[i], LOW);
    }
  }
}
/*****
In this code, we have a new procedure to display the binary number we want to show. 
Numbers in the programming language are actually stored in binary even when we set 
their values using denary. We can take advantage of that fact to avoid having to write 
code to do the conversion (although we could). In this code, a for loop is used to read 
the values of the first four bits of the number sent to the procedure. 
The bitRead function tells us whether there is a 1 or 0 at a given place value.
If we find a 1, we turn that LED on, if we find a zero, we turn the LED for that position off.

Test this code with all of the different numbers from 0 to 15. You can also put in values up to 255.
Numbers in this range need 8 place value columns to be represented. Since our code ignores 
the last 4 place values, the LEDs will only be on if that number has a 1 in one or more of the first
4 place value columns. All odd numbers will have the first place value lit up, all even numbers 
will mean it is not lit.*****/

En dat uitgeprobeerd op breadboard:
_klik
Werkt goed, als de switch wordt omgezet en dus ingang 4 hoog of laag wordt dan maakt de sketch wel eerst z'n cyclus af; deze switcht dus niet meteen om.
Ik ga dat verder ook niet proberen, zal waarschijnlijk iets met een exit-opdracht moeten worden of het controleren van de switch-status ergens anders in de sketch inplakken.
Ik ben hier langer als verwacht mee bezig geweest, zo was ik regel 21 vergeten er in te zetten. Aangezien ik dacht dat het ergens anders aan lag dat het niet goed werkte duurde het lang voordat ik mijn fout inzag.

Daarom is het van belang dat je zelf aan de slag gaat met dit soort dingen, van fouten leer je en het is ook goed dat je zelf eerst hier mee bent begonnen met je eigen programma, wat dus inderdaad veel korter kan.
En als je de links en de code goed doorleest dat kan je er best iets van opsteken.
En toegegeven, ik maakte zelf ook gebruik van andermans voorbeelden, maar ja, dat is bijna altijd zo, praktische toepassingen berusten nu eenmaal vaak op wat anderen voor jou hebben ontdekt.

Ps, als je die schakelaar niet hebt dan kun je gewoon pin 4 rechtstreeks met draadje op de 5V- of de Gnd-rail leggen.
Over bitRead:
http://arduino.cc/en/Reference/bitRead

[ Voor 18% gewijzigd door kitao op 26-01-2014 16:03 . Reden: ps ]

[darkvortex]

@Kitao

Ik heb net even je programma getest en dat doet eigenlijk wat m'n eerste programma moet doen, het optellen (en ook aftellen = niet noodzakelijk) van de bits van 0 tot aan 15 ,alleen is het korter.
Die knop die ik in het begin verklaar moet eigenlijk pas in m'n tweede "programma" (die nog niet geschreven is) gebruikt worden om naar de volgende stap te gaan.

Het programma zou als volgt moeten werken:
-als de schakelaar = HIGH dan moet het eerste deel van m'n programma in werking treden.
-Eerste deel = gewoon binair van 0 tot 15 tellen met 1 seconde tussenstap.
-Als de schakelaar = LOW dan moet het tweede deel van het programma in werking treden.
-Tweede deel = binair tellen van 0 tot 15 maar op het drukken van een knop (zie int knop = 2)

Voorbeeld: Schakelaar = LOW --> dus binair tellen met knop = 0000 --> druk op knop ---> 0001

Dat is hoe het uiteindelijke programma zou moeten werken, ik ben wel blij dat je me hebt kunnen verder helpen met het verkorten van m'n programma, maar ik heb eigenlijk nog wat hulp nodig met dat tweede deel van het programma.

Nogmaals bedankt voor de hulp, het is inderdaad zo dat ik met de arduino enorm veel bijleer uit andermans projecten met name jouw programmaatje.

EDIT: In dit filmpje toont een jongen wat ik wil doen in mijn tweede deel van het programmaatje :
YouTube: Arduino 4 Bits led counter (add/subtract)
(Ik heb enkel het Add gedeelte nodig dus niet het subtract gedeelte)

[ Voor 10% gewijzigd door darkvortex op 27-01-2014 13:56 ]

[kitao]

@DarkVortex,
Bedankt voor de terugkoppeling. De snelheid van de te doorlopen stappen verhogen tot 1 seconde is makkelijk, dan hoef je enkel in regel 9 van de vorige sketch de 500 tot 1000 te verhogen.
Wil je alleen optellen dat is ook makkelijk, dan hoef je enkel wat regels weg te knippen, dat laat ik je zometeen zien en dan kun je vergelijken. Uiteraard is er dan ook geen knop meer nodig voor dat eerste gedeelte.
Over stap twee, -druk een knop en tel er een bit bij op -, tja.... ik kan zelf amper programmeren en eerlijk gezegd is het ook niet mijn hobby maar zie ik het meer als noodzakelijk kwaad (wat uiteindelijk wel van pas komt, dat wel). Anyway, vandaag wordt dat niks meer en ik weet niet hoe lang het gaat duren. Ik zou je vooral willen aanmoedigen om zelf alvast verder te zoeken ?
Aangepast 1e deel programma volgt in een edit.

edit/ voor het optellen staat een sketch kant en klaar op deze eerder gelinkte site : Enige wat ik heb toegevoegd is de int del als makkelijker in te voeren waarde voor de delay.

C++:

int ledPin[] = {7,8,9,10};
int del=1000;  // snelheid voor het optellen in milliseconden

void setup()
{
  for (int i =0;i<4;i++)
  {
    pinMode(ledPin[i], OUTPUT);
  }
}
//  Start Loop
void loop()
{
  for (byte counter =0;counter<=15; counter++)
  {
    displayBinary(counter);
    delay(del);
  }
}
// Einde Loop
//Begin functie displayBinary (of noem het een subroutine, whatever)
void displayBinary(byte numToShow)
{
  for (int i =0;i<4;i++)
  {
    if (bitRead(numToShow, i)==1)
    {
      digitalWrite(ledPin[i], HIGH);
    }
    else
    {
      digitalWrite(ledPin[i], LOW);
    }
  }
}

Ik zal wat proberen toe te lichten en dat is zoals ik het begrijp; wil dus niet zeggen dat het echt zo is.
Het programma begint met het gebruikele, declareren en void setup
Dan volgt de void loop
In die loop zie je regel 16 : displayBinairy(counter)
De counter zit natuurlijk in de for regel op regel 14
displayBinairy is een aparte functie dat begint op regel 22: void displayBinairy
Wat jij dus nodig hebt is nog een functie waar je in de void loop naar verwijst als er een schakelaar wordt omgezet, noem die maar bijvoorbeeld void drukKnopOptel.
Hoe je een schakelaar kunt inpassen in het programma was in mijn vorige sketch al getoond.
In de functie void drukKnopOptel moet er dan een programma worden geschreven dat iedere keer met 1 bit verhoogt als er een knop wordt ingedrukt.

Kortom, 2 functies, de ene doet dit, de andere doet dat en welke er wordt aangeroepen wordt dan bepaald aan de hand van een schakelaar waarvan de status constant wordt gecontroleerd in de void loop.
Ik heb er wat comments bij gezet waar de loop begint en eindigt.
Probleem met C (imo) is die eeuwige rothaakjes, in Basic zou je gewoon schrijven Goto of Gosub.

[ Voor 57% gewijzigd door kitao op 27-01-2014 15:51 ]

[darkvortex]

@Kitao

Wauw, wat een info!
Ik laat dit even bezinken en ik hou je zeker op de hoogte hoe ik het verder zal aanpakken.
Hoe dan ook heb ik vandaag door jou enorm veel bijgeleerd en dat is ten slotte waar het om gaat.

[Sprite_tm]

Modbreak:

Ik heb wat (absoluut goed bedoelde) posts van Kitao weggehaald, en ik vraag ook iedereen geen code meer te posten. De TS heeft dit gekregen als huiswerkvraag, wat betekent dat 'ie zelf code moet gaan schrijven. Het helpt niet echt als we de antwoorden voor gaan kauwen.

Darkvortex: Ik geloof dat Kitao je al een eind op weg geholpen heeft. Probeer het laatste stukje zelf eens te implementeren

[ Voor 18% gewijzigd door Sprite_tm op 28-01-2014 08:14 ]

[darkvortex]

@Sprite

Zal wel goed komen, het is geen huiswerk hoor maar toch versta ik je reactie.
Ik hou jullie wel op de hoogte hoe het verder gaat, en nogmaals bedankt kitao voor de hulp.

[kitao]

Vond het wel een geinige opdracht en veel lastiger als ik dacht. Bijvoorbeeld wat ik eerst schreef over 2e functie er aanplakken lukte echt voor geen meter.
Uiteindelijk heb ik het wel werkend gekregen door 2 programma's die op het net stonden in elkaar te plakken.
Zelf van de bodem af zoiets schrijven gaat me voorlopig niet lukken tenzij ik een goede cursus ga volgen.
Is ook best gecompliceerd. In ieder geval succes met je opdracht, als je het af hebt kan ik je misschien alsnog wat links en mijn gekloonde sketch daarvan geven.

[kitao]

Ik wou nog even iets toevoegen over de 2e functie erbij plakken ...
In mijn vorige post schreef ik dat dit niet lukte, maar ik bedacht me later dat dit andere oorzaak had. Programma was namelijk behoorlijk lang en onoverzichtelijk geworden waardoor ik het niet zag.
Ik wil je echter niet op dwaalspoor brengen dat dit heel moeilijk zou zijn.
In feite blijkt het heel simpel te zijn en er zijn voorbeelden van dus ik hoop dat dit beschouwd wordt als een algemene correctieve hint.
Dit kun je uittesten met slechts 1 jumpwire in plaats van een pushbutton op pin 2 naar 5V of Gnd.

C++:

/*zet pushbutton op pin2 
 dit programma is voorbeeld subroutine*/
int pushButton = 2;
int led = 13;
int buttonState = 0;     // variable for reading the pin status
void setup() {
  Serial.begin(9600);
  pinMode(pushButton, INPUT);
  pinMode(led, OUTPUT);  // declare LED as output

}

void loop() {
  buttonState = digitalRead(pushButton);  
  Serial.println(buttonState); 
  //  ^^^ status pushbutton printen op ser.monitor
  Subroutine(); // springt over naar subroutine  
} // einde loop

void Subroutine(){ // begin subroutine
  buttonState = digitalRead(pushButton); 
  if (buttonState==HIGH){
    digitalWrite (led,HIGH); // led 13 aan
  }
  else {
    digitalWrite(led,LOW); // led 13 uit
  }
} // einde subroutine, springt terug naar loop

[darkvortex]

We zitten ondertussen al weer een eindje verder.
Even updaten hoe het gaat met m'n programmaatje, het is in de richting aan het komen hoe ik het wil.

code:

const int buttonPin = 8;     // adres van de drukknop
int i = 0;
int j = 0;
int buttonState = 0;

/* Bovenstaand worden de integers van het tweede deel van het 
programma verklaard */

int schakelaar = 12; // loop of stap per stap
int uitgang1 = 2; // adres uitgang 1
int uitgang2 = 3; // adres uitgang 2
int uitgang3 = 4; // adres uitgang 3
int uitgang4 = 5;  // adres uitgang 4
int del = 500; //delay tijd
int toestand = 0;  // toestand van de schakelaar


/*
Bovenstaand geven we onze inputs/outputs een benaming,
Onderstaand zeggen we of het een input is of output.
*/

void setup() {
  
  DDRD = DDRD | B00111100;   
  pinMode(buttonPin, INPUT);
  
 /*Bovenstaand is de setup van het tweede deel van het programma*/
 
  pinMode(schakelaar, INPUT);
  pinMode(uitgang1, OUTPUT);
  pinMode(uitgang2, OUTPUT);
  pinMode(uitgang3, OUTPUT);
  pinMode(uitgang4, OUTPUT);
}

void loop(){
 
toestand = digitalRead(schakelaar); //de toestand van de schakelaar wordt bekeken.

  if (toestand == HIGH) //is de toestand van de schakelaar 1 dan volgt een loop.
{
   // stap 0 0000
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, LOW);  
  delay(del); 

   // stap 1 0001
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, LOW);  
  delay(del); 
  
     // stap 2 0010
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, LOW);  
  delay(del); 
  
     // stap 3 0011
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, LOW);  
  delay(del); 
  
     // stap 4 0100
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, LOW);  
  delay(del); 
  
     // stap 5 0101
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, LOW);  
  delay(del); 
  
     // stap 6 0110
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, LOW);  
  delay(del); 
  
       // stap 7 0111
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, LOW);  
  delay(del); 

       // stap 8 1000
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, HIGH);  
  delay(del); 
  
       // stap 9 1001
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, HIGH);  
  delay(500);
 
    // stap 10 1010
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, HIGH);  
  delay(500);

   // stap 11 1011 
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, LOW);
  digitalWrite(uitgang4, HIGH);  
  delay(del); 
 
    // stap 12 1100
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, HIGH);  
  delay(del);  
  
     // stap 13 1101
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, LOW);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, HIGH);  
  delay(del); 
  
       // stap 14 1110
  digitalWrite(uitgang1, LOW);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, HIGH);  
  delay(del); 
  
       // stap 15 1111
  digitalWrite(uitgang1, HIGH);
  digitalWrite(uitgang2, HIGH);
  digitalWrite(uitgang3, HIGH);
  digitalWrite(uitgang4, HIGH);  
  delay(del); 
}
 else
{

    PORTD = PORTD & B11000011; // Maak pin 2 t.e.m. 5 vrij
  buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {
    i++;
    i = i % 16;
  }
  j = (i << 2);
  PORTD = PORTD | j;
  while (buttonState == HIGH) {
    buttonState = digitalRead(buttonPin);
    delay(50);
  }
  delay(50);
  
}
}

Met het eerste deel is iedereen ondertussen wel vertrouwd geraakt, het is en blijft dat lelijk lange programmaatje, maar daar is een reden voor.
Met het eerste deel is mijn leerkracht akkoord dat het korter kan maar dit is iets wat ik zelf "geschreven" heb en wat ik ook zeer simpel kan uitleggen, terwijl als ik het kortere programma gebruik er eigenlijk niks bijzit die ik zelf heb "bedacht".

Het tweede deel heb ik kunnen scoren via een filmpje en ook kunnen verwerken in m'n programma.
Nu is er nog één werkpunt aan en dat is dat de schakelaar continu moet bekeken worden op z'n toestand,
want wat nu zal het programma eerst de loop afmaken voor het herbekeken wordt.
Nogmaals bedankt voor de massale respons (die ik hier niet had verwacht op het elektronica gedeelte).

[kitao]

darkvortex schreef op maandag 03 februari 2014 @ 14:21:
Met het eerste deel is mijn leerkracht akkoord dat het korter kan.
Het tweede deel heb ik kunnen scoren via een filmpje en ook kunnen verwerken in m'n programma.
Nu is er nog één werkpunt aan en dat is dat de schakelaar continu moet bekeken worden op z'n toestand,
want nu zal het programma eerst de loop afmaken voor het herbekeken wordt.

Ik vraag me enigzins af of jouw leraar de lat niet iets te hoog legt ?
Als ik nu kijk naar de 2 programma's die ik heb gebruikt dan kwam ik tegen een bitRead functie en een modulus functie. In jouw programma wordt er zelfs poortmanipulatie gebruikt.
Dat lijkt me geen beginnersstof.
Paar links daarover :
http://arduino.cc/en/Reference/PortManipulation
https://www.inkling.com/r...2nd/chapter-3/recipe-3-12
http://arduino.cc/en/Reference/Modulo
Ben zelf bijna klaar met het doorlezen van een (ingewikkeld) boek over Arduino C-programmeren en de functie PORTD is daarin niet eens behandeld, ik zie dat voor het eerst.

Ik heb jouw programma geprobeerd en het werkt goed; dat het niet meteen omschakelt als de schakelaar wordt verzet had ik eerst ook last van (zie zondag 13:04).
Om dit op te vangen zal je er waarschijnlijk meerdere if-functies erin moeten zetten zodat de schakelaar vaker wordt uitgelezen, dat heb ik althans in 'mijn' programma toegepast om dit op te vangen.
Dat gaf echter weer het volgende schoonheidsfoutje, bij omschakelen sprong de automatische teller niet op 0. Voor dat heb ik nog geen oplossing voor gezocht.

In de link poortmanipulatie zie je overigens een waarschuwing staan dat je niet de seriele poorten onklaar maakt. Al met al heb ik tot nu toe voor jouw project nog geen enkele eenvoudige oplossing gezien en al helemaal niet iets wat iemand zelf met "echte grondbeginselen" kan opbouwen. Maar kan ook aan mij liggen natuurlijk.

[ Voor 4% gewijzigd door kitao op 05-02-2014 10:47 . Reden: toevoeging ]

[Verwijderd]

darkvortex schreef op maandag 03 februari 2014 @ 14:21:

Nu is er nog één werkpunt aan en dat is dat de schakelaar continu moet bekeken worden op z'n toestand,
want wat nu zal het programma eerst de loop afmaken voor het herbekeken wordt.

dat doe je met een interrupt, zie - http://arduino.cc/en/Reference/attachInterrupt

[darkvortex]

Nieuwe issues vormen zich, en ik heb veel tekst nodig om het uit te leggen.

Nu alles een beetje naar behoren werkt zit ik met het grootste probleem die ik denk ik kan tegenkomen (in de mate dat dat hier mogelijk is).
Ik kom er al testende wijze achter dat het stap na stap uitlezen van m'n code enorme problemen geeft voor de componenten die ik ermee wil aansturen.
Het zit namelijk zo; bij deel 2 van m'n programma (stap na stap optellen op de puls van een drukknop) zitten er tussenfases tussen twee stappen.

Wat bedoel je?

-wel wanneer de binaire code van bv: 0011 naar 0100 gaat is er een tussen "fase" namelijk 0111.
Dit probleem komt omdat er sequentieel van boven naar onder wordt gelezen.
De oplossing zou zijn dat alle toestanden tegelijk worden geschreven in plaats van toestand na toestand.
Is er iemand die me kan helpen met dit probleem?

[Sprite_tm]

Huh? Bij het onderste gedeelte van de code gebeurt dat juist niet; je schrijft alle bits tegelijkertijd. Omdat je ze eerst cleart zal je wel een fractie van een miliseconde naar 000 toegaan, dus 0011 -> 0000 -> 0100. Dat kan je veranderen door de status van je poortbits eerst in een variabele te lezen, daarna je set- en clearwerk te doen en daarna in 1 klap weg te schrijven naar PORTD.

[darkvortex]

Sprite_tm schreef op dinsdag 11 februari 2014 @ 13:52:
Huh? Bij het onderste gedeelte van de code gebeurt dat juist niet; je schrijft alle bits tegelijkertijd. Omdat je ze eerst cleart zal je wel een fractie van een miliseconde naar 000 toegaan, dus 0011 -> 0000 -> 0100. Dat kan je veranderen door de status van je poortbits eerst in een variabele te lezen, daarna je set- en clearwerk te doen en daarna in 1 klap weg te schrijven naar PORTD.

Als ik het goed begrijp is het dus bij het eerste deel dat het misloopt, want daar krijg je dan wel die "tussen" fase.

[Sprite_tm]

Hoezo 'als ik het goed begrijp'? Het is jouw code, jij denkt tegen de problemen aan te lopen En er zit dus ook in het tweede gedeelte een tussenfase.

[ Voor 23% gewijzigd door Sprite_tm op 11-02-2014 14:21 ]

[darkvortex]

Ik had even te snel gelezen en geantwoord.
Ik lees nu net van jou (sprite_tm) dat er dan toch een tussenfase aanwezig is in het tweede deel.
Je zegt dat dit op te lossen valt met variabelen etc...
Maar hoe juist, ik ben hier niet zo in thuis.
Is het misschien mogelijk een voorbeeld te geven?

[Sprite_tm]

Nee Als ik dat doe ga je de code nooit begrijpen. Maar ik wil je wel helpen. Probeer eens, desnoods door middel van een stel goedgerichte Google-zoekacties, of je de vette regels van onderstaand stukje code kan uitleggen? Als je dat lukt ben ik er vrij zeker van dat je eruit kan komen

[b]    PORTD = PORTD & B11000011; // Maak pin 2 t.e.m. 5 vrij[/b]
  buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {
    i++;
    i = i % 16;
  }
[b]  j = (i << 2);[/b]
[b]  PORTD = PORTD | j;[/b]

[darkvortex]

Er begint me één en ander duidelijk te worden van die poortmanipulatie, zo weet ik nu dat portd een commando is die pin 0 t.e.m. 7 kan 'aansturen' ( als input of output hoog of laag zetten).
Met dat bitshifting ben ik nog niet volledig mee en met modulo (%) ook nog niet echt.

Ik versta best dat je het programma niet zomaar meegeeft, maar is het mogelijk om me wat te begeleiden met de zaken waarvan ik geen weet heb (misschien a.d.h.v. een oefening) ?
Het is namelijk zo dat het arduino gedeelte een onderdeel is van een groter geheel, dit wil zeggen dat ik wat gekloot zit met het feit dat de rest wat op hold staat.

EDIT/UPDATE:

M'n leerkracht heeft met mij de code eens overlopen en we zijn er ongeveer uitgekomen.

We starten met volgende binaire code ==> 11000011
i zal op ieder buttonsignaal verhogen in toestand (druk op knop = verhogen)
Maar omdat we starten vanaf pin 2 moet deze toestand twee plaatsen worden doorgeschoven,
dit zou er dan zo uit zien 11000111 (na een eerste maal drukken op de knop).
Bij een volgende maal drukken op de knop gebeurd het zelfde, de code 0010 wordt 'geproduceerd' maar ook deze moet doorgeschoven worden dus van 11000011 naar --> 11001011.
Dit blijft zo doorgaan tot we aan 16 komen dan zal i terug 0 worden.

[ Voor 34% gewijzigd door darkvortex op 14-02-2014 14:35 ]

[kitao]

Het is me niet helemaal duidelijk wat nu precies het probleem is, ik dacht dat het merendeels al opgelost was en na het zelf geprobeerd te hebben gaven de leds goed de telpositie aan. Blijkt dus dat er ongewenste tussenresultaten tevoorschijn komen die voor het blote oog niet zichtbaar zijn maar wel nadelig effect hebben op een schakeling erachter ?
In ieder geval is de modulusfunctie % vrij eenvoudig en zijn er ook veel voorbeelden van.
Komt er eigenlijk op neer dat bijv. 12 % 5 een restgetal geeft van 2 dus als er staat :
x=13%5 dan is x gelijk aan 3.
http://arduino.cc/en/Reference/Modulo
In deze gratis pdf kon ik met find vrijwel geen modulusvoorbeeld vinden maar is verder wel een aardige introduktie in C++.

http://it-ebooks.info/book/1581/

[darkvortex]

@Kitao

Zoals jij het zegt is het precies juist, met het blote oog is er inderdaad geen probleem.
Maar het probleem speelt pas mee vanaf dat ik de arduino i.c.m. met andere componenten gebruik (in dit geval een sram geheugen), daar zie ik duidelijk dat het adres waarnaar geschreven wordt, niet juist is.

Ondertussen versta ik het modulo gedeelte ,en ook wat het doet in m'n programma.
Bedankt voor het e-book, hier zal ik zeker eens naar kijken als ik klaar ben met dit project.

[kitao]

Ok, bedankt voor de toelichting, ik dacht al dat ik even iets gemist had.
Over dat boek; je kan er voor kiezen om een probleem gericht op te lossen dus zoals Sprite al aangaf door je te concentreren op de termen die in de sketch geschreven staan of je begint bij de basis of zoals waar ik nu mee bezig ben met een combinatie daarvan. Uiteindelijk zal er dan uit al die stukjes een samenhangend geheel ontstaan (hopelijk).
Geheugenadressen uitlezen had ik eigenlijk niet verwacht dat je daar nu al mee bezig bent gezien de opzet van de openingspost maar goed, zoals ik al zei, het is niet echt nodig om bij A te beginnen om bij Z uit te komen. Kan ook kriskras natuurlijk.

[darkvortex]

Ik zal meer naar het einde toe, verder toelichting geven over het totaalplaatje.
De reden dat ik dit nu niet doe is om geen verwarring te veroorzaken.

[Sprite_tm]

Je snapt shifting en hoe bits werken icm de output ports. Da's hardstikke mooi, dat betekent dat je in ieder geval in de juiste frame of mind zit, en da's geen kleine opgave.

Je snapt dat in je variabele 'j' nu hetzelfde staat als in je variabele 'i' maar dan twee posities opgeschoven, en dat het uiteindelijk naar de poorten toegaat. Wat je echter niet helemaal lijkt te snappen (of wel, maar het blijkt niet direct uit je tekst) is wat elke individuele vette regel doet. Kan je eens proberen om per regel uit te leggen wat de processor precies uitvreet als 'ie die regel probeert uit te voeren? Kan je bijvoorbeeld verklaren waarom alle LEDs na verloop van tijd aangaan en nooit meer uit op het moment dat je de eerste regel aan code weghaalt? (Hint: Het commentaar wat je er nu bij hebt staan is niet helemaal correct.)

Een kleine hint: PORTD is niet een commando, da's de verkeerde term ervoor. Je moet het eerder zien als een variabele (net zoals i en j in je code) die echter als speciaal geintje heeft dat de waarde ervan binair op de pinnen van je Arduino terechtkomt.

[ Voor 3% gewijzigd door Sprite_tm op 14-02-2014 17:15 ]

[darkvortex]

En het is terug maandag!

Ik ben er deze ochtend direct ingevlogen met volgende website http://tronixstuff.com/20...rduino-port-manipulation/;
Hierop ben ik weer volgende stappen wijzer geworden:

-DDRD --> gebruiken in de setup van je programma om de eerste acht I/O pinnen als input of output in te stellen. 1 = OUTPUT 0 = INPUT.

Vb: DDRD = B01010101; //even getallen zijn outputs oneven getallen zijn inputs.

-PORTD --> deze term gebruiken we in onze loop om pin 0 t.e.m. 7 hoog of laag te zetten.
1 = HOOG 0 = LAAG.

Vb: PORTD = B01010101; //even getallen zijn HOOG oneven getallen zijn LAAG.

Vanaf daar ben ik nog mee, maar wanneer we dat bekijken in m'n programmaatje hebben we geen standaard stukje code.

PORTD = PORTD & B11000011;

Dan maar onderdeel per onderdeel, ik heb het "=" teken opgezocht op de arduino reference pagina.
Dit teken staat voor assignment operator, hieruit leid ik af dat de waarde van de rechtse variabele opgeslagen wordt in de linkere variabele (t.o.v. het "=" teken).

Ik ga er deze dag verder op in, maar nu heb ik even andere lessen voor de boeg.
Ondertussen hoop ik dat ik op het juiste spoor zit, misschien kan iemand dit ondertussen controleren/bevestigen.

[Sprite_tm]

Yep, je komt een heel eind. Als je begrijpt wat voor effect de & en |-tekens hebben op de fysieke lijntjes ben je er waarschijnlijk.

[darkvortex]

Ik denk te snappen wat de & en | symbolen willen zeggen.
De & staat voor een en-poort (binaire logica) met volgende waarheidstabel:

1010 = 10 = a
0011 = 3 = b
0010 = 2 = resultaat van a & b

De | staat voor een of-poort (binaire logica) met volgende waarheidstabel:

1010 = 10 = a
0011 = 3 = b
1011 = 11 = resultaat van a | b

--> merk op dat bij de & enkel toestand 1 & 1 = 1
--> merk op dat bij de | => 1 | x = 1

Dit is wat ik eruit kan opmaken door de reference pagina van arduino zelf.
Nu begint het totaalplaatje te komen maar ik ben er nog niet, ik zie nog niet echt in hoe ik de "tussentoestanden" weg kan krijgen.

[Sprite_tm]

We komen er wel. Denkoefeningetje: Stel je voor, je hebt je poort PORTB. Daar hangen allemaal ledjes aan. Nou wil je het aller-eerste ledje aanzetten, terwijl je de rest van de ledjes niet wil aanraken. Dat kan je in 1 actie doen zonder digitalwrite, dus met alleen het bovenstaande. Hoe zou je dat aanpakken? En wat als je het eerste ledje op dezelfde manier weer uit wilt zetten? Wat als je in 1 actie zowel led 1 als 2 aan wilt zetten?

[darkvortex]

code:

void setup()
{
 DDRB = DDRB | B000011; // pin 8&9 output pin 10-13 input 
}

void loop()
{
  PORTB = B000001; //led 8 aan 
  delay(500);
  PORTB = B000000; //led 8 uit
  delay(500);
  PORTB = B000010; //led 9 aan 
}

zoiets goed?

[Sprite_tm]

Niet helemaal wat ik bedoel. Ik wil een stukje code hebben waarbij je de staat van de andere leds niet weet (omdat het bijvoorbeeld de hoeveelheid keer dat een knop is ingedrukt, of iets anders) en dan toch de eerste led aan of uit wil zetten

code:

void setup() {
  DDRB=b11111111; //alle pinnen output
  PORTB=pakEenRandomGetalErgensVandaan(); //zet de leds willekeurig aan of uit
}


void loop() {
  [jouw code hier] //Zet led 0 uit, maar laat de rest van de leds intact
}

Wat ik wil is dat je me alleen maar geeft wat er op de aangegeven plek moet staan. De rest van de code mag je dus niet aanraken

[ Voor 11% gewijzigd door Sprite_tm op 17-02-2014 14:57 ]

[darkvortex]

Zo ik heb wat zitten klooien, maar wat ik nu heb gedaan werkt!
Ik weet wel niet juist of ik nu gecheat heb of niet maar ik begin het meer en meer te snappen, en dat is waar we naar toe willen.

code:

void setup() {
  DDRB=B11111111; //alle pinnen output
  PORTB=(63); //zet de leds willekeurig aan of uit
}


void loop() {
 PORTB = PORTB & 62; //Zet led 0 uit, maar laat de rest van de leds intact
}

[Sprite_tm]

Kan je nog even uitleggen waarom je specifiek 62 gekozen hebt, en niet, ik noem maar wat, 254? En wat nou als je op dezelfde manier die LED weer aan moet zetten?

[darkvortex]

code:

void setup() {
  DDRB=B111111; //alle pinnen output
  PORTB=(15); //zet de leds willekeurig aan of uit
}


void loop() {
 PORTB = PORTB & B111110; //Zet led 0 uit, maar laat de rest van de leds intact
}

Ik denk dat dit het wordt!
Alleen heb ik wel de PORTB aangepast van 8 bits naar 6 (de uno heeft maar 14 I/O's PORTD 8 en PORTB 6).

[Sprite_tm]

Netjes, ik denk dat je het snapt. Kan je nu uitleggen wat de regels met de & en | in je originele code doen? Kan je dan uitleggen waarom er een kleine maar aanwezige tijd is tussen die twee dat de LEDs uitzijn?

[darkvortex]

code:

  PORTD = PORTD & B11000011; // Maak pin 2 t.e.m. 5 vrij
  buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {
    i++;
    i = i % 16;
  }
  j = (i << 2);
  PORTD = PORTD | j;

In de eerste lijn zeggen we dat PORTD gelijk is aan PORTD & B11000011

Later zeggen we dan dat PORTD gelijk is aan PORTD & B11000011 | j

Dus als j gelijk is aan 8 dan zeggen we eigenlijk volgende :

PORTD = PORTD & B11000011 | 0010000

Met als gevolg dat led 5 HOOG zal staan.

Tot hier alles ok maar ik zie niet waar die vertraging vandaan komt....

Toch heb ik vandaag al weer veel bijgeleerd, hopelijk komt het antwoord me nog te binnen, of kan jij me er nog naar toe leiden.

[Sprite_tm]

Volgens mij mis je nog een stukje begrip. Kan je uitleggen wat dit stukje code zal doen, en waarom? (Niet valsspelen en het daadwerkelijk in een AVR zetten ) Kan je ook gokken voor welke actie de & en | in het geval van IO-poorten vaak gebruikt worden?

code:

void setup() {
  PORTB=eenRandomGetalOfzo();
}

void loop() {
  delay(500);
  PORTB=PORTB|B010010;
  delay(500);
  PORTB=PORTB&B101101;
}

[darkvortex]

Wat ik zie is dat je nooit een getal zal tegenkomen met 2 of 16 erin aangezien zij altijd waar zijn in lijn 7 van je code.
Want automatisch zullen deze getallen 'vernietigd' worden in lijn 9 van je code.

Waarschijnlijk is dit niet waar je naar opzoek bent maar dat is het enige dat ik zo'n beetje kan zien,
misschien heb ik morgen weer een iets heldere ingeving

EDIT/UPDATE

Net even getest met een paar ledjes en een breadboard, conlusie:
ongeacht welk getal ik gebruik led 2 en 5 gaan om de 500 ms knipperen.

Dit komt omdat we in het eerste deel pin 2 en 5 automatisch hoog zetten want 1 | x = 1

code:

 delay(500);
  PORTB=PORTB|B010010;

-de overige getallen zullen gewoon gelijk zijn aan hun toestand want 0 | x = x


Daarentegen gaan we in het tweede deel 2 en 5 automatisch laag zetten want 0 & x =0

code:

  delay(500);
  PORTB=PORTB&B101101;

-de overige getallen zullen gewoon gelijk zijn aan hun toestand want 1 & x = x

[ Voor 45% gewijzigd door darkvortex op 18-02-2014 11:23 ]

[darkvortex]

Ondertussen heb ik mijn volledige code aangepast met de code die ik ondertussen voor het grootste deel versta.

code:

const int schakelaar = 12;
const int knop = 8; 
const int tristate = 6; 

int knoptoestand = 0;
int toestand = 0;  

int i = 0;  
int j = 0; 

int del = 500; 
int del2 = 50; 

void setup()
{
 DDRD = DDRD | B00111100;
}

void loop()
{
  
 toestand = digitalRead(schakelaar); 
 if (toestand == HIGH) 
 {
   digitalWrite(tristate, HIGH );
   PORTD = PORTD & B11000011; 
   i++; 
   i = i % 16; 
   j = (i << 2); 
   PORTD = PORTD | j; 
   delay(del); 
 }
 else 
{

  digitalWrite(tristate, LOW ); 
  PORTD = PORTD & B11000011; 
  knoptoestand = digitalRead(knop); 
  if (knoptoestand == HIGH) 
  {
    i++; 
    i = i % 16; 
  }
  j = (i << 2); 
  PORTD = PORTD | j; 
  while (knoptoestand == HIGH)
  {
    knoptoestand = digitalRead(knop); 
    delay(del2); 
  }
  delay(del2); 
  
}
}

Ik heb nu juist nog een probleem met dat laatste stukje logica, moest iemand (bij voorkeur sprite_tm)
mij daar nog wat bij helpen met me duidelijk te maken wat ik nog niet zie dan zou dat fantastisch zijn.

[Sprite_tm]

Kijk, dat 1|x=1 en 0&x=0 is hetgeen waar ik je heen wilde leiden. | gebruik je om bitjes aan te zetten, & gebruik je om bitjes uit te zetten.

Kan je me vertellen wat voor probleem je hebt met het onderste stukje code? Ik zie wel een potentieel probleem maar weet niet zeker of je die wel hebt.

[darkvortex]

Wel mijn probleem is dat je tussen de overgang van bijvoorbeeld 3 naar 4 een tussen fase hebt.

0011-->3
0111------->TUSSENFASE
0100-->4

Dit gebeurt enorm snel, met het oog kan je het niet waarnemen maar de componenten waarbij ik het gebruik ondervinden dit wel.

Nu is de vraag hoe ik die tussenfase er tussenuit haal?

EDIT: verduidelijking

[ Voor 5% gewijzigd door darkvortex op 20-02-2014 15:44 ]

[Sprite_tm]

Ah, dat probleem nog steeds, sorry.

Hoe kom je erbij dat je tussenfase 0111 is? Dat haal ik niet uit de code. Je weet neem ik aan waardoor die tussenfase komt, aka kan je de twee regels eens noemen waartussen de tussenfase zich voordoet?

Als je dat kan zie je misschien ook wel dat de tussenfase zich voordoet omdat je op twee verschillende plekken de bits in PORTD manipuleert. Dat moet je misschien lostrekken: lees eerst de bestaande waarde van PORTD in en sla 'em tijdelijk op in een variabele, doe daarna je ding met alle bitmanipulaties en schrijf de waarde daarna weer terug naar PORTD. Omdat dat laatste de enige plek is waar je de bits in PORTD aanpast krijg je geen tussenfases. Kan je dat verhaal omzetten in code?

[darkvortex]

Sorry voor die laatste post, deze was onnodig.
Ondertussen heb ik alles getest en het loopt als een zonnetje!
Ik wil jou (sprite_tm) even in het bijzonder bedanken voor de uitleg en de moeite die je in mij hebt geïnvesteerd.
Ik laat jullie binnen x-aantal weken zien wat het eindresultaat is en waarom ik dit nodig had.
Nogmaals aan iedereen bedankt voor de massale input, dit forum heeft van mij een slimmer man gemaakt.

[Sprite_tm]

Graag gedaan

[darkvortex]

Vandaag is het eindelijk af, het eindwerk waarin de arduino verwerkt zit werkt! (met dank aan sprite en mede-tweakers).
Zoals beloofd zal ik het doel van de arduino uitleggen, maar dat zal voor morgen zijn

[kitao]

Ben benieuwd

[darkvortex]

Eventjes terug naar de basis.
De arduino moet in grote lijnen twee dingen kunnen:

1) Van 0000 naar 1111 tellen met een bepaald tijdsinterval = READ
2) Van 0000 naar 1111 tellen en verspringen wanneer er op de knop wordt gedrukt (naast de arduino) = WRITE

Daarbij komend zijn er nog 2 ingangen en 1 uitgang die gebruikt worden op de arduino om wat componenten aan te sturen.

Uiteindelijk is dit het eindresultaat:


-De gele draadjes uit de arduino sturen het ramblokje aan naast de READ/WRITE schakelaar.

-Wanneer de READ/WRITE schakelaar op READ staat wordt er data uit het ramblokje gelezen die op dat bepaalde adres is geschreven.

-Wanneer de READ/WRITE schakelaar op WRITE staat dan worden de 8 schakelaars (geel aangeduid) geactiveerd en dan kan je de lichtjes aan of uit schakelen.
Nu kan je zelf het verloop van het lichtje bepalen: stel dat je alle 8 letters stap per stap aan en uit wil laten gaan dan moet je eerst de eerste letter aanschakelen daarna op de knop drukken naast de arduino en dan de tweede aanzetten de eerste uit dan weer op de knop drukken, en dit blijft doorgaan tot je er genoeg van hebt.

Dit kan allemaal wat verward overkomen, dus laat me iets weten als je het niet begrijpt.

Voor de rest heb ik nog twee tri-state buffers (blauw aangeduid) die dienen om bepaalde elementen uit te schakelen (om zo kortsluiting te vermijden).
De twee schakelaars naast het ramblokje (rood aangeduid) dienen om naar een andere geheugenbank te gaan (zo heb ik 4 verschillende banken).

Voor de geïnteresseerden heb ik nog het schema:



Waarschijnlijk lijkt dit alles nogal vaag, maar als je vragen hebt zal ik er proberen op te antwoorden.

Nogmaals dank voor de medewerking, GoT zal vermeld worden in m'n verslag.