Timer Test Bench

Project to build a programmable timer test bench based on Arduino Nano and Mega.

Dec 30, 2023

•

1558 views

•

0 respects

•

GPL3+

Devices & Components

Arduino Mega 2560 Rev3

Arduino Nano

4x4 Matrix Membrane Keypad

5v 8 relay module

8 Digits LED Seven Segment Display

12V battery

Hardware & Tools

Soldering Station

drill, screwdriver, soldering iron

Software & Tools

ChatGPT

Project description

Code

Slave

Slave code with relay start instruction for Mega.

1#include <Wire.h>
2
3#define RELAY_COUNT 8
4int relayPins[RELAY_COUNT] = {A0, A1, A2, A3, A4, A5, A6, A7};
5
6int currentRelay = 0;
7unsigned long previousMillis = 0;
8const unsigned long relayDelay = 100;  
9
10void setup() {
11  Serial.begin(9600);
12  Wire.begin(8);
13  Wire.onReceive(receiveEvent);
14
15  for (int i = 0; i < RELAY_COUNT; i++) {
16    pinMode(relayPins[i], OUTPUT);
17    digitalWrite(relayPins[i], LOW);
18  }
19}
20
21void loop() {
22  // Le code de l'esclave peut effectuer d'autres tâches ici si nécessaire
23}
24
25void receiveEvent() {
26  while (Wire.available()) {
27    byte command = Wire.read();
28
29    Serial.print("Received command: ");
30    Serial.println(command, HEX);
31
32    if (command == 0xAA) {
33      activateRelays();
34    } else {
35      // Gérer d'autres commandes si nécessaire
36    }
37  }
38}
39
40void activateRelays() {
41  unsigned long currentMillis = millis();
42
43  if (currentMillis - previousMillis >= relayDelay) {
44    previousMillis = currentMillis;
45
46    if (currentRelay < RELAY_COUNT) {
47      digitalWrite(relayPins[currentRelay], HIGH);
48      currentRelay++;
49    } else {
50      // Réinitialiser pour la prochaine séquence
51      currentRelay = 0;
52    }
53  }
54}

#include <Wire.h>

#define RELAY_COUNT 8
int relayPins[RELAY_COUNT] = {A0, A1, A2, A3, A4, A5, A6, A7};

int currentRelay = 0;
unsigned long previousMillis = 0;
const unsigned long relayDelay = 100;  

void setup() {
  Serial.begin(9600);
  Wire.begin(8);
  Wire.onReceive(receiveEvent);

  for (int i = 0; i < RELAY_COUNT; i++) {
    pinMode(relayPins[i], OUTPUT);
    digitalWrite(relayPins[i], LOW);
  }
}

void loop() {
  // Le code de l'esclave peut effectuer d'autres tâches ici si nécessaire
}

void receiveEvent() {
  while (Wire.available()) {
    byte command = Wire.read();

    Serial.print("Received command: ");
    Serial.println(command, HEX);

    if (command == 0xAA) {
      activateRelays();
    } else {
      // Gérer d'autres commandes si nécessaire
    }
  }
}

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

  if (currentMillis - previousMillis >= relayDelay) {
    previousMillis = currentMillis;

    if (currentRelay < RELAY_COUNT) {
      digitalWrite(relayPins[currentRelay], HIGH);
      currentRelay++;
    } else {
      // Réinitialiser pour la prochaine séquence
      currentRelay = 0;
    }
  }
}

Master

Timer code with bus instruction for Nano.

1#include <Wire.h>
2#include <Keypad.h>
3#include <LedControl.h>
4#include "I2CCommunication.h"
5
6const byte ROWS = 4;
7const byte COLS = 4;
8char keys[ROWS][COLS] = {
9  {'1', '2', '3', 'A'},
10  {'4', '5', '6', 'B'},
11  {'7', '8', '9', 'C'},
12  {'*', '0', '#', 'D'}
13};
14byte rowPins[ROWS] = {6, 7, 8, 9};
15byte colPins[COLS] = {2, 3, 4, 5};
16
17Keypad keypadObj = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
18LedControl lc = LedControl(10, 11, 12, 1);
19
20long csecondsLeft;
21int decrement = 3;
22bool explosed = false;
23bool defused = false;
24
25long hours = 0;
26long minutes = 0;
27long seconds = 0;
28long hundredths = 0;
29
30String code = "";
31
32char keypadOutput[32] = {0};
33byte playSound = A0;
34
35bool isProgrammingTime = false;
36String inputKeys = "";
37String programmedTime = "";
38bool isCountingDown = false;
39
40void setup() {
41  csecondsLeft = 0;
42  Serial.begin(9600);
43  lc.shutdown(0, false);
44  lc.setIntensity(0, 10);
45  lc.clearDisplay(0);
46
47  tone(playSound, 2000, 80); digitalWrite(13, HIGH); delay(50); digitalWrite(13, LOW); delay(150);
48  tone(playSound, 2000, 80); digitalWrite(13, HIGH); delay(50); digitalWrite(13, LOW); delay(150);
49  tone(playSound, 2000, 80); digitalWrite(13, HIGH); delay(50); digitalWrite(13, LOW); delay(150);
50  
51  lc.setChar(0,7,'-',false); lc.setChar(0,0,'-',false); delay(80); lc.clearDisplay(0); 
52  lc.setChar(0,6,'-',false); lc.setChar(0,1,'-',false); delay(80); lc.clearDisplay(0); 
53  lc.setChar(0,5,'-',false); lc.setChar(0,2,'-',false); delay(80); lc.clearDisplay(0); 
54  lc.setChar(0,4,'-',false); lc.setChar(0,3,'-',false); delay(80); lc.clearDisplay(0); 
55  lc.setChar(0,5,'-',false); lc.setChar(0,2,'-',false); delay(80); lc.clearDisplay(0); 
56  lc.setChar(0,6,'-',false); lc.setChar(0,1,'-',false); delay(80); lc.clearDisplay(0);
57  lc.setChar(0,7,'-',false); lc.setChar(0,0,'-',false); delay(80); lc.clearDisplay(0); 
58
59  pinMode(A0, OUTPUT);
60  pinMode(A1, OUTPUT);
61  pinMode(A3, OUTPUT);
62  pinMode(A6, OUTPUT);
63  pinMode(13, OUTPUT);
64
65  analogWrite(A0, 0);
66
67  Wire.begin(8); // Initialise la communication I2C
68}
69
70void updateDisplay() {
71  long remainingSeconds = csecondsLeft / 60;
72  hours = remainingSeconds / 3600;
73  remainingSeconds %= 3600;
74  minutes = remainingSeconds / 60;
75  seconds = remainingSeconds % 60;
76  hundredths = csecondsLeft % 60;
77
78  lc.setDigit(0, 7, hours / 10, false);
79  lc.setDigit(0, 6, hours % 10, false);
80  lc.setDigit(0, 5, minutes / 10, false);
81  lc.setDigit(0, 4, minutes % 10, false);
82  lc.setDigit(0, 3, seconds / 10, false);
83  lc.setDigit(0, 2, seconds % 10, false);
84  lc.setDigit(0, 1, hundredths / 10, false);
85  lc.setDigit(0, 0, hundredths % 10, false);
86}
87
88void programTime() {
89  if (inputKeys.length() >= 8) {
90    inputKeys = inputKeys.substring(0, 8);
91    programmedTime = inputKeys.substring(0, 2) + ":" + inputKeys.substring(2, 4) + ":" + inputKeys.substring(4, 6) + ":" + inputKeys.substring(6, 8);
92
93    Serial.print("inputKeys: ");
94    Serial.println(inputKeys);
95    Serial.print("programmedTime: ");
96    Serial.println(programmedTime);
97
98    lc.clearDisplay(0);
99
100    inputKeys = "";
101  }
102}
103
104void startCountdown() {
105  Serial.println("Starting countdown...");
106
107  if (programmedTime.length() == 11) {
108    hours = programmedTime.substring(0, 2).toInt();
109    minutes = programmedTime.substring(3, 5).toInt();
110    seconds = programmedTime.substring(6, 8).toInt();
111    hundredths = programmedTime.substring(9, 11).toInt();
112
113    csecondsLeft = ((hours * 3600) + (minutes * 60) + seconds) * 60 + hundredths;
114  } else {
115    Serial.println("Invalid programmed time. Please enter a time greater than zero.");
116    return;
117  }
118
119  updateDisplay();
120  isCountingDown = true;
121}
122
123void loop() {
124
125  char key = keypadObj.getKey();
126
127  if (key) {
128    Serial.print("Key Pressed: ");
129    Serial.println(key);
130
131    if (key >= '0' && key <= '9') {
132      int num = key - '0';
133      int displayIndex = 7 - inputKeys.length();
134      lc.setDigit(0, displayIndex, num, false);
135      inputKeys += key;
136      tone(playSound, 2000, 50);
137    }
138
139    if (!isProgrammingTime && key == 'A') {
140      Serial.println("Programming time...");
141      isProgrammingTime = true;
142      inputKeys = "";
143      programmedTime = "";
144      lc.clearDisplay(0);
145    } else if (isProgrammingTime && key == 'D') {
146      isProgrammingTime = false;
147      programTime();
148      Serial.print("Programmed Time: ");
149      Serial.println(programmedTime);
150      startCountdown();
151      programmedTime = "";
152    } else if (isCountingDown && key == 'B') {
153      Serial.println(code);
154      decrement = 0;
155      defused = true;
156      code = "";
157    } else if (isCountingDown && key == 'D') {
158      Serial.println(code);
159      decrement = 3;
160      defused = false;
161      code = "";
162    } else if (key == 'C') {
163      isProgrammingTime = false;
164      lc.setDigit(0, 7, 0, false);
165      lc.clearDisplay(0);
166    }
167  }
168
169  
170  if (isCountingDown) {
171    delay(50);
172    csecondsLeft -= decrement;
173
174    if (csecondsLeft < 0) {
175      csecondsLeft = 0;
176      if (!explosed) {
177        sendI2CCommand(0xFF); // Envoyer une commande I2C à l'esclave
178        digitalWrite(13, HIGH);
179        digitalWrite(A1, HIGH);
180        digitalWrite(A3, HIGH);
181        digitalWrite(A6, HIGH);
182        explosed = true;
183      }
184    }
185    updateDisplay();
186    if (csecondsLeft % 60 == 0) {
187      tone(playSound, 3236, 150);
188      if (csecondsLeft == 0) {
189        // Envoyer une nouvelle commande pour démarrer la séquence des relais
190        sendI2CCommand(0xAA);
191      }
192    }
193  }
194}

#include <Wire.h>
#include <Keypad.h>
#include <LedControl.h>
#include "I2CCommunication.h"

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {6, 7, 8, 9};
byte colPins[COLS] = {2, 3, 4, 5};

Keypad keypadObj = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
LedControl lc = LedControl(10, 11, 12, 1);

long csecondsLeft;
int decrement = 3;
bool explosed = false;
bool defused = false;

long hours = 0;
long minutes = 0;
long seconds = 0;
long hundredths = 0;

String code = "";

char keypadOutput[32] = {0};
byte playSound = A0;

bool isProgrammingTime = false;
String inputKeys = "";
String programmedTime = "";
bool isCountingDown = false;

void setup() {
  csecondsLeft = 0;
  Serial.begin(9600);
  lc.shutdown(0, false);
  lc.setIntensity(0, 10);
  lc.clearDisplay(0);

  tone(playSound, 2000, 80); digitalWrite(13, HIGH); delay(50); digitalWrite(13, LOW); delay(150);
  tone(playSound, 2000, 80); digitalWrite(13, HIGH); delay(50); digitalWrite(13, LOW); delay(150);
  tone(playSound, 2000, 80); digitalWrite(13, HIGH); delay(50); digitalWrite(13, LOW); delay(150);
  
  lc.setChar(0,7,'-',false); lc.setChar(0,0,'-',false); delay(80); lc.clearDisplay(0); 
  lc.setChar(0,6,'-',false); lc.setChar(0,1,'-',false); delay(80); lc.clearDisplay(0); 
  lc.setChar(0,5,'-',false); lc.setChar(0,2,'-',false); delay(80); lc.clearDisplay(0); 
  lc.setChar(0,4,'-',false); lc.setChar(0,3,'-',false); delay(80); lc.clearDisplay(0); 
  lc.setChar(0,5,'-',false); lc.setChar(0,2,'-',false); delay(80); lc.clearDisplay(0); 
  lc.setChar(0,6,'-',false); lc.setChar(0,1,'-',false); delay(80); lc.clearDisplay(0);
  lc.setChar(0,7,'-',false); lc.setChar(0,0,'-',false); delay(80); lc.clearDisplay(0); 

  pinMode(A0, OUTPUT);
  pinMode(A1, OUTPUT);
  pinMode(A3, OUTPUT);
  pinMode(A6, OUTPUT);
  pinMode(13, OUTPUT);

  analogWrite(A0, 0);

  Wire.begin(8); // Initialise la communication I2C
}

void updateDisplay() {
  long remainingSeconds = csecondsLeft / 60;
  hours = remainingSeconds / 3600;
  remainingSeconds %= 3600;
  minutes = remainingSeconds / 60;
  seconds = remainingSeconds % 60;
  hundredths = csecondsLeft % 60;

  lc.setDigit(0, 7, hours / 10, false);
  lc.setDigit(0, 6, hours % 10, false);
  lc.setDigit(0, 5, minutes / 10, false);
  lc.setDigit(0, 4, minutes % 10, false);
  lc.setDigit(0, 3, seconds / 10, false);
  lc.setDigit(0, 2, seconds % 10, false);
  lc.setDigit(0, 1, hundredths / 10, false);
  lc.setDigit(0, 0, hundredths % 10, false);
}

void programTime() {
  if (inputKeys.length() >= 8) {
    inputKeys = inputKeys.substring(0, 8);
    programmedTime = inputKeys.substring(0, 2) + ":" + inputKeys.substring(2, 4) + ":" + inputKeys.substring(4, 6) + ":" + inputKeys.substring(6, 8);

    Serial.print("inputKeys: ");
    Serial.println(inputKeys);
    Serial.print("programmedTime: ");
    Serial.println(programmedTime);

    lc.clearDisplay(0);

    inputKeys = "";
  }
}

void startCountdown() {
  Serial.println("Starting countdown...");

  if (programmedTime.length() == 11) {
    hours = programmedTime.substring(0, 2).toInt();
    minutes = programmedTime.substring(3, 5).toInt();
    seconds = programmedTime.substring(6, 8).toInt();
    hundredths = programmedTime.substring(9, 11).toInt();

    csecondsLeft = ((hours * 3600) + (minutes * 60) + seconds) * 60 + hundredths;
  } else {
    Serial.println("Invalid programmed time. Please enter a time greater than zero.");
    return;
  }

  updateDisplay();
  isCountingDown = true;
}

void loop() {

  char key = keypadObj.getKey();

  if (key) {
    Serial.print("Key Pressed: ");
    Serial.println(key);

    if (key >= '0' && key <= '9') {
      int num = key - '0';
      int displayIndex = 7 - inputKeys.length();
      lc.setDigit(0, displayIndex, num, false);
      inputKeys += key;
      tone(playSound, 2000, 50);
    }

    if (!isProgrammingTime && key == 'A') {
      Serial.println("Programming time...");
      isProgrammingTime = true;
      inputKeys = "";
      programmedTime = "";
      lc.clearDisplay(0);
    } else if (isProgrammingTime && key == 'D') {
      isProgrammingTime = false;
      programTime();
      Serial.print("Programmed Time: ");
      Serial.println(programmedTime);
      startCountdown();
      programmedTime = "";
    } else if (isCountingDown && key == 'B') {
      Serial.println(code);
      decrement = 0;
      defused = true;
      code = "";
    } else if (isCountingDown && key == 'D') {
      Serial.println(code);
      decrement = 3;
      defused = false;
      code = "";
    } else if (key == 'C') {
      isProgrammingTime = false;
      lc.setDigit(0, 7, 0, false);
      lc.clearDisplay(0);
    }
  }

  
  if (isCountingDown) {
    delay(50);
    csecondsLeft -= decrement;

    if (csecondsLeft < 0) {
      csecondsLeft = 0;
      if (!explosed) {
        sendI2CCommand(0xFF); // Envoyer une commande I2C à l'esclave
        digitalWrite(13, HIGH);
        digitalWrite(A1, HIGH);
        digitalWrite(A3, HIGH);
        digitalWrite(A6, HIGH);
        explosed = true;
      }
    }
    updateDisplay();
    if (csecondsLeft % 60 == 0) {
      tone(playSound, 3236, 150);
      if (csecondsLeft == 0) {
        // Envoyer une nouvelle commande pour démarrer la séquence des relais
        sendI2CCommand(0xAA);
      }
    }
  }
}

bus management file

cpp

I2C communication .h file for Master code.

1// I2CCommunication.h
2#ifndef I2C_COMMUNICATION_H
3#define I2C_COMMUNICATION_H
4
5#include <Wire.h>
6#include <Arduino.h>
7
8void sendI2CCommand(byte command);
9void checkConnection();
10
11#endif // I2C_COMMUNICATION_H

// I2CCommunication.h
#ifndef I2C_COMMUNICATION_H
#define I2C_COMMUNICATION_H

#include <Wire.h>
#include <Arduino.h>

void sendI2CCommand(byte command);
void checkConnection();

#endif // I2C_COMMUNICATION_H

bus management file

cpp

I2C communication .cpp file for Master code.

1// I2CCommunication.cpp
2#include "I2CCommunication.h"
3#include <Arduino.h>
4
5
6void sendI2CCommand(byte command) {
7  Wire.beginTransmission(8);  // Adresse I2C de l'esclave
8  Wire.write(command);
9  Wire.endTransmission();
10}

// I2CCommunication.cpp
#include "I2CCommunication.h"
#include <Arduino.h>


void sendI2CCommand(byte command) {
  Wire.beginTransmission(8);  // Adresse I2C de l'esclave
  Wire.write(command);
  Wire.endTransmission();
}

Comments

Only logged in users can leave comments

acidfurs

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content