Arduino code hulp

Een constant kan het natuurlijk nooit worden als 'ie steeds verandert... (staat vast bij compile-time)
Die code nog tweemaal voor pin 12 en 13 zou toch moeten werken?

En hoe gaat 11 aan dan? Spontaan en magisch?

Met DigitalWrite schrijf je een pin naar een waarde. Dat is een actie die je zelf doet. Hoezo staat daar een if voor?

Je bedoelt toch dat er _de_hele_tijd_ moet gecheckt worden?

1) dit kan niet in de setup, en evenmin als const
2) de status van pen 11 lezen doe je niet met digitalWrite

Nog veel onduidelijker is het me wat je met pen 12 wilt: is dat nu een ingang of een uitgang? Het kan niet allebei tegelijk zijn! Hoogstens kan het soms een ingang zijn en dan weer een uitgang maar dat lijkt me maar een vreemd opzet.

Vertel eens wat uitvoeriger wat je eigenlijk wilt bereiken. Misschien helpt het ook als je beschrijft wat er wordt aangesloten aan die pennen 11, 12, 13.

@flipflop hierboven: het zou kunnen dat er bedoeld wordt "als het lukt om pen 11 hoog te maken, doe dan...." maar ik vermoed van niet.

Ik heb een cube gemaakt.

In de setup heb ik een void H();

 
void H(int r)
{
  ledState = digitalRead(r);
   
  if (ledState == HIGH)
  {
    digitalWrite(r, LOW);
  }
  else
  {
    digitalWrite(r, HIGH);
  }

Nu zet ik een pin aan door H(11);
Te geven.
Maar pin 11,12,13 zijn de layers die mogen nooit tegelijk aan.
Dus wilde ik eigenlijk zorgen dat als ik 1 van die 3 aanzet de andere op LOW gezet word.
Alle pins zijn outputs.
De gehele code tot dusver staat op.
https://github.com/JeroenVrij/3x3x3-cube-under-const
Ik ben maar een noob probeer dit sinds een aantal dagen.

[Bericht gewijzigd door Jeroen vrij op zaterdag 23 maart 2019 16:17:07 (15%)

Programmeren is natuurlijk een kwestie van stijl en van smaak en van gewoontes. Ik wil niet zeggen dat je verkeerd bezig bent, maar _voor_mijn_smaak_ ben je het te ver aan het zoeken.

In je setup doe je voor mijn part niet meer dan pinMode(11, OUTPUT) en idem dito voor pennen 12 en 13. In de main code (in het "loop" gedeelte, dus) doe je al naar het geval

digitalWrite(11,HIGH); digitalWrite(12,LOW) ; digitalWrite(13,LOW);
dan wel
digitalWrite(11,LOW); digitalWrite(12,HIGH) ; digitalWrite(13,LOW);
of anders
digitalWrite(11,LOW); digitalWrite(12,LOW) ; digitalWrite(13,HIGH);

Je kunt daarvoor wel functies maken, maar dat lijkt mij "met een kanon op een mug schieten". Als je dat doet horen die functiedefinities wel vóór de set-functie te komen, niet erin zoals je lijkt te denken.

Nog steeds in het hoofdstuk "stijl en smaak": sommigen zullen het wellicht lelijk of ongepast vinden om die drie commando's op één regel te schrijven zoals ik voorstel; maar ik vind dat juist compact en overzichtelijk. Ieders zijn meug!

Sukses gewenst! Houd ons op de hoogte!

Zou dit werken als ik dat voor elke layer doe.

void L1();
{
digitalwrite(12, LOW);
digitalWrite(13, LOW);
digitalWrite(11, HIGH);
}

En dit kan dus ook in de loop;

H(2); H(4); H(6);

Ipv onder elkaar

Op bitnivo aansturen is nogal omslachtig. Waarom niet een hele 8 bits poort voor bijv. 8 layers?
Je maakt dan de port 0x01, en hoeft dan alleen nog maar een aantal shift lefts te doen... (dan kan er nooit meer als 1 hoog zijn)

Nou omdat ik nog maar net kom kijken en dat port manupilation snap ik van geen kant.
Ik heb maar 3 layers.

Als deze draait ga ik een 6x6x6 maken met shiftregisters.
Daarvoor ga ik shifty.h gebruiken.
En ga ik ook per bit aansturen.
Ik doe het nog geen maand en moet zeker nog veel leren maar dat komt stukje voor stukje wel.
Ben nu bezig met millis want wil de blockende delays eruit hebben maar, daar kom ik ook nog niet uit.

TS, hoe je het nu hebt is het prima in orde, die L1 functie bedoel ik. Wat je eerst had is vreselijk lelijk en onnodig.
Ik zou de functie wel een iets logischer naam geven L1 of H1 zegt mij niks, en jou ook niet over 6 maanden.

Nee klopt verander ze nog in colom en Layer.

Weet iemand van jullie dat misschien.
Ik heb nu de code van blink without delay.
Overgenomen.
In dat schema word de interval op 1000 ms gezet.
Heb het overbodige er even uitgeknipt.
Maar nu is elke interval 1000.
En kan niet gewoon de functie millis(500);
Gebruiken.
Weet iemand hoe ik wel de interval voor elk blok kan bepalen.

 
const int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9, 10};
const int layerPins[] = {11, 12, 13};

int ledState = LOW;             

unsigned long previousMillis = 0;        

const long interval = 1000;           

void setup() 
 {
  pinMode(ledPins[9], OUTPUT);
  pinMode(layerPins[2], OUTPUT);
 }


void loop() 
 {
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >=    interval) 
 {
  previousMillis = currentMillis;
 }
 L(1);
 digitalWrite(ledPins[9], HIGH);
}

Waar is de definitie gebleven van de functie millis ?
Maar wellicht kom je al een heel eind als je interval niet als een const declareert maar wel als een variabele.

Snap je wel wat er precies gebeurd in die code? De functie miliis() returned een getal van 0 (als je net opgestart bent) en iets-heeeeeeeee-groots. Je vergelijkt steeds of dat getal al genoeg verder is. In die vergelijking kun je natuurlijk op alles checken wat je maar wilt. Nu een constante, maar dat hoeft niet natuurlijk.

waarom maakt je niet 1 functie die alles doet. moet je zelf maar beveiligen.
ik denk dat je ook 1 en 0 als LOW en HIGH kan gebruiken
bv

void makePinsHigh(int a, int b, int c){
 if (a+b+c==1){
  digitalwrite(11, a);
  digitalWrite(12, b);
  digitalWrite(13, c);
 }
}

je kan de functie dan oproepen als
makePinsHigh(1,0,0);
of
makePinsHigh(0,1,0);
of
makePinsHigh(0,0,1);

met nog een extra veiligheid dat de if loop niet uitgevoerd wordt als je 1,0,1 zou meegeven.

of je maakt een CASE

void makePinHigh(int number){
 switch (numer) {
  case 11:
    digitalwrite(11, HIGH);
    digitalwrite(12, LOW);
    digitalwrite(13, LOW);
    break;
  case 12:
    digitalwrite(12, HIGH);
    digitalwrite(11, LOW);
    digitalwrite(13, LOW);
    break;
  case 13::
    digitalwrite(13, HIGH);
    digitalwrite(12, LOW);
    digitalwrite(11, LOW);
}

en die roep je dan op met
makePinHigh(11);
makePinHigh(12);
of
makePinHigh(13);

Ja snap het ongeveer.
Hij vergelijkt de vorige millis. Bij de start 0
Met de huidige millis en als dat verschil 1000 is voert hij nogmaal die functie uit.

Had deze van arduino.cc daar stond millis niet gedefinieerd.
Het zou in mijn geval makkelijker zijn om in te vullen millis(500) ipv delay.

Iedereen zegt mij millis te gebruiken voor mijn cube maar begrijp in mijn case niet waarom.
Tijdens de delays doet mijn code niks.
Of ie nou pauzeert of telt millis kost meer kb.
Ben een echte noob haha

Op 23 maart 2019 18:23:33 schreef fcapri:

code:

void makePinsHigh(int a, int b, int c){
 if (a+b+c==1){
  digitalwrite(11, a);
  digitalWrite(12, b);
  digitalWrite(13, c);
 }
}

FCapri, als jij deze functie maakt, dan zou ik makePinsHigh(1,-1,1) uitproren. Maar ik hou ook van vuurwerk

Mijn insteek:

void SelectLayer(int l) {
  digitalWrite(11, 0);
  digitalWrite(12, 0);
  digitalWrite(13, 0);
  if (1 == l)
    digitalWrite(11, 1);
  if (2 == l)
    digitalWrite(12, 1);
  if (3 == l)
    digitalWrite(13, 1);
}

Op 23 maart 2019 18:33:35 schreef Jeroen vrij:
Ja snap het ongeveer.
Tijdens de delays doet mijn code niks.
Of ie nou pauzeert of telt millis kost meer kb.

Het is natuurlijk het idee dat je tijdens het wachten niet niks gaat doen! Met delay kun je niks anders doen, want je zit in die wachtlus te niksen. Met de "methode mills" kun je ondertussen nog vanalles doen. Bv het scannen van toetsen, of het updaten van een display, of een regellus van een motor.

Ik heb zelfs programma's die in de main() loop helemaal niks doen...
(alles wordt in interrupts afgehandeld. Zolang er geen 'trage' dingen hoeven te worden gedaan werkt dat prima...)

Ja maar mijn cube die wacht maar haha.
Had ondertussen een stukje code bedacht.
Maar vraag me af of het met minder tekst kan.
De bedoeling is dat over de hele cube her en der leds aan gaan.

 
long randNumber;

void setup() {

  randomSeed(analogRead(0));
}

void loop() 
 {
 for (int i = 0; i < 10; i++) 
 {
  randNumber = random(2, 10);
  Kolom(randNumber);
  delay(randNumber*10);
 }
 {
  randNumber = random(1, 3);
  Layer(randNumber);
 }
 for (int i = 0; i < 10; i++) 
 {
  randNumber = random(2, 10);
  Kolom(randNumber);
  delay(randNumber*10);
 }
 {
  randNumber = random(1, 3);
  Layer(randNumber);

waarom werkt je met loopjes van 10 en dat 2keer na elkaar?
jij gaat 1 random getal pakken, dan een bepaalde tijd wachten, 1 random getal, bepaalde tijd wachten.... dat 10keer na elkaar.
dan kies je 1 random layer

daarna ga je 1 random getal pakken, dan een bepaalde tijd wachten, 1 random getal, bepaalde tijd wachten.... dat 10keer na elkaar.
dan kies je 1 random layer

dat is 2keer dezelfde code na elkaar. kan je gewoon de helft al weggooien.
en waarom altijd dat wachten in de lussen. als je dan toch repetitief werkt, laat je arduino dan veel sneller door zijn loop gaan

volgens mij ga je ook enkel ledjes aanzetten, en nooit afzetten maak in je loop ook de mogelijkheid om een led af te zetten met bv
AanOfUit=random(0,1)

void loop(){
Kolom(random(2, 10);
Layer(random(1, 3);
delay(random(10, 100);
}
deze code gaat binnen de 100ms eens lopen, gaat een random kolom en layer nemen, en dan een random tijd wachten. en dit vele keren na elkaar

Omdat ik niet zo slim als jij ben.
Haha
Zo is beter idd.
Mijn leds zijn zo ingesteld in de setup.
Dat ze bij 1x aan gaan en de 2e met de zelfde code weer uit gaan.

Met een random aan uit heb ik volgens mij het zelfde.

Maar zoals het nu staat kan ik dan de randnumber
Helemaal weg laten

[Bericht gewijzigd door Jeroen vrij op zondag 24 maart 2019 08:21:35 (14%)

is gewoon ervaring.
vroeger schreef ik hetzelfde.

loop{
doe iets
wacht x
doe iets anders
wacht x
doe nog iets anders
wacht x
update display
}

maar eens je met displays werkt, ga je merken dat je display pas na al die x'jes wachten een refresh doet.
als x 500ms is, dan heb je een resfresh na 1500ms en dat kan aardig traag zijn.
de arduino gaat elke 1,5sec het programma doorlopen.

nu werkt ik met millis, de arduino gaat 30 000keer per seconde door die loop en voert weinig uit.
loop{
zijn er 500ms voorbij?=> doe iets
zijn er 1000ms voorbij?=> doe iets anders
zijn er 1500ms voorbij?=> doe nog iets anders
update display
}
dit geeft als voordeel dat ik na 500ms iets doe, en het display wordt direct vernieuwd.
na 1000ms gaat die het eerste weer uitvoeren, en het 2de ook, en nogmaals een display updaten
na 1300ms doet die niks anders, buiten een display update
na 1450ms doet die niks anders, buiten een display updaten.

dit komt vooral van pas als je bv een grafisch display maakt, waar je elke seconde de tijd wil aanpassen, elke 10sec een update van een waarde, en elke minuut wil je een gemiddelde van een andere waarde .
zou je schrijven zoals je nu doet, ga je overal delays steken, en gaat je klok slechts elke minuut update, en ook die waarde die elke 10sec veranderd, ga je pas na een minuut zien

ivm die randnumber: je hoeft geen variabele te gaan declareren, tenzij je die elders nog eens wil gebruiken.
als het een random getal is om 1x te gebruiken, gewoon die random rechtstreeks oproepen zonder tussen variabele

zou je bv zeggen: ik wil een random getal zodat die na die tijd aanspringt, en diezelfde tijd weer wacht om uit te schakelen.
bv led 1 wil je na 3sec aan, en na diezelfde 3sec weer uit, dan kan je die variabele bijhouden.

[Bericht gewijzigd door fcapri op zondag 24 maart 2019 10:38:29 (61%)

Als ik dit gebruik
Void loop(){
Kolom(random(2, 10);
Layer(random(1, 3);
delay(random(10, 100);
Dan kan ik dus die randnumber= random weglaten?
En die randomseed moet wel blijven denk ik toch?
}

Het lukt mij met millis alleen om een constante millis aan te maken.
Het is mij nog niet gelukt dat ik kan zeggen.
Die iets() ;
Millis(500);
Doe iets
Millis(1000);

Zoals ik het nu begrijp moet ik steeds in de loop
Die hele millis gebeuren zetten bij elke aktie.

Ik heb nu de leds en de layers zo ingesteld
Dat er maar 1 tegelijk aan kan.
Zodat ik geen mosfets hoef te gebruiken.
Zo gebruikt elke pin max 10ma per x ipv 90ma per laag.

Is er een optie om de millis functie 1x aan te maken en dan ipv delay steeds millis te gebruiken.
Dat is dan wel beter voor het multiplexen.

Ben even opnieuw begonnen.

const int pinArray1[] ={3, 4, 5, 6, 7, 8, 9, 10};
const int pinArray2[] ={2, 4, 5, 6, 7, 8, 9, 10};
const int pinArray3[] ={2, 3, 5, 6, 7, 8, 9, 10};
const int pinArray4[] ={2, 3, 4, 6, 7, 8, 9, 10};
const int pinArray5[] ={2, 3, 3, 5, 7, 8, 9, 10};
const int pinArray6[] ={2, 3, 4, 5, 6, 8, 9, 10};
const int pinArray7[] ={2, 3, 4, 5, 6, 7, 9, 10};
const int pinArray8[] ={2, 3, 4, 5, 6, 7, 8, 10};
const int pinArray9[] ={2, 3, 4, 5, 6, 7, 8, 9};
int ledState   = 0;
int count      = 0;
int timer      = 30;
int t200       = 200;
long randNumber;

//all pins to output//
void setup()
 {
 for (int i = 2; i <= 13; i++)
 {
  pinMode(i, OUTPUT);
 }
}
// Kolom(pinnumber) sets pin to HIGH or LOW//
void Kolom(int number)
 {
  switch (number) 
 {
  case 1:
   digitalWrite(2, HIGH);
   digitalWrite(pinArray1[8], LOW);
  break;
  case 2:
   digitalWrite(3, HIGH);
   digitalWrite(pinArray2[8], LOW);
  break;
  case 3:
   digitalWrite(4, HIGH);
   digitalWrite(pinArray3[8], LOW);
  case 4:
   digitalWrite(5, HIGH);
   digitalWrite(pinArray4[8], LOW);
  break;
  case 5:
   digitalWrite(6, HIGH);
   digitalWrite(pinArray5[8], LOW);
  break;
  case 6:
   digitalWrite(7, HIGH);
   digitalWrite(pinArray6[8], LOW);
  case 7:
   digitalWrite(8, HIGH);
   digitalWrite(pinArray7[8], LOW);
  break;
  case 8:
   digitalWrite(9, HIGH);
   digitalWrite(pinArray8[8], LOW);
  break;
  case 9:
   digitalWrite(10, HIGH);
   digitalWrite(pinArray9[8], LOW);
 }
}

void Layer(int number)
 {
  switch (number) 
 {
  case 1:
   digitalWrite(11, HIGH);
   digitalWrite(12, LOW);
   digitalWrite(13, LOW);
  break;
  case 2:
   digitalWrite(12, HIGH);
   digitalWrite(11, LOW);
   digitalWrite(13, LOW);
  break;
  case 3:
   digitalWrite(13, HIGH);
   digitalWrite(12, LOW);
   digitalWrite(11, LOW);
 }
  randomSeed(analogRead(0));
 }

void loop()
{
   for (int i = 0; i < 10; i++) 
 {
  randNumber = random(1, 9);
  Kolom(randNumber);
  randNumber = random(1, 3);
  Layer(randNumber);
  randNumber = random(10,100);
  delay(randNumber);
 }
}

[Bericht gewijzigd door Jeroen vrij op zondag 24 maart 2019 10:52:08 (57%)

Nogmaals, die millis() functie geeft je alleen de tijd terug. Het is geen wachtlus zoals delay(). Anders was je er geen snars mee opgeschoten. millis() is ook geen constante, het is een functie die je aanroept, en gelijk weer terugkomt. Die delay blijft hangen totdat de tijd voorbij is, en dat wil je niet, dat blokkeert steeds je hele programma.

Voor een uitleg van dit mechanisme zie b.v. alhier: https://www.arduino.cc/en/Tutorial/BlinkWithoutDelay