HELP pls! using a series of 7 LDR's in the right sequence to light a display

Other Hardware Sensors
1

I am trying to get a circuit, with seven LDR's, you have to point a laser at them in the right order to get a display to light up. at first i tried seven if statements within each other... didnt succeed, then 7 different loops, with each time the right LDR was activated it would move onto the next loop, to no success. I've now tried to just do it in the void loop mainly but am also stuck....

I think the main issue are my side loops, and formatting? - not sure of the lingo... first time on here and doing arduino/coding...

i have checked and my LDR's are sensing fine, until the correct LDR (the first one in the series) is activated, then after this value the code freezes and it just stops....

const int LED1 = 13;
const int LED2 = 12;
const int LED3 = 11;
const int LED4 = 10;
const int LED5 = 9;
const int LED6 = 8;
const int LED7 = 7;
const int DISPLAY1 = 15;
const int DETECTOR1 = A0;
const int DETECTOR2 = A1;
const int DETECTOR3 = A2;
const int DETECTOR4 = A3;
const int DETECTOR5 = A4;
const int DETECTOR6 = A5;
const int DETECTOR7 = A6;
bool newval1 = false;
bool newval2 = false;
bool newval3 = false;
bool newval4 = false;
bool newval5 = false;
bool newval6 = false;
bool newval7 = false;
bool confval1 = false;
bool confval2 = false;
bool confval3 = false;
bool confval4 = false;
bool confval5 = false;
bool confval6 = false;
bool confval7 = false;
bool confval8 = false;
int VAL1 = 0;
int VAL2 = 0;
int VAL3 = 0;
int VAL4 = 0;
int VAL5 = 0;
int VAL6 = 0;
int VAL7 = 0;

int sensorValue = 0; // variable to store the value coming from the sensor

void setup() {
pinMode(LED1 , OUTPUT);
pinMode(LED2 , OUTPUT);
pinMode(LED3 , OUTPUT);
pinMode(LED4 , OUTPUT);
pinMode(LED5 , OUTPUT);
pinMode(LED6 , OUTPUT);
pinMode(LED7 , OUTPUT);
pinMode(DETECTOR1 , INPUT);
pinMode(DETECTOR2 , INPUT);
pinMode(DETECTOR3 , INPUT);
pinMode(DETECTOR4 , INPUT);
pinMode(DETECTOR5 , INPUT);
pinMode(DETECTOR6 , INPUT);
pinMode(DETECTOR7 , INPUT);
pinMode(DISPLAY1 , OUTPUT);
//lcd.begin(4, 1);
//lcd.print("0285")
Serial.begin(9600); //sets serial port for communication
start();
}
void start() { //a loop to reset my code, its meant to be easily repeatable without a hard reset

newval1 = false;
newval2 = false;
newval3 = false;
newval4 = false;
newval5 = false;
newval6 = false;
newval7 = false;
confval1 = true;
confval2 = false;
confval3 = false;
confval4 = false;
confval5 = false;
confval6 = false;
confval7 = false;
confval8 = false;
return;
}

void loop() {
sensorValue = analogRead(DETECTOR4); // read the value from the sensor
Serial.println(sensorValue); //prints the values coming from the sensor on the screen
while (confval2 == true) {
digitalWrite(LED1 , HIGH);
}
while (confval3 == true) {;
digitalWrite(LED2 , HIGH);
}
while (confval4 == true) {
digitalWrite(LED3 , HIGH);
}
while (confval5 == true) {;
digitalWrite(LED4 , HIGH);
}
while (confval6 == true) {
digitalWrite(LED5 , HIGH);
}
while (confval7 == true) {
digitalWrite(LED6 , HIGH);
}
while (confval8 == true) {
digitalWrite(LED7 , HIGH);
//write the display stuff here

} // these values will turn the light on
VAL1 = analogRead(A0);
if (VAL1 <= 945) {
newval1 = true;
}
delay(100);
VAL2 = analogRead(A1);
if (VAL2 <= 945) {
newval2 = true;
}
delay(100);
VAL3 = analogRead(A2);
if (VAL3 <= 945) {
newval3 = true;
}
delay(100);
VAL4 = analogRead(A3);
if (VAL4 <= 945) {
newval4 = true;
}
delay(100);
VAL5 = analogRead(A4);
if (VAL5 <= 945) {
newval5 = true;
}
delay(100);
VAL6 = analogRead(A5);
if (VAL6 <= 945) {
newval6 = true;
}
delay(100);
VAL7 = analogRead(A6);
if (VAL7 <= 945) {
newval7 = true;
}
delay(100); // to check the LDR's about once a sec when all the timers are accounted for
if ((newval1 == true || newval3 == true || newval4 == true || newval5 == true || newval6 == true || newval2 == true) && confval7 == true) {
start();
}
delay(20);
if (newval7 == true && confval7 == true) {
light7();
}
delay(20);
if (newval7 == true && confval8 == true) {
newval7 = false;
}
delay(20); // these come in triplets, to check if the right LDR is activated, if so allows the next to be activated, if not resets it.
// they finish off the void loop (about 6 triplets, and one double of this format for the 7 LDRs)
if ((newval1 == true || newval3 == true || newval4 == true || newval5 == true || newval2 == true || newval7 == true) && confval6 == true) {
start();
}
delay(20);
if (newval6 == true && confval6 == true) {
light6();
}
delay(20);
if (newval6 == true && confval7 == true) {
newval6 = false;
}
delay(20);
if ((newval1 == true || newval3 == true || newval4 == true || newval2 == true || newval6 == true || newval7 == true) && confval5 == true) {
start();
}
delay(20);
if (newval5 == true && confval5 == true) {
light5();
}
delay(20);
if (newval5 == true && confval6 == true) {
newval5 = false;
}
delay(20);
if ((newval1 == true || newval2 == true || newval3 == true || newval5 == true || newval6 == true || newval7 == true) && confval4 == true) {
start();
}
delay(20);
if (newval4 == true && confval4 == true) {
light4();
}
delay(20);
if (newval4 == true && confval5 == true) {
newval4 = false;
}
delay(20);
if ((newval1 == true || newval2 == true || newval4 == true || newval5 == true || newval6 == true || newval7 == true) && confval3 == true) {
start();
}
delay(20);
if (newval3 == true && confval3 == true) {
light3();
}
delay(20);
if (newval3 == true && confval4 == true) {
newval3 = false;
}
delay(20);
if ((newval1 == true || newval3 == true || newval4 == true || newval5 == true || newval6 == true || newval7 == true) && confval2 == true) {
start();
}
delay(20);
if (newval2 == true && confval2 == true) {
light2();
}
delay(20);
if (newval2 == true && confval3 == true) {
newval2 = false;
}
delay(20);
if (newval1 == true && confval1 == true) {
light1();
}
delay(20);
if (newval1 == true && confval2 == true) {
newval1 = false;
}
delay(20);

}
void light1() {
newval2 = false;
newval3 = false;
newval4 = false;
newval5 = false;
newval6 = false;
newval7 = false;
confval2 = true;
return; // these code allows the next LDR to be activated, whilst resetting the previous values so it doesnt get messed up.
}

void light2() {
newval1 = false;
newval3 = false;
newval4 = false;
newval5 = false;
newval6 = false;
newval7 = false;
confval3 = true;
return;
}

void light3() {
newval2 = false;
newval1 = false;
newval4 = false;
newval5 = false;
newval6 = false;
newval7 = false;
confval4 = true;
return;
}
void light4() {
newval2 = false;
newval3 = false;
newval1 = false;
newval5 = false;
newval6 = false;
newval7 = false;
confval5 = true;
return;
}
void light5() {
newval2 = false;
newval3 = false;
newval4 = false;
newval1 = false;
newval6 = false;
newval7 = false;
confval6 = true;
return;
}
void light6() {
newval2 = false;
newval3 = false;
newval1 = false;
newval5 = false;
newval1 = false;
newval7 = false;
confval7 = true;
return;
}
void light7() {
newval2 = false;
newval3 = false;
newval1 = false;
newval5 = false;
newval6 = false;
newval1 = false;
confval8 = true;
return;
}

please_work.ino (6.95 KB)

2

funnycones:
I think the main issue are my side loops, and formatting? - not sure of the lingo... first time on here and doing arduino/coding...

First, edit your post using code tags - How to use this forum.

A site search of 'combination lock' should turn up some relevant posts.

3

As soon as you feel the need to use numbers in your variables it's time to look up the use of arrays. I'm sure your code can be shrunk drastically making it more readable & maintainable at the same time.

4

This is a problem that needs a state-machine to implement. You need to make explicit the states and the transistions between them. Learn to draw state-transition diagrams, it comes in handy all over the place.

For instance you need a state for each stage in the LDR recognition process, that only transitions to the next stage on the correct input, otherwise falls back to the initial state.

Here array for the LDRs makes sense and the state should include a number than indexes that array.

State machines are powerful for several reasons:

  1. The diagrams are a great aid to coding and avoiding confusion.
  2. You can run any number of state-machines in parallel - just provide a call in loop() to the handler of each machine.
  3. It makes it straight-forward to avoid using delay(), as you can use a state with only a timeout transition.
  4. Many user-interface mechanism implicitly have state (recognizing a double-click is a simple example).