duimwielschakelaars

[nicoverduin Profiel PrivéberichtWebsite]

Nou het klopt dat je 15 krijgt. De duimwiel schakelaar nooit 0:) Immers je hebt C aan 5V gehangen dus lezen alle schakelaars 5V als er geen verbinding is aan GND.
als je analog wilt lezen, dan moet je poorten ook analoog lezen. Nu heb je ze gedefinieerd als digitaal. En daar ze aan de 5V hangen krijg je altijd een HIGH binnen. Nog sterker zelfs met alle standen krijg je dezelfde "HIGH" omdat, ook al zou je met een weerstand naar GND gaan. Stel 1K, dan loopt er wel 5 mA (5V / 1000) door de weerstand. De spanning over die weerstand wordt (1000 * 0.005) = 5V. dus blijven de datapinnen altijd hoog.
De werkelijke vraag voor mij is wat wil je precies? Wil je de digitale waarde van de schakelaar lezen of een of andere intelligente analoge waarde hebben op basis van de stand van de duimwiel? Nu lijkt het erop dat je van alles door elkaar gooit....

[Redundant Profiel Privébericht]

Nou het klopt dat je 15 krijgt. De duimwiel schakelaar nooit 0:) Immers je hebt C aan 5V gehangen dus lezen alle schakelaars 5V als er geen verbinding is aan GND.
als je analog wilt lezen, dan moet je poorten ook analoog lezen. Nu heb je ze gedefinieerd als digitaal. En daar ze aan de 5V hangen krijg je altijd een HIGH binnen. Nog sterker zelfs met alle standen krijg je dezelfde "HIGH" omdat, ook al zou je met een weerstand naar GND gaan. Stel 1K, dan loopt er wel 5 mA (5V / 1000) door de weerstand. De spanning over die weerstand wordt (1000 * 0.005) = 5V. dus blijven de datapinnen altijd hoog.
De werkelijke vraag voor mij is wat wil je precies? Wil je de digitale waarde van de schakelaar lezen of een of andere intelligente analoge waarde hebben op basis van de stand van de duimwiel? Nu lijkt het erop dat je van alles door elkaar gooit....

Hallo Nico, het Programma aangepast, in zoverre, dat er nu gelijk met de stand van het Duimwiel de juiste waarden tevoorschijn komen, de 4 is dus een 4 etc.

De bedoeling is: de standen van de Duimwielschakelaar vertalen naar routines
cijfer 1 kan dan een routine worden om bijv het aantal graden in te stellen.
cijfer 2 cirkel in .... delen
cijfer 4 kan dan een routine worden voor bijv een verdeelapparaat met een verhouding 1:40 etc
Cijfer 6 voor 1:60
cijfer 7 voor 1:72
cijfer 9 voor 1:90 etc

De waarde PKS is nu bekend, ik hoop dat het bruikbaar is in deze vorm.

Heb een programma gezien waar gewerkt met de naam case. 1 etc. als naam voor de routines


// http://www.brainstorm-vzw.be/stappenmotor/
// Webside met uitleg Stappenmotor.

// Arduino MEGA_2560
// Programma voor verdeeltafel-aansturing met 4_draden stappenmotor // en LCD_scherm ?
// Verdeeltafel kan met 4/60/90 verhouding zijn.
// Bediening
int Aan = 0; // Led Blauw betekend Schakeling = Aan TESTLED = Poort 13
int Uit = 0; // Alles Uit
int PKS = 0;
int readSwitch = 0;

// ProgrammaKeuze_schakelaar voor Nr.1= Graden opgave Nr.2 = Verdeling opgeven Verhouding 3,4,5 = 40/60/90 of 6 t/m 0 = reserve
// int DWS = 0; // Digitaal in Programma

// Programma Keuze


int PKS1 = A8; // analogread ProgrammaKeuzeSchakelaar Single_Duimwiel
int PKS2 = A9; // analogread ProgrammaKeuzeSchakelaar Single_Duimwiel
int PKS4 = A10; // analogread ProgrammaKeuzeSchakelaar Single_Duimwiel
int PKS8 = A11; // analogread ProgrammaKeuzeSchakelaar Single_Duimwiel

// Aantal Bewerkingen
int DWS1 = A12; // analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
int DWS2 = A13; // analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
int DWS4 = A14; // analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
int DWS8 = A15; // analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel



// int ledPinPKS = 0; // Keuze uit te voeren Routine vastleggen met 3-Duimwielschakelaars 000 t/m 999


// int HoHT = 0; // Aantal stappen per Tand (afstand)
// int inputPinDWS = 0; // Totaal van uitlezing Duimwielschakelaars 3 rijen 10 standen // = digitaal



// int inputPinPKS = A0; // PKS Programma_Keus = 4e Duimwielschakelaar_stand_1 t/m 0
// int inputPinAU = A1; // Aan/Uit schakelen



int ledPinSR = 10; // 10PWM Led Groen Stappenmotor staat (Ready) klaar voor opdracht
int ledPinRM = 11; // 11PWM Led Rood Stappenmotor draait (Revolution_Motor)
int ledPinAU = 13; // 12PWM Led Blauw Aan/Uit TESTLED = Poort 13

int ledPinWW40 = 15; // 15PWM Gele Led Wormwielverhouding 1:40 // indien geen LCD
int ledPinWW60 = 16; // 16PWM Gele Led Wormwielverhouding 1:60 // indien geen LCD
int ledPinWW90 = 17; // 17PWM Gele Led Wormwielverhouding 1:90 // indien geen LCD


// Stappenmotor
int dirpin = 22; // 22 digitaal Draairichting Stappenmotor
int steppin = 24; // 24 digitaal Aantal stappen
int speedpin = 26; // 26 digitaal Snelheid stappenmotor


void setup()
{
// pinMode (inputPinAU, INPUT) ; // A1 stand lezen Aan/Uit schakelaar
// pinMode (inputPinPKS, INPUT) ; // A0 stand lezen losse/enkele Duimwielschakelaar = Programmakeuzeschakelaar
// pinMode (inputPinDWS, INPUT) ; // A2 stand lezen 3 Duimwielschakelaars voor aantal tanden/graden
pinMode (13, OUTPUT);

pinMode (ledPinAU, OUTPUT); // 12PWM Blauwe Led
pinMode (ledPinWW40, OUTPUT); // 4PWM WW40 Gele Led
pinMode (ledPinWW60, OUTPUT); // 6PWM WW60 Gele Led
pinMode (ledPinWW90, OUTPUT); // 9PWM WW90 Gele Led
pinMode (ledPinSR, OUTPUT); // 10PWM Groene Led, Stappenmotor klaar voor nieuw signaal
pinMode (ledPinRM, OUTPUT); // 11PWM Rode Led, stappenmotor draait



pinMode (A8, INPUT); // PKS1 Routine is gemaakt als programma Duimwiel_1-schijf //
pinMode (A9, INPUT); // PKS2 van de uitkomst worden cijfers en tientallen en honderdtallen
pinMode (A10, INPUT); // PKS4 bij elkaar opgeteld en aangeboden (in programma te gebruiken)
pinMode (A11, INPUT); // PKS8 bij elkaar opgeteld en aangeboden (in programma te gebruiken)


pinMode (DWS1, INPUT); // Routine is gemaakt als programma Duimwiel_1-axis //
pinMode (DWS2, INPUT); // van de uitkomst worden cijfers en tientallen en honderdtallen
pinMode (DWS4, INPUT); // bij elkaar opgeteld en aangeboden (in programma te gebruiken)
pinMode (DWS8, INPUT); // bij elkaar opgeteld en aangeboden (in programma te gebruiken)

// We zeggen dat de poorten voor de stappen en de pulsen outputs zijn.
pinMode (dirpin, OUTPUT); //
pinMode (steppin, OUTPUT); //

Serial.begin(9600);
}







void loop() {

PKS = 0;
{
if (digitalRead(A8 ) == HIGH ) { PKS += 1 ; }
{digitalWrite(8,HIGH);}
}

{
if (digitalRead (A9 ) == HIGH ) { PKS += 2 ; }
{digitalWrite(9,HIGH);}
}

{
if (digitalRead (A10) == HIGH ) { PKS += 4 ; }
{digitalWrite(10,HIGH);}
}

{
if (digitalRead (A11) == HIGH ) { PKS += 8 ; }
{digitalWrite(11,HIGH);}
}

{
Serial . print ( PKS ) ;
Serial . print ( " = " ) ; // sends switch value to serial monitor box
Serial . println ( " PKS" ) ; // sends switch value to serial monitor box
}

delay(500);

{
digitalWrite (8, LOW);
digitalWrite (9, LOW);
digitalWrite (10, LOW);
digitalWrite (11, LOW);
}
delay(500);

}

[Redundant Profiel Privébericht]

Al verder werkende heb ik nu echt hulp nodig, ik heb een groot probleem.
Krijg nu steeds de melding
"expected declaration before '}' token

ben al bezig geweest met de accolades, maar kom er niet uit. Help.

Martin

// http://www.brainstorm-vzw.be/stappenmotor/
// Webside met uitleg Stappenmotor.

// Arduino MEGA_2560
// Programma voor verdeeltafel-aansturing met 4_draden stappenmotor // en LCD_scherm ?
// Verdeeltafel kan met 4/60/72/90 verhouding zijn.

// Bediening

int Aan = 0; // Led Blauw betekend Schakeling = Aan TESTLED = Poort 13
int Uit = 0; // Alles Uit Kan ook rechtstreeks van Schakelaar

// LCD Scherm
int backLight = 10; // LCD Panel Backlight LED connected to digital pin 10
int LightLevel = 255; // Initialise light full on


// ProgrammaKeuze_schakelaar voor Nr.1= GRaden opgave Nr.2 = Verdeling opgeven Verhouding 3,4,5 = 40/60/72/90 of 6 t/m 0 = reserve

int PKSNul = 0; // Nul Geen ProgrammaKeuze gemakat
int PKSGR = 0; // 1 Graden opgeven
int PKSVd = 0; // 2 Verdeling opgeven
int PKS40 = 0; // 3 Verdeelapparaat 1:40
int PKS60 = 0; // 4 Verdeelapparaat 1:60
int PKS72 = 0; // 5 Verdeelapparaat 1:72
int PKS90 = 0; // 6 Verdeelapparaat 1:90
int PKS_Reserve7 = 0; // 7 Reserve
int PKS_Reserve8 = 0; // 8 Reserve
int PKS_Reserve9 = 0; // 9 Reserve


// Programma Keuze maken
int PKS = 0; // Waarde ProgrammaKeuzeSchakelaar
int PKS1 = A8; // Blauw analogread ProgrammaKeuzeSchakelaar Single_Duimwiel
int PKS2 = A9; // Paars analogread ProgrammaKeuzeSchakelaar Single_Duimwiel
int PKS4 = A10; // Grijs analogread ProgrammaKeuzeSchakelaar Single_Duimwiel
int PKS8 = A11; // Wit analogread ProgrammaKeuzeSchakelaar Single_Duimwiel

// aantal Bewerkingen opgeven / vastleggen met 3-Duimwielschakelaars 000 t/m 999
int DWSW = 0; // Totaalwaarde set van 3-Duimwielschakelaars
int DWS1 = A12; // Paars analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
int DWS2 = A13; // Blauw analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
int DWS4 = A14; // Groen analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
int DWS8 = A15; // Geel analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel


int ledPinAU = 12; // 12PWM Led Blauw Aan/Uit
int TestLed = 13; // 13PWM Led TestLed ROOD


// Stappenmotor
int ledPinRM = 2; // 2PWM Led Rood Stappenmotor draait (Revolution_Motor)
int ledPinSR = 3; // 3PWM Led Groen Stappenmotor staat (Ready) klaar voor opdracht

int dirpin = 0; // 22digitaal Draairichting Stappenmotor
int steppin = 0; // 24digitaal Aantal stappen
int Speedpin = 0; // 26digitaal Snelheid stappenmotor
int HoHT = 0; // Aantal stappen per Tand (Hart op Hart afstand)




void setup() {

pinMode (13, OUTPUT); // TestLed

pinMode (ledPinSR, OUTPUT); // 3PWM Groene Led, Stappenmotor klaar voor nieuw signaal
pinMode (ledPinRM, OUTPUT); // 2PWM Rode Led, stappenmotor draait

// Programmakeuze enkel Duimwiel
// Common = rechtstreeks van 5V
pinMode (A8, INPUT); // PKS1 Blauw Routine is gemaakt als programma Duimwiel_1-schijf //
pinMode (A9, INPUT); // PKS2 Paars van de uitkomst worden cijfers en tientallen en honderdtallen
pinMode (A10, INPUT); // PKS4 Grijs bij elkaar opgeteld en aangeboden (in programma te gebruiken)
pinMode (A11, INPUT); // PKS8 Wit bij elkaar opgeteld en aangeboden (in programma te gebruiken)

// Aantallen Opgave 3-Duimwielen
// 3 X Common
pinMode (10, OUTPUT); // 10PWM Rood = C van 1/3e DuimwielSchakelaar
pinMode (11, OUTPUT); // 11PWM Oranje = C van 2/3e DuimwielSchakelaar
pinMode (12, OUTPUT); // 12PWM Geel = C van 3/3e DuimwielSchakelaar

pinMode (DWS1, INPUT); // A12 Paars Routine is gemaakt als programma Duimwiel_1-axis //
pinMode (DWS2, INPUT); // A13 Blauw van de uitkomst worden cijfers en tientallen en honderdtallen
pinMode (DWS4, INPUT); // A14 Groen bij elkaar opgeteld en aangeboden (in programma te gebruiken)
pinMode (DWS8, INPUT); // A15 Geel bij elkaar opgeteld en aangeboden (in programma te gebruiken)

// We zeggen dat de poorten voor de stappen en de pulsen outputs zijn.

pinMode (Speedpin, OUTPUT); // 26PWM
pinMode (steppin, OUTPUT); // 24PWM
pinMode (dirpin, OUTPUT); // 26PWM

Serial.begin(9600);
}





void loop() {

PKS = 0; {
if (digitalRead(A8 ) == HIGH ) { PKS += 1 ; }
{digitalWrite(8,HIGH);}
if (digitalRead (A9 ) == HIGH ) { PKS += 2 ; }
{digitalWrite(9,HIGH);}
if (digitalRead (A10) == HIGH ) { PKS += 4 ; }
{digitalWrite(10,HIGH);}
if (digitalRead (A11) == HIGH ) { PKS += 8 ; }
{digitalWrite(11,HIGH);}
}
Serial . print ( PKS ) ;
Serial . print ( " = " ) ; // sends switch value to serial monitor box
Serial . println ( " PKS" ) ; // sends switch value to serial monitor box


switch (PKS){ // Routine Case = OK switch(PKS)

case 0:
Serial . print ("Maak Keuze ") ; // PKS = stand Nul
LightLevel = 255; break;
case 1:
Serial . print ("Graden opgeven ") ; // PKS = 1
LightLevel = 255; break;
case 2:
Serial . print ("Verdeling opgeven ") ; // PKS = 2
LightLevel = 255; break;
case 3:
Serial . print ( "WW 40 Verdeling ") ; // PKS = 3
LightLevel = 255; break;
case 4:
Serial . print ( "WW60 Verdeling ") ; // PKS = 4
LightLevel = 255; break;
case 5:
Serial . print ( "WW72 Verdeling ") ; // PKS = 5
LightLevel = 255; break;
case 6:
Serial . print ( "WW90 Verdeling ") ; // PKS = 6
LightLevel = 255; break;
case 7:
Serial . print ( "Reserve 7 ") ; // PKS = 7
LightLevel = 255; break;
case 8:
Serial . print ( "Reserve 8 ") ; // PKS = 8
LightLevel = 255; break;
case 9:
Serial . print ( "Reserve 9 ") ; // PKS = 9
LightLevel = 255; break;
}


// Routine van de 3-Duimwielschakelaars is goed werkend / klaar

DWSW = 0; {

digitalWrite(11, HIGH); // 1e Duimwiel lezen 0 t/m 9
digitalWrite(10, LOW); // Duimwiel 10 t/m 99
digitalWrite( 9, LOW); // Duimwiel 100 t/m 999


if (digitalRead (A12) == HIGH ) { DWSW += 1 ; }
if (digitalRead (A13) == HIGH ) { DWSW += 2 ; }
if (digitalRead (A14) == HIGH ) { DWSW += 4 ; }
if (digitalRead (A15) == HIGH ) { DWSW += 8 ; }

digitalWrite(11, LOW); // Duimwiel 0 t/m 9
digitalWrite(10, HIGH); // 2e Duimwiel lezen 10 t/m 99
digitalWrite(09, LOW); // Duimwiel 100 t/m 999


if (digitalRead (A12) == HIGH ) { DWSW += 10 ; }
if (digitalRead (A13) == HIGH ) { DWSW += 20 ; }
if (digitalRead (A14) == HIGH ) { DWSW += 40 ; }
if (digitalRead (A15) == HIGH ) { DWSW += 80 ; }


digitalWrite(11, LOW); // Duimwiel 0 t/m 9
digitalWrite(10, LOW); // Duimwiel 10 t/m 99
digitalWrite(09, HIGH); // 3e Duimwiel lezen 100 t/m 999


if (digitalRead (A12) == HIGH ) { DWSW += 100 ; }
if (digitalRead (A13) == HIGH ) { DWSW += 200 ; }
if (digitalRead (A14) == HIGH ) { DWSW += 400 ; }
if (digitalRead (A15) == HIGH ) { DWSW += 800 ; }

} // derde wiel

Serial . print ( DWSW ) ; // Tijdelijk laten zien wat de waarde is.
Serial . print ( " = " ) ; // Tijdelijk laten zien wat de waarde is.
Serial . print (" DWSW " ) ; // Tijdelijk laten zien wat de waarde is.
Serial . println ( DWSW ) ; // Tijdelijk laten zien wat de waarde is.


delay(500);

}
}

[nicoverduin Profiel PrivéberichtWebsite]

Om het iedereen en jezelf wat gemakkelijker te maken wordt het zeer op prijs gesteld dat je de code tussen de [ code ] en [ /code ] tags zet. Dan blijft het formaat zoals je het in jouw programma hebt. Overigens de IDE heeft ook een format functie (zie het menu). Dan wordt de code ff wat geformateerd en had je gezien dat je 2x een accolade aan het eind van jouw programma hebt......

Daarnaast gebruik je het statement digitalWrite(09,....). In mijn compiler wordt 09 gezien als een octaal [0-7) getal. je moet de 0 weglaten.

Deze code compileert god. D

Code: Alles selecteren

// http://www.brainstorm-vzw.be/stappenmotor/
// Webside met uitleg Stappenmotor.

// Arduino MEGA_2560
// Programma voor verdeeltafel-aansturing met 4_draden stappenmotor // en LCD_scherm ?
// Verdeeltafel kan met 4/60/72/90 verhouding zijn.

// Bediening

int Aan = 0; // Led Blauw betekend Schakeling = Aan TESTLED = Poort 13
int Uit = 0; // Alles Uit Kan ook rechtstreeks van Schakelaar

// LCD Scherm
int backLight = 10; // LCD Panel Backlight LED connected to digital pin 10
int LightLevel = 255; // Initialise light full on

// ProgrammaKeuze_schakelaar voor Nr.1= GRaden opgave Nr.2 = Verdeling opgeven Verhouding 3,4,5 = 40/60/72/90 of 6 t/m 0 = reserve

int PKSNul = 0; // Nul Geen ProgrammaKeuze gemakat
int PKSGR = 0; // 1 Graden opgeven
int PKSVd = 0; // 2 Verdeling opgeven
int PKS40 = 0; // 3 Verdeelapparaat 1:40
int PKS60 = 0; // 4 Verdeelapparaat 1:60
int PKS72 = 0; // 5 Verdeelapparaat 1:72
int PKS90 = 0; // 6 Verdeelapparaat 1:90
int PKS_Reserve7 = 0; // 7 Reserve
int PKS_Reserve8 = 0; // 8 Reserve
int PKS_Reserve9 = 0; // 9 Reserve

// Programma Keuze maken
int PKS = 0; // Waarde ProgrammaKeuzeSchakelaar
int PKS1 = A8; // Blauw analogread ProgrammaKeuzeSchakelaar Single_Duimwiel
int PKS2 = A9; // Paars analogread ProgrammaKeuzeSchakelaar Single_Duimwiel
int PKS4 = A10; // Grijs analogread ProgrammaKeuzeSchakelaar Single_Duimwiel
int PKS8 = A11; // Wit analogread ProgrammaKeuzeSchakelaar Single_Duimwiel

// aantal Bewerkingen opgeven / vastleggen met 3-Duimwielschakelaars 000 t/m 999
int DWSW = 0; // Totaalwaarde set van 3-Duimwielschakelaars
int DWS1 = A12; // Paars analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
int DWS2 = A13; // Blauw analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
int DWS4 = A14; // Groen analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
int DWS8 = A15; // Geel analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel

int ledPinAU = 12; // 12PWM Led Blauw Aan/Uit
int TestLed = 13; // 13PWM Led TestLed ROOD

// Stappenmotor
int ledPinRM = 2; // 2PWM Led Rood Stappenmotor draait (Revolution_Motor)
int ledPinSR = 3; // 3PWM Led Groen Stappenmotor staat (Ready) klaar voor opdracht

int dirpin = 0; // 22digitaal Draairichting Stappenmotor
int steppin = 0; // 24digitaal Aantal stappen
int Speedpin = 0; // 26digitaal Snelheid stappenmotor
int HoHT = 0; // Aantal stappen per Tand (Hart op Hart afstand)

void setup() {

   pinMode(13, OUTPUT); // TestLed

   pinMode(ledPinSR, OUTPUT); // 3PWM Groene Led, Stappenmotor klaar voor nieuw signaal
   pinMode(ledPinRM, OUTPUT); // 2PWM Rode Led, stappenmotor draait

// Programmakeuze enkel Duimwiel
// Common = rechtstreeks van 5V
   pinMode(A8, INPUT); // PKS1 Blauw Routine is gemaakt als programma Duimwiel_1-schijf //
   pinMode(A9, INPUT); // PKS2 Paars van de uitkomst worden cijfers en tientallen en honderdtallen
   pinMode(A10, INPUT); // PKS4 Grijs bij elkaar opgeteld en aangeboden (in programma te gebruiken)
   pinMode(A11, INPUT); // PKS8 Wit bij elkaar opgeteld en aangeboden (in programma te gebruiken)

// Aantallen Opgave 3-Duimwielen
// 3 X Common
   pinMode(10, OUTPUT); // 10PWM Rood = C van 1/3e DuimwielSchakelaar
   pinMode(11, OUTPUT); // 11PWM Oranje = C van 2/3e DuimwielSchakelaar
   pinMode(12, OUTPUT); // 12PWM Geel = C van 3/3e DuimwielSchakelaar

   pinMode(DWS1, INPUT); // A12 Paars Routine is gemaakt als programma Duimwiel_1-axis //
   pinMode(DWS2, INPUT); // A13 Blauw van de uitkomst worden cijfers en tientallen en honderdtallen
   pinMode(DWS4, INPUT); // A14 Groen bij elkaar opgeteld en aangeboden (in programma te gebruiken)
   pinMode(DWS8, INPUT); // A15 Geel bij elkaar opgeteld en aangeboden (in programma te gebruiken)

// We zeggen dat de poorten voor de stappen en de pulsen outputs zijn.

   pinMode(Speedpin, OUTPUT); // 26PWM
   pinMode(steppin, OUTPUT); // 24PWM
   pinMode(dirpin, OUTPUT); // 26PWM

   Serial.begin(9600);
}

void loop() {

   PKS = 0;
   {
      if (digitalRead(A8) == HIGH) {
         PKS += 1;
      }
      {
         digitalWrite(8, HIGH);
      }
      if (digitalRead(A9) == HIGH) {
         PKS += 2;
      }
      {
         digitalWrite(9, HIGH);
      }
      if (digitalRead(A10) == HIGH) {
         PKS += 4;
      }
      {
         digitalWrite(10, HIGH);
      }
      if (digitalRead(A11) == HIGH) {
         PKS += 8;
      }
      {
         digitalWrite(11, HIGH);
      }
   }
   Serial.print(PKS);
   Serial.print(" = "); // sends switch value to serial monitor box
   Serial.println(" PKS"); // sends switch value to serial monitor box

   switch (PKS) { // Routine Case = OK switch(PKS)

   case 0:
      Serial.print("Maak Keuze "); // PKS = stand Nul
      LightLevel = 255;
      break;
   case 1:
      Serial.print("Graden opgeven "); // PKS = 1
      LightLevel = 255;
      break;
   case 2:
      Serial.print("Verdeling opgeven "); // PKS = 2
      LightLevel = 255;
      break;
   case 3:
      Serial.print("WW 40 Verdeling "); // PKS = 3
      LightLevel = 255;
      break;
   case 4:
      Serial.print("WW60 Verdeling "); // PKS = 4
      LightLevel = 255;
      break;
   case 5:
      Serial.print("WW72 Verdeling "); // PKS = 5
      LightLevel = 255;
      break;
   case 6:
      Serial.print("WW90 Verdeling "); // PKS = 6
      LightLevel = 255;
      break;
   case 7:
      Serial.print("Reserve 7 "); // PKS = 7
      LightLevel = 255;
      break;
   case 8:
      Serial.print("Reserve 8 "); // PKS = 8
      LightLevel = 255;
      break;
   case 9:
      Serial.print("Reserve 9 "); // PKS = 9
      LightLevel = 255;
      break;
   }

// Routine van de 3-Duimwielschakelaars is goed werkend / klaar

   DWSW = 0;
   {

      digitalWrite(11, HIGH); // 1e Duimwiel lezen 0 t/m 9
      digitalWrite(10, LOW); // Duimwiel 10 t/m 99
      digitalWrite(9, LOW); // Duimwiel 100 t/m 999

      if (digitalRead(A12) == HIGH) {
         DWSW += 1;
      }
      if (digitalRead(A13) == HIGH) {
         DWSW += 2;
      }
      if (digitalRead(A14) == HIGH) {
         DWSW += 4;
      }
      if (digitalRead(A15) == HIGH) {
         DWSW += 8;
      }

      digitalWrite(11, LOW); // Duimwiel 0 t/m 9
      digitalWrite(10, HIGH); // 2e Duimwiel lezen 10 t/m 99
      digitalWrite(9, LOW); // Duimwiel 100 t/m 999

      if (digitalRead(A12) == HIGH) {
         DWSW += 10;
      }
      if (digitalRead(A13) == HIGH) {
         DWSW += 20;
      }
      if (digitalRead(A14) == HIGH) {
         DWSW += 40;
      }
      if (digitalRead(A15) == HIGH) {
         DWSW += 80;
      }

      digitalWrite(11, LOW); // Duimwiel 0 t/m 9
      digitalWrite(10, LOW); // Duimwiel 10 t/m 99
      digitalWrite(9, HIGH); // 3e Duimwiel lezen 100 t/m 999

      if (digitalRead(A12) == HIGH) {
         DWSW += 100;
      }
      if (digitalRead(A13) == HIGH) {
         DWSW += 200;
      }
      if (digitalRead(A14) == HIGH) {
         DWSW += 400;
      }
      if (digitalRead(A15) == HIGH) {
         DWSW += 800;
      }

   } // derde wiel

   Serial.print(DWSW); // Tijdelijk laten zien wat de waarde is.
   Serial.print(" = "); // Tijdelijk laten zien wat de waarde is.
   Serial.print(" DWSW "); // Tijdelijk laten zien wat de waarde is.
   Serial.println(DWSW); // Tijdelijk laten zien wat de waarde is.

   delay(500);

}


[Redundant Profiel Privébericht]

Nico, bedankt, we gaan weer verder. gr Martin

[nicoverduin Profiel PrivéberichtWebsite]

Martin
Mijn eerste reactie zou zijn om bepaalde functionaliteiten in aparte functies te zetten zodat je de hoofdlijn van het programma gemakkelijker kan lezen.
Bijvoorbeeld het lezen van de duimwiel waarde zou als een functie gemaakt kunnen worden:

Code: Alles selecteren

/**
 * @name leesDuimwiel
 * @return pks   gelezen waarden uit de duimwiel schakelaar en zet bepaalde LEDS aan
 * Leest de duimwiel schakelaar binaire waarde op A8, A9, A10 en A11. Tevens worden de volgende LEDS aan gezet op het
 * moment dat het bit is gelezen:
 * A8    LED D8
 * A9    LED D9
 * A10    LED D10
 * A11    LED D11
 */
uint8_t leesDuimwiel(){

uint8_t duimwiel = 0;                        // resultaat waarde uit duimwiel
   //
   // lees de verschillende bits van de Duimwiel
   //
   if (digitalRead(A8) == HIGH) {
       duimwiel += 1;
   }
   digitalWrite(8, HIGH);
   
   if (digitalRead(A9) == HIGH) {
       duimwiel += 2;
   }
   digitalWrite(9, HIGH);
   
   if (digitalRead(A10) == HIGH) {
       duimwiel += 4;
   }
   digitalWrite(10, HIGH);
   
   if (digitalRead(A11) == HIGH) {
       duimwiel += 8;
   }
   digitalWrite(11, HIGH);
   //
   // geef de waarde terug
   //
   return duimwiel;
}


en in de loop krijg je dan

Code: Alles selecteren

PKS = leesDuimwiel();


En daarna kan je er nog een heleboel verbeteringen op loslaten en code verkleiningen.

[Redundant Profiel Privébericht]

Hallo Nico, je bent er al vroeg bij.
De Leds gebruik ik alleen om tijdelijk aan te geven dat de routine zover werkt.
Daarna kan begonnen worden met invullen van de LCD en de te volgen eind-routine.

WaT bedoel je met het maken van een functie en waar wordt die dan gezet?

[nicoverduin Profiel PrivéberichtWebsite]

Nu prop je alles in de loop(0 en dat maakt het vrij onoverzichtelijk. Als je naar het programma kijkt kun je die opdelen in een aantal stappen:
- lees duimwiel
- doe iets op basis van de keuze
- lees 3Duimwielschakelaars
Ik heb even jouw programma herschreven (deels) waarbij ik de functionaliteit heb opgebroken en dubbele code zoveel mogelijk verwijderd. Het kan nog mooier, maar kijk eerst maar of je dit nog kan volgen.

Overigens een functie = een subroutine die een waarde teruggeeft.
Een subroutine is een stukje code dat vanuit verschillende plekken in het programma aangeroepen kan worden. Vroeger was er nog onderscheid tussen een subroutine en functie. Tegenwoordig is het alleen nog functie omdat dat al voldoende de lading dekt.

In jouw code hieronder staan nu 2 functies:
a) leesDuimwiel
b) verwerkDuimwiel

Code: Alles selecteren

// http://www.brainstorm-vzw.be/stappenmotor/
// Webside met uitleg Stappenmotor.

// Arduino MEGA_2560
// Programma voor verdeeltafel-aansturing met 4_draden stappenmotor // en LCD_scherm ?
// Verdeeltafel kan met 4/60/72/90 verhouding zijn.

// Bediening

int Aan = 0; // Led Blauw betekend Schakeling = Aan TESTLED = Poort 13
int Uit = 0; // Alles Uit Kan ook rechtstreeks van Schakelaar

// LCD Scherm
int backLight = 10; // LCD Panel Backlight LED connected to digital pin 10
int LightLevel = 255; // Initialise light full on

// ProgrammaKeuze_schakelaar voor Nr.1= GRaden opgave Nr.2 = Verdeling opgeven Verhouding 3,4,5 = 40/60/72/90 of 6 t/m 0 = reserve

int PKSNul             = 0; // Nul Geen ProgrammaKeuze gemakat
int PKSGR             = 0; // 1 Graden opgeven
int PKSVd             = 0; // 2 Verdeling opgeven
int PKS40             = 0; // 3 Verdeelapparaat 1:40
int PKS60             = 0; // 4 Verdeelapparaat 1:60
int PKS72             = 0; // 5 Verdeelapparaat 1:72
int PKS90             = 0; // 6 Verdeelapparaat 1:90
int PKS_Reserve7    = 0; // 7 Reserve
int PKS_Reserve8    = 0; // 8 Reserve
int PKS_Reserve9    = 0; // 9 Reserve
//
// enumeraties
//
enum {
   duimwielPKS,         // programma keuze
   duimwielDWS            // geen idee hoe dit heet
};

//
// Programma keuze schakelaar
//
#define PKS1    A8         // LSB
#define PKS2    A9
#define PKS4    A10
#define PKS8    A11      // MSB

uint8_t PKS_array[] = { PKS1, PKS2, PKS4, PKS8 };

uint8_t PKS = 0; // Waarde ProgrammaKeuzeSchakelaar
//
// Bewerkingkeuze schakelaar. Dit zijn 3 parallel geschakelde duimwiel schakelaars waarbij
// DWS_KEUZEx aangeeft welk van de 3 wielen actief is.
//
int DWSW = 0; // Totaalwaarde set van 3-Duimwielschakelaars

#define DWS1   A12   // Paars analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
#define DWS2   A13   // Blauw analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
#define DWS4   A14   // Groen analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel
#define DWS8   A15   // Geel  analogread Bepalen aantal bewerkingen met 3_voudige Duimwiel

uint8_t DWS_array[] = {DWS1, DWS2, DWS4, DWS8 };

#define DWS_KEUZE1   11      // Eenheden
#define DWS_KEUZE2   10      // tientallen
#define DWS_KEUZE3   9         // hondertallen

uint8_t Keuze_array[] = {DWS_KEUZE1, DWS_KEUZE2, DWS_KEUZE3 };


int ledPinAU    = 12; // 12PWM Led Blauw Aan/Uit
int TestLed    = 13; // 13PWM Led TestLed ROOD

// Stappenmotor
int ledPinRM    = 2; // 2PWM Led Rood Stappenmotor draait (Revolution_Motor)
int ledPinSR    = 3; // 3PWM Led Groen Stappenmotor staat (Ready) klaar voor opdracht

int dirpin       = 0; // 22digitaal Draairichting Stappenmotor
int steppin    = 0; // 24digitaal Aantal stappen
int Speedpin    = 0; // 26digitaal Snelheid stappenmotor
int HoHT          = 0; // Aantal stappen per Tand (Hart op Hart afstand)

void setup() {

   pinMode(13, OUTPUT); // TestLed

   pinMode(ledPinSR, OUTPUT); // 3PWM Groene Led, Stappenmotor klaar voor nieuw signaal
   pinMode(ledPinRM, OUTPUT); // 2PWM Rode Led, stappenmotor draait
   //
   // Programmakeuze enkel Duimwiel
   // Common = rechtstreeks van 5V
   //
   for (uint8_t i = 0; i < 4; i++) {
      pinMode(PKS_array[i], INPUT);
   }
   //
   // Aantallen Opgave 3-Duimwielen
   // 3 X Common
   //
   for (uint8_t i = 0; i < 4; i++) {
      pinMode(Keuze_array[i], OUTPUT);
   }
   for (uint8_t i = 0; i < 4; i++) {
      pinMode(DWS_array[i], INPUT);
   }
   //
   // We zeggen dat de poorten voor de stappen en de pulsen outputs zijn.
   //
   pinMode(Speedpin, OUTPUT); // 26PWM
   pinMode(steppin, OUTPUT); // 24PWM
   pinMode(dirpin, OUTPUT); // 26PWM

   Serial.begin(9600);
}

void loop() {

   PKS = leesDuimwiel(duimwielPKS);

   Serial.print(PKS);
   Serial.print(" = "); // sends switch value to serial monitor box
   Serial.println(" PKS"); // sends switch value to serial monitor box

   verwerkPKS(PKS);

   // Routine van de 3-Duimwielschakelaars is goed werkend / klaar

   DWSW = leesDuimwiel(duimwielDWS);

   Serial.print(DWSW); // Tijdelijk laten zien wat de waarde is.
   Serial.print(" = "); // Tijdelijk laten zien wat de waarde is.
   Serial.print(" DWSW "); // Tijdelijk laten zien wat de waarde is.
   Serial.println(DWSW); // Tijdelijk laten zien wat de waarde is.

   delay(500);

}
/**
 * @name leesDuimwiel
 * @param  duimwielType   type duimwiel dat gekozen wordt PKS of DWS
 * @return resultaat  dE gelezen waarde uit de duimwiel schakelaar(S)
 * Leest de duimwiel schakelaars afhankelijk van het gekozen type. Daar alle pinnen indirect geadresseerd
 * worden via tabellen hoeven we ons hier niet druk te maken over de feitelijke pinnen. Hiermee bereik je een stuk
 * abstractie tussen functionaliteit en de feitelijke pinnen.
 */
uint8_t leesDuimwiel(uint8_t duimwielType){

   uint8_t resultaat = 0;      // het resultaat van de duimwiel actie
   uint8_t * duimwiel;            // wijst straks naar de juiste array (PKS_array of DWS_array)
   //
   // bepaal welke array we gaan gebruiken voor de juiste IO pinnen
   //
   if (duimwielType == duimwielPKS) {
      duimwiel = PKS_array;
   } else {
      duimwiel = DWS_array;
   }
   //
   // lees de duimwiel schakelaar(s)
   //
   for (uint8_t i = 0; i < 3; i++) {
      //
      // als het de PKS duimwiel is dan hoeven we maar een duimwiel te tellen
      //
      if (duimwielType == duimwielPKS) {
         //
         // het is maar een wiel dus ook een keer tellen
         //
         i = 3;
      } else {
         //
         // het is een DWS duimwiel dus ff alle pinnen op laag. Dan hoeven we alleen de goede hoog
         // te zetten voor het lezen straks
         //
         digitalWrite(Keuze_array[0], LOW);
         digitalWrite(Keuze_array[1], LOW);
         digitalWrite(Keuze_array[2], LOW);
         digitalWrite(Keuze_array[i], HIGH);
         //
         // eventueel resultaat dat we al hebben met 10 vermenigvuldigen
         //
         resultaat = resultaat * 10;
      }
      //
      // en nu loopen we via de verschillende duimwiel schakelaars
      //

      uint8_t temp             = 0;         // temp bevat de waarde van de duimwiel schakelaar die gelezen wordt
      uint8_t multiplier    = 1;         // de eerste waarde x 1
      //
      // nu ff alle pinnen lezen en temp bepalen
      //
      for (uint8_t j = 0; j < 4; j++) {
         //
         // digitalRead geeft de waarde 0 of 1 terug dus kan je klakkeloos vermenivuldigen en optellen
         // van de multiplyer
         temp             = temp + (digitalRead(duimwiel[j]) * multiplier);
         //
         // volgende vermenigvuldiger is 2x zo groot
         //
         multiplier    = multiplier * 2;
      }
      //
      // resultaat verhogen met temp
      //
      resultaat = resultaat + temp;
   }
   //
   // geef het resultaat terug aan de aanroeper
   //
   return resultaat;
}
/**
 * @name verwerkPKS(uint8_t pks)
 * @param pks programma keuze
 * Verwerken van de gekozen programmakeuze
 */
void verwerkPKS(uint8_t pks) {

   switch (pks) { // Routine Case = OK switch(PKS)

   case 0:
      Serial.print("Maak Keuze "); // PKS = stand Nul
      LightLevel = 255;
      break;
   case 1:
      Serial.print("Graden opgeven "); // PKS = 1
      LightLevel = 255;
      break;
   case 2:
      Serial.print("Verdeling opgeven "); // PKS = 2
      LightLevel = 255;
      break;
   case 3:
      Serial.print("WW 40 Verdeling "); // PKS = 3
      LightLevel = 255;
      break;
   case 4:
      Serial.print("WW60 Verdeling "); // PKS = 4
      LightLevel = 255;
      break;
   case 5:
      Serial.print("WW72 Verdeling "); // PKS = 5
      LightLevel = 255;
      break;
   case 6:
      Serial.print("WW90 Verdeling "); // PKS = 6
      LightLevel = 255;
      break;
   case 7:
      Serial.print("Reserve 7 "); // PKS = 7
      LightLevel = 255;
      break;
   case 8:
      Serial.print("Reserve 8 "); // PKS = 8
      LightLevel = 255;
      break;
   case 9:
      Serial.print("Reserve 9 "); // PKS = 9
      LightLevel = 255;
      break;
   }
}


Ik heb de code niet kunnen testen. Dat mag jij doen . Compileert wel goed.

[Redundant Profiel Privébericht]

Hallo Nico, ik moet wel bekennen dat ik eigenlijk niet snapte hoe e.e.a. werkt met de gegevens die je aangeeft.

Maar ik ben er eens goed voor gaan zitten en het begint te dagen.
Ga even een nieuw opzetje maken en uitproberen hoe het echt werkt als ik zelf iets uitwerkt.
En daarna in het programma aanpassen waar nodig,

Bedankt zover, heel interessant allemaal.

[nicoverduin Profiel PrivéberichtWebsite]

Gewoon een groot probleem opdelen in kleine enkelvoudige problemen.