debuggen by arduino

is er ook iets van een mogelijkheid om realtime te debuggen in een Arduino...

het gaat best goed nu met de Arduino...maar ik heb nu iets geschreven en er gaat iets fout....

nu zou het leuk zijn als ik wat waarden realtime kon bekijken?

cnc filmpjes op Http://www.arjan-swets.com

of misschien kan iemand mee denken wat ik nu fout doe....

het zijn dus 14 ledstrips die via PWM aangestuurd worden, welke onder de traptreden gemaakt worden....

nu werkt het aan gedeelte werkt goed.... dus van boven naar beneden snel aan, en van beneden naar boven snel aan...

uit wil ik ze langzaam uit laten faden....
dat gaat goed bij de trap_op_uit... maar trap_neer_uit gaat niet goed.... het kan nooit veel zijn.... misschien ziet iemand het....

alvast bedankt!

c code:


int TreeOuputNummer[15] = {00, 44, 46, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
int TreeOuputNummerBrandWaarde[15];
int Speedstep = 1 ;
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void setup() {
  for (int TreeOuputNummerHuidigeTreeOuputNummerTeller = 1 ; TreeOuputNummerHuidigeTreeOuputNummerTeller <= 15; TreeOuputNummerHuidigeTreeOuputNummerTeller++) {
    pinMode(TreeOuputNummer[TreeOuputNummerHuidigeTreeOuputNummerTeller], OUTPUT);
  }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void loop() {
  delay(2000);
  // trap_op_aan(150);
  trap_neer_aan(150);
  delay(2000);
  // trap_op_uit(10, 5, 20);
  trap_neer_uit(10, 5, 20);
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_op_uit(int StepStartWaarde, int StepFadeWaarde, int SpeedTime)
{
  int HuidigeTreeOuputNummerTellerFadeWaarde = 1;
  do {
    for (int HuidigeTreeOuputNummerTeller = 1; HuidigeTreeOuputNummerTeller < 15; HuidigeTreeOuputNummerTeller++)
    {
      if ( HuidigeTreeOuputNummerTellerFadeWaarde > ((HuidigeTreeOuputNummerTeller * StepStartWaarde) - StepStartWaarde) )
      {
        if (TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] > 0 )
        {
          TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] = TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] - StepFadeWaarde;
          analogWrite(TreeOuputNummer[HuidigeTreeOuputNummerTeller], TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller]);
        }
      }
    }
    HuidigeTreeOuputNummerTellerFadeWaarde++;
    delay(SpeedTime);
  } while ( TreeOuputNummerBrandWaarde[14] > 0);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_neer_uit(int StepStartWaarde, int StepFadeWaarde, int SpeedTime)
{
  int HuidigeTreeOuputNummerTellerFadeWaarde = 14 * StepFadeWaarde * StepStartWaarde * 255;
  do {
    for (int HuidigeTreeOuputNummerTeller = 14; HuidigeTreeOuputNummerTeller > 0; HuidigeTreeOuputNummerTeller--)
    {
      if ( HuidigeTreeOuputNummerTellerFadeWaarde < (HuidigeTreeOuputNummerTeller * StepStartWaarde ) )
      {
        if (TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] > 0 )
        {
          TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] = TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] - StepFadeWaarde;
          analogWrite(TreeOuputNummer[HuidigeTreeOuputNummerTeller], TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller]);
        }
      }
    }
    HuidigeTreeOuputNummerTellerFadeWaarde--;
    delay(SpeedTime);
  } while ( TreeOuputNummerBrandWaarde[1] > 0);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_op_aan (byte speed)
{
  for (int TreeOuputNummerHuidigeTreeOuputNummerTeller = 1 ; TreeOuputNummerHuidigeTreeOuputNummerTeller < 15; TreeOuputNummerHuidigeTreeOuputNummerTeller++ ) {
    for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += Speedstep) {
      TreeOuputNummerBrandWaarde[TreeOuputNummerHuidigeTreeOuputNummerTeller] = fadeValue;
      analogWrite(TreeOuputNummer[TreeOuputNummerHuidigeTreeOuputNummerTeller], TreeOuputNummerBrandWaarde[TreeOuputNummerHuidigeTreeOuputNummerTeller]);
      delayMicroseconds(speed);
    }
  }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_neer_aan (byte speed)
{
  for (int TreeOuputNummerHuidigeTreeOuputNummerTeller = 14 ; TreeOuputNummerHuidigeTreeOuputNummerTeller > 0 ; TreeOuputNummerHuidigeTreeOuputNummerTeller-- ) {
    for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += Speedstep) {
      TreeOuputNummerBrandWaarde[TreeOuputNummerHuidigeTreeOuputNummerTeller] = fadeValue;
      analogWrite(TreeOuputNummer[TreeOuputNummerHuidigeTreeOuputNummerTeller], TreeOuputNummerBrandWaarde[TreeOuputNummerHuidigeTreeOuputNummerTeller]);
      delayMicroseconds(speed);
    }
  }
}
cnc filmpjes op Http://www.arjan-swets.com

je variabele namen zijn veel te lang, en nederlands en engels door elkaar.

c code:

for (int HuidigeTreeOuputNummerTeller = 1; HuidigeTreeOuputNummerTeller < 15; HuidigeTreeOuputNummerTeller++)

wat is er mis met:

c code:

or (int i = 1; i < 15; i++)

?

deze code is haast onleesbaar.

maar wat doet int HuidigeTreeOuputNummerTellerFadeWaarde = 14 * StepFadeWaarde * StepStartWaarde * 255;? bij het aanzetten zet je hem op 255?
als je trap_neer_uit(10, 5, 20); doet, is dus HuidigeTreeOuputNummerTellerFadeWaarde = 14*10*5*255 = 178500!!
je kan trouwens een beetje monitoren door serial.print te gebruiken.

[Bericht gewijzigd door Progger op 27 december 2016 13:22:51 (11%)]

GMT+1
EricP

mét CE

Geen zin om een moeilijk leesbaar stuk code door te spitten, maar...

Ik trigger op 255 die je ergens in een vermenigvuldiging gebruikt. Zonder te weten waar het voor is... Moet dan geen 256 zijn?? (nee is ook geen goed antwoord hoor, maar het lijkt een soort shit te zijn. En dan is 255 geen handige waarde zeg maar).

Overigens heb ik vroegah nog wel eens een onleesbaar stuk assembly in elkaar gefrut. Vechten om de laatste bytes code maakt het niet leesbaarder. Zogenaamde 'write only code'. Instructies in de juiste volgorde om te garenderen dat een flag clear is - scheelt weer 1 instructie... Meer commentaar waarom het zo in elkaar zat dan code. Ik heb de review en certificering niet meer meegemaakt (die is er wel gekomen), maar er heeft vast iemand hoofdpijn van gekregen.
Oh, en waarom moest het zo? Custom made chippie met een custom made core die misbruikt werd waardoor er opeens veel in software moest in plaats van in de daarvoor bedoelde hardware. En dan explodeert je codesize (en implodeert de performance... maar dat was hier niet erg).

Jochem

Golden Member

Op 27 december 2016 13:00:09 schreef Arjan Swets:
is er ook iets van een mogelijkheid om realtime te debuggen in een Arduino...

Nee, een Arduino is wat dat betreft maar een onhandig ding.

uit wil ik ze langzaam uit laten faden....
dat gaat goed bij de trap_op_uit... maar trap_neer_uit gaat niet goed....

Het scheelt als je zou beschrijven wat er precies mis gaat. Hangt hij? Reset hij? Doet hij niet precies wat je verwacht, maar wel iets? En wat is dan dat iets?

En ik moet me aansluiten bij mijn voorgangers: je code is onleesbaar. Die idioot lange namen van je variabelen zijn in feite het grootste struikelblok. De rest van de code is ook niet optimaal, maar als je de variabelen aanpast en syntax highlighting goed gebruikt hier op CO (dus de tag [code=c] gebruiken) dan scheelt dat al een slok op een borrel.

edit:
Zonder je code precies te willen doorgronden, denk ik:
Als trap_neer_uit hetzelfde moet doen als trap_op_uit, maar alleen de volgorde van de kanalen omgedraaid, waarom is de rest van de code van die functie dan niet ook gelijk?

Als je zegt dat trap_op_uit prima werkt, kun je trap_neer_uit gewoon hetzelfde schrijven, en alleen deze regel

c code:

for (int HuidigeTreeOuputNummerTeller = 1; HuidigeTreeOuputNummerTeller < 15; HuidigeTreeOuputNummerTeller++)

vervangen door:

c code:

for (int HuidigeTreeOuputNummerTeller = 14; HuidigeTreeOuputNummerTeller > 0; HuidigeTreeOuputNummerTeller--)

Weet je trouwens zeker dat in de versie die je nu hebt gepost de functie trap_op_uit prima werkt?

[Bericht gewijzigd door Jochem op 27 december 2016 14:17:19 (29%)]

Heb geduld: alle dingen zijn moeilijk voordat ze gemakkelijk worden.

Hij werkt....

tijdens het bestralen net schoot het opeens door me hoofd :-)

dit is het geworden en dit werkt....

de grootste fout was inderdaad die vermeenigvuldiging met die 255 er in.... dat werd zo groot dat het niet meer in een int paste.... toen een long van gemaakt.... maar later bleek dat die vermenigvuldiging kleiner kon... en toen paste het wel in een Int..

tja die lange namen voor de variabelen ga ik zo ff inkorten.... tis meer even voor mezelf om te onthouden waar ze ook al weer voor zijn...

en die 255.... weet ik veel waarom...zit er nu ook niet meer in.... maar had iets te maken met dat die PWM werken van 0 tot 255 toch?
maar zat er dus voor lul in...maar ik zat te rommelen om het werkend te krijgen....

trouwens nog een vraag, kan je een array niet op 1 laten beginnen? begint hij altijd op 0?

en nogmaals.... (niet om zielig ofzo te doen).... maar het denken gaat, sinds ik kanker heb, iets minder.... maar om er niet de hele dag er aan te zitten denken probeer ik een beetje bezig te blijven... en ik ben pas begonnen met de Arduino... maar vind het wel leuk....

c code:


int AantalTreden = 14;
int TreeOuputNummer[15] = {00, 44, 46, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
int TreeOuputNummerBrandWaarde[15];
int Speedstep = 1 ;
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void setup() {
  for (int TreeOuputNummerHuidigeTreeOuputNummerTeller = 1 ; TreeOuputNummerHuidigeTreeOuputNummerTeller <= 15; TreeOuputNummerHuidigeTreeOuputNummerTeller++) {
    pinMode(TreeOuputNummer[TreeOuputNummerHuidigeTreeOuputNummerTeller], OUTPUT);
  }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void loop() {
  delay(2000);
  // trap_op_aan(150);
  trap_neer_aan(150);
  delay(2000);
  // trap_op_uit(10, 5, 20);
  trap_neer_uit(10, 5, 20);
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_op_uit(int StepStartWaarde, int StepFadeWaarde, int SpeedTime)
{
  int HuidigeTreeOuputNummerTellerFadeWaarde = 1;
  do {
    for (int HuidigeTreeOuputNummerTeller = 1; HuidigeTreeOuputNummerTeller < AantalTreden+1; HuidigeTreeOuputNummerTeller++)
    {
      if ( HuidigeTreeOuputNummerTellerFadeWaarde > ((HuidigeTreeOuputNummerTeller * StepStartWaarde) - StepStartWaarde) )
      {
        if (TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] > 0 )
        {
          TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] = TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] - StepFadeWaarde;
          analogWrite(TreeOuputNummer[HuidigeTreeOuputNummerTeller], TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller]);
        }
      }
    }
    HuidigeTreeOuputNummerTellerFadeWaarde++;
    delay(SpeedTime);
  } while ( TreeOuputNummerBrandWaarde[AantalTreden+1] > 0);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_neer_uit(int StepStartWaarde, int StepFadeWaarde, int SpeedTime)
{
  int HuidigeTreeOuputNummerTellerFadeWaarde = AantalTreden * StepStartWaarde;
  do {
    for (int HuidigeTreeOuputNummerTeller = AantalTreden; HuidigeTreeOuputNummerTeller > 0; HuidigeTreeOuputNummerTeller--)
    {
      if ( HuidigeTreeOuputNummerTellerFadeWaarde < (HuidigeTreeOuputNummerTeller * StepStartWaarde ) )
      {
        if (TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] > 0 )
        {
          TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] = TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller] - StepFadeWaarde;
          analogWrite(TreeOuputNummer[HuidigeTreeOuputNummerTeller], TreeOuputNummerBrandWaarde[HuidigeTreeOuputNummerTeller]);
        }
      }
    }
    HuidigeTreeOuputNummerTellerFadeWaarde--;
    delay(SpeedTime);
  } while ( TreeOuputNummerBrandWaarde[1] > 0);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_op_aan (byte speed)
{
  for (int TreeOuputNummerHuidigeTreeOuputNummerTeller = 1 ; TreeOuputNummerHuidigeTreeOuputNummerTeller < AantalTreden+1 ; TreeOuputNummerHuidigeTreeOuputNummerTeller++ ) {
    for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += Speedstep) {
      TreeOuputNummerBrandWaarde[TreeOuputNummerHuidigeTreeOuputNummerTeller] = fadeValue;
      analogWrite(TreeOuputNummer[TreeOuputNummerHuidigeTreeOuputNummerTeller], TreeOuputNummerBrandWaarde[TreeOuputNummerHuidigeTreeOuputNummerTeller]);
      delayMicroseconds(speed);
    }
  }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_neer_aan (byte speed)
{
  for (int TreeOuputNummerHuidigeTreeOuputNummerTeller = AantalTreden ; TreeOuputNummerHuidigeTreeOuputNummerTeller > 0 ; TreeOuputNummerHuidigeTreeOuputNummerTeller-- ) {
    for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += Speedstep) {
      TreeOuputNummerBrandWaarde[TreeOuputNummerHuidigeTreeOuputNummerTeller] = fadeValue;
      analogWrite(TreeOuputNummer[TreeOuputNummerHuidigeTreeOuputNummerTeller], TreeOuputNummerBrandWaarde[TreeOuputNummerHuidigeTreeOuputNummerTeller]);
      delayMicroseconds(speed);
    }
  }
}
cnc filmpjes op Http://www.arjan-swets.com

Ik wilde deze PIR-tjes gebruiken : https://www.hobbyelectronica.nl/product/mini-bewegingssensor...arood-pir/

maar ze doen het niet op de Arduino? ik heb ze aangesloten op pin 22 en 24

doe ik iets fout? of komt het omdat er maar 3,3 volt uit komt?
hoe kan ik dit werkend krijgen?

alvast bedankt...

cnc filmpjes op Http://www.arjan-swets.com

Voor een Uno, <0.3*Vcc voor laag, en >0.6*Vcc voor hoog (ca. 3V)
3.3V zit daar ruim boven.
Maar waar lees je die inputs in je code in?

EricP

mét CE

PWM werken van 0 tot 255 toch?

Geen idee. Jij hebt die code gebakken, ik niet. Ik neem aan dat je weet waarom die daar staat...

maar zat er dus voor lul in...maar ik zat te rommelen om het werkend te krijgen....

Ah, de microsoft style...

trouwens nog een vraag, kan je een array niet op 1 laten beginnen? begint hij altijd op 0?

Waarom zou je een array op 1 willen laten beginnen? Maar goed... kort door de bocht: arrays bestaan niet. Het is een trucje van de compiler wat feitelijk niks anders doet dan

code:

addressToRead = baseAddress + (elementSize * elementNumber)

Natuurlijk kun je erin gaan trucen. De simpelste truc is... element 0 niet gebruiken. Als het echt nodig is.

je wil dus variabelen gebruiken in je loopjes, ben je niet beter om gewoon een korte loop te maken zoals progger al aanhaalde, en daarna wat commentaar achter te zetten zodat je weet wat het goed

je gebruikt nergens commentaar en hele lange variabelen. en vooral dat je variabelen het grootste deel hetzelfde beginnen. je zal wel eens op een probleem stoten dat je naam te lang is, en de programmeertaal enkel de eerste 20 karakters zal nemen. en dan zijn er 2 variabelen die dezelfde naam zullen hebben. vind die fout dan maar is.

deze code bv kan je ook omdraaien:

c code:

 for (int TreeOuputNummerHuidigeTreeOuputNummerTeller = AantalTreden ; TreeOuputNummerHuidigeTreeOuputNummerTeller > 0 ; TreeOuputNummerHuidigeTreeOuputNummerTeller-- ) {

c code:

for (int i = 0; i< AantalTreden; i++)

doet hetzelfde

ik zie ook veel herhalende code. probeer dat te vermijden en eventueel in een functie te gooien.

ik schrijf een programma altijd in stukjes. telkens ik een stukje schrijf, toon ik ook alle output op serialmonitor met een delay ertussen. zo kan ik telkens zien wat het programma doet als het een loop doorloopt.
nadat mijn deel werkt, zet ik die serial.print allemaal in commentaar.

wil ik later eens iets aanpassen, of loopt er wat fout, kan ik die commentaar verwijderen en kan ik weer zien wat een loop doet

dit is zo een stukje uit mijn programma

c code:


void printSerial(){
/*  Serial.print("Bat:");  
  Serial.print(battery);  //show voltage, resitor divider 4:1              F:6,60 25li 6,65
  Serial.print("V ");                                        //                     Bat:13,6 T:8,30
  Serial.print("T:");  
  Serial.println(tempvolt);
  Serial.print("temperatuur:");
  Serial.print(temp);
  Serial.println();
  Serial.print(fuelinst);    //instant fuelsender  voltage
  Serial.print(" ");
  Serial.print(fuelavg);
  Serial.print(" ");
  Serial.print(liters);
  Serial.print("L - ");
  Serial.print(distance);
  Serial.print("km");
  Serial.println();Serial.println();*/
}

loopt er ergens iets fout, dan zet ik in mijn programma gewoon printSerial();
ik kan dan onmiddelijk alle gemeten en alle berekende waarde bekijken.
loopt er iets fout bij een regel, dan zet ik tussen elke stap gewoon
printSerial();
delay(3000);

en dan kan ik elke 3sec 1 stap zien en zie ik alle variabelen wijzigen

[Bericht gewijzigd door fcapri op 28 december 2016 22:16:38 (44%)]

ik hou van werken ..., ik kan er uren naar kijken

ik heb dit nu als hoofdlus:

c code:


void loop() {

  int ValOnder = 0;
  int ValBoven = 0;

  ValOnder = digitalRead(InPinOnder);
  ValBoven = digitalRead(InPinBoven);

  Serial.print(ValOnder);
  Serial.println(ValBoven);

  if ( ValBoven == 1)
  {
    trap_op_aan(150);
    delay(2000);
    trap_op_uit(10, 5, 20);
  }

  if ( ValOnder ==  1)
  {
    trap_neer_aan(150);
    delay(2000);
    trap_neer_uit(10, 5, 20);
  }
}

inpinonder en inpinboven zijn inputjes 22 en 24...

en als ik via een draadje van de plus 5 even zo'n inputje hoog maakt, gaat het goed....
maar die gekke PIR zijn continue hoog...

moet daar iets van een pulldown weerstand over ofzo?

ik had toevallig 2 kogellagers hier liggen waar die kopjes van die PIR-tje precies inpassen.... daar heb ik ze ingezet...dus ze zien alleen de tafel en de kogellager waar ze in zitten.... dan moet de geschakelde zwarte draad toch laag zijn, 0 volt geven...?

Op 28 december 2016 22:10:40 schreef fcapri:
je wil dus variabelen gebruiken in je loopjes, ben je niet beter om gewoon een korte loop te maken zoals progger al aanhaalde, en daarna wat commentaar achter te zetten zodat je weet wat het goed

je gebruikt nergens commentaar en hele lange variabelen. en vooral dat je variabelen het grootste deel hetzelfde beginnen. je zal wel eens op een probleem stoten dat je naam te lang is, en de programmeertaal enkel de eerste 20 karakters zal nemen. en dan zijn er 2 variabelen die dezelfde naam zullen hebben. vind die fout dan maar is.

ik ga alle variable zo eerst inkorten, dat van 20 karakters wist ik niet.... maar ontdanks ze w\veel langer zijn gaat het wel allemaal goed.... en ja van het commentaar heb je gelijk... maar ja... om nu tijdens het rommelen steeds commentaar bij te werken... ik weet dat het hoort... en dat serieel uitlezen is wel makkelijk ja... en de tip van tijd er tussen is ook wel slim.... bij mij kwamen de getallen wel erg hard voorbij... :-)

Op 28 december 2016 20:54:24 schreef EricP:
[...]Geen idee. Jij hebt die code gebakken, ik niet. Ik neem aan dat je weet waarom die daar staat...[...]Ah, de microsoft style...[...]Waarom zou je een array op 1 willen laten beginnen? Maar goed... kort door de bocht: arrays bestaan niet. Het is een trucje van de compiler wat feitelijk niks anders doet dan

code:

addressToRead = baseAddress + (elementSize * elementNumber)

Natuurlijk kun je erin gaan trucen. De simpelste truc is... element 0 niet gebruiken. Als het echt nodig is.

nou die 255 is toch de max waarden die je mag gebruiken bij analogWrite... dat heeft niets met mijn code te maken...
en ja ik vind het vaak makkelijker om een array op 1 teleaten beginnen zodat tree 1 ook in de array in 1 terecht komt.... nu gebruik ik 0 ook niet... maar er zijn ook talen waar je gewoon kan kiezen... array(1..20) ofzo...

o...nu de Pirtjes een tijdje in de lager zitten komen er (serieel) toch 2 x 0 terug... en het geheel staat in rust....

maar zodra ik de PIR aan raakt, geeft hij een 1... misschien een tijdje over de ingang zetten?

ik ga maar wat proberen....

cnc filmpjes op Http://www.arjan-swets.com

kode nu:

c code:


int vStairSteps = 14;                                                    // aantal treden
int O_nr[15] = {00, 44, 46, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};     // output nummers in een array zette
int iDown = 22;                                                          // Nummer input PIR onderaan de trap
int iUp = 24;                                                            // Nummer input PIR bovenaan de trap
int ValFade[15];                                                         // huidige Fade waarden per tree onthouden
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void setup() {
  for (int i = 1 ; i <= 15; i++) {                                       // alle PWM pinnen op output zetten
    pinMode(O_nr[i], OUTPUT);
  }
  pinMode(iDown, INPUT);                                                 // PIR inputjes op ingang zetten
  pinMode(iUp, INPUT);

  //digitalWrite(iDown, LOW);
  //digitalWrite(iUp, LOW);

  //Serial.begin(9600);                                                  // serieel verbinding straten voor eventueel debuggen
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void loop() {

  int vDown = 0;
  int vUp = 0;

  vDown = digitalRead(iDown);
  vUp = digitalRead(iUp);

  Serial.print(vDown);
  Serial.println(vUp);

  if ( vUp == 1)
  {
    trap_op_aan( 1, 150);
    delay(2000);
    trap_op_uit(50, 5, 20);
  }

  if ( vDown ==  1)
  {
    trap_neer_aan( 1, 150);
    delay(2000);
    trap_neer_uit(50, 5, 20);
  }
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//vStart = een drempel tussen de verschillende treden..  als deze op 0 staat zullen alle treden tegelijk uitfaden... staat deze op 50 ,zal elke tree apart uitfaden
//vStep = stap grote van het uit fade
//vSpeed =  wachtlus
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_op_uit(int vStart, int vStep, int vSpeed)
{
  int i = 1;                                                                  // tel op, zolang nog niet alle treeden uit zijn
  do {
    for (int j = 1; j < vStairSteps + 1; j ++)                                // starten bij tree 1
    {
      if ( i > (j * vStart) )                                                 // waarde teller groter als drmpel * huidige tree
      {
        if (ValFade[j] > 0 )                                                  // Led al uit? nee dan verlagen
        {
          ValFade[j] = ValFade[j] - vStep;
          analogWrite(O_nr[j], ValFade[j]);                                   // Uitgang aansturen
        }
      }
    }
    i++;
    delay(vSpeed);
  } while ( ValFade[vStairSteps] > 0);                                        // laatste tree Uit?
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//vStart = een drempel tussen de verschillende treden..  als deze op 0 staat zullen alle treden tegelijk uitfaden... staat deze op 50 ,zal elke tree apart uitfaden
//vStep = stap grote van het uit fade
//vSpeed =  wachtlus
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_neer_uit(int vStart, int vStep, int vSpeed)
{
  int i = vStairSteps * vStart;
  do {
    for (int j = vStairSteps; j > 0; j--)                                     // starten bij tree 14
    {
      if ( i < (j * vStart) )
      {
        if (ValFade[j] > 0 )
        {
          ValFade[j] = ValFade[j] - vStep;
          analogWrite(O_nr[j], ValFade[j]);
        }
      }
    }
    i--;
    delay(vSpeed);
  } while ( ValFade[1] > 0);                                                  // laatste tree Uit?
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_op_aan (int vStep, byte speed)
{
  for (int i = 1 ; i < vStairSteps + 1 ; i++ ) {                              // lus welke al de treeden afgaat (van onder(1) naar boven(14)
    for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += vStep) {          // lus welke de PWM output van de tree aanzet
      ValFade[i] = fadeValue;
      analogWrite(O_nr[i], ValFade[i]);
      delayMicroseconds(speed);
    }
  }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void trap_neer_aan (int vStep, byte speed)
{
  for (int i = vStairSteps ; i > 0 ; i-- ) {                                  // lus welke al de treeden afgaat (van boven(14) naar onder(1)
    for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += vStep) {          // lus welke de PWM output van de tree aanzet
      ValFade[i] = fadeValue;
      analogWrite(O_nr[i], ValFade[i]);
      delayMicroseconds(speed);
    }
  }
}
cnc filmpjes op Http://www.arjan-swets.com

PIR-tjes werken wel.... heb ze nu beide in een stukje verwarmingsbuis geschoven... en als ik me hand voor het gat hou werkt het....

die dingen zijn zo super gevoelig....

cnc filmpjes op Http://www.arjan-swets.com

Op 27 december 2016 13:35:39 schreef EricP:
Geen zin om een moeilijk leesbaar stuk code door te spitten, maar...

Ik trigger op 255 die je ergens in een vermenigvuldiging gebruikt. Zonder te weten waar het voor is... Moet dan geen 256 zijn?? (nee is ook geen goed antwoord hoor, maar het lijkt een soort shit te zijn. En dan is 255 geen handige waarde zeg maar).

Overigens heb ik vroegah nog wel eens een onleesbaar stuk assembly in elkaar gefrut. Vechten om de laatste bytes code maakt het niet leesbaarder. Zogenaamde 'write only code'. Instructies in de juiste volgorde om te garenderen dat een flag clear is - scheelt weer 1 instructie... Meer commentaar waarom het zo in elkaar zat dan code. Ik heb de review en certificering niet meer meegemaakt (die is er wel gekomen), maar er heeft vast iemand hoofdpijn van gekregen.
Oh, en waarom moest het zo? Custom made chippie met een custom made core die misbruikt werd waardoor er opeens veel in software moest in plaats van in de daarvoor bedoelde hardware. En dan explodeert je codesize (en implodeert de performance... maar dat was hier niet erg).

tja... ik kom nog uit de z80 assembly tijd... daar probeerde ik ook zoveel mogelijk te doen met zo weinig mogelijk instrukties....

en ik heb ook met diverse PLC gewerkt, waar het commentaar (en ook symbolische namen voor variabele en I/O) ook ruimte in nam... dus tja uit die tijd heb ik ook een beetje het weinige commentaar over gehouden.... en de namen overdijf ik nu een beetje :-)

ik heb hem een beetje opgeschoond... hoop dat het nu beter leesbaar is....

cnc filmpjes op Http://www.arjan-swets.com

Op 28 december 2016 22:42:47 schreef Arjan Swets:

ik ga alle variable zo eerst inkorten, dat van 20 karakters wist ik niet.... maar ontdanks ze w\veel langer zijn gaat het wel allemaal goed.... en ja van het commentaar heb je gelijk... maar ja... om nu tijdens het rommelen steeds commentaar bij te werken... ik weet dat het hoort... en dat serieel uitlezen is wel makkelijk ja... en de tip van tijd er tussen is ook wel slim.... bij mij kwamen de getallen wel erg hard voorbij... :-)

die 20karakters was een voorbeeld, ik weet niet hoelang ze mogen zijn bij arduino. ik weet dat ik het heeeeeeeeeeeel lang geleden eens voorgehad heb. ik kreeg de melding dat de variabele al gedeclareerd was.
bv
int hetTeVermenigvuldigenGetal1 = 0;
int hetTeVermenigvuldigenGetal2 = 0;

als de compiler nu zegt dat er maximaal 25karakters mogen staan, dan ziet die:
int hetTeVermenigvuldigenGeta = 0;
int hetTeVermenigvuldigenGeta = 0;

het kan evengoed op 100karakters staan, ik weet niet hoe ze dat nu nog maken, of dat ze intelligenter zijn geworden om dergelijke problemen eruit te filteren (bv renamen van alle variabelen en dan pas compileren)

commentaar bijschrijven is een gewoonte en moet je van begins af aan doen. ik heb hier nog wel wat programmas rondslingeren van mijne jonge tijd. en toen schreef ik geen commentaar, ik weet immers wel hoe het werkt... moet je daar dan 10jaar later eens naar kijken (ik ben van een windowsserver naar linux server overgestapt en heb nogal wat perl code mogen aanpassen die ik 10jaar geleden schreef). heb ik de gehele code uitgeprint en overal pijlen gemaakt tussen de verschillende stukken om het toch maar weer te begrijpen.
verschillende scripts zijn niet meer aangepast en ben ik dus kwijt, veel teveel werk om aan te passen. ik maakte toen ook de fout om veel links te hardcoden (bv: C:/temp/backupfile.dat en dergelijke. dat doet het dus niet meer in linux)

lange variabelen zoals de uwe gaan echt niet helpen dan

ik hou van werken ..., ik kan er uren naar kijken