Recuperer valeur du clavier membrane et le soustraire avec l'heure actuelle

Bonjour,

Ce que je veux actuellement faire, c'est qu'une personne tape au clavier membrane une heure et que cette heure la se soustrait a l'heure actuelle du module DS1307 et que le tout déclenche un compte a rebours et a la fin du compte a rebours une musique se joue.

Par exemple, il est 11h du matin, l'utilisateur tape 12h00, alors que je veux un compte a rebours d'1h et qu'a la fin de ce compte a rebours la musique se joue.

J'utilise un ecran LCD 16x2

Alors voici pour l’instant ce que j'ai fait

//Afficher l'heure actuelle :


DS3231 clock;
RTCDateTime dt;

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

void setup()
{
  
  lcd.begin(16, 2);
  clock.begin();

  // Send sketch compiling time to Arduino
  clock.setDateTime(__DATE__, __TIME__);
}


void heure()
{
   
   dt = clock.getDateTime();

  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  
  // print the number of seconds since reset:
  //lcd.print(millis()/1000);
 
 
  lcd.setCursor(0, 0);
  lcd.print(dt.hour);   lcd.print(":");
  lcd.print(dt.minute); lcd.print(":");
  lcd.print(dt.second);
  
  
}

Pour le compte a rebours :

void comptearebours()
{
   
  for (byte digit = 12; digit > 0; --digit) 
  {
    delay(1000);
    lcd.setCursor(0,2);
    lcd.print(digit-2); 
    
    if (digit == 1)
      {
        
        // lancer la musique
        lcd.clear();
        lcd.print("Musique!!"); 
       midi();
      }
      
  }
}

Et pour le clavier membrane :

void clavier()
{
char key = customKeypad.getKey();
Serial.print(key); 
  if (int(key) != 0) {
    
    if (key == ourCode[currentPosition])
      {
        ++currentPosition;
        if (currentPosition == 3)
        {
          unlockDoor();
          currentPosition = 0;
        }
      } else {
        invalidCode();
        currentPosition = 0;
      }
  }
}

void invalidCode()
{
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("CODE REFUSE");
  delay(5000);
}

void unlockDoor()
{
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("CODE BON");
  delay(5000);
  heure();
  delay(5000);
  reboot();

}

Maintenant, depuis quelques jours, je ne sais pas comment on peut récupérer la valeur du clavier ensuite la convertir en une heure pour la soustraire a l'heure actuelle pour ensuite la reconvertir pour le compte a rebours, j'ai essayer de chercher mais sans résultat

Comment je pourrais faire ?

Merci

fa23

D'abord, a quoi ressemble ton clavier ? Peux tu montrer une photo ou donner un lien vers un clavier similaire ?

Le plus simple pour entrer une heure et d'entrer quatre chiffres. Tu captes ces chiffres l'un après l'autre et tu en fais un nombre de quatre chiffres, qui représentera l'heure. Par exemple si on entre 1 2 4 6, tu auras le nombre 1246 pour 12 heures 46 minutes.

Sais tu comment obtenir ce nombre à partir des quatre chiffres ? Il faut penser à taper le 0 si l'heure est avant 10:00. Ou alors, un appui sur une touche non numérique indique que l'utilisateur a terminé.

Tu peux ensuite calculer le nombre de minutes écoulées depuis 0:00 (ou minuit) pour tes deux heures et faire la soustraction. Ça te donnera le nombre de minutes du compte à rebours

Salut,
Voici le clavier que je possède:

Non je ne sais pas du tout comment faire pour obtenir ce nombre à partir des quatre chiffres.

Merci

fa2302

Ok, tu peux partir du code de l'instructable. As-tu réussi à le faire fonctionner ?

Tu peux utiliser ce code pour lire les quatre chiffres. Il suffit de créer un compteur que tu incrémentes à chaque fois que le clavier détecte un appui.

La lecture du clavier renvoie un char, par exemple '3'. Le char contient le code ASCII du caractère '3'. Pour obtenir le chiffre 3 à partir de ce char il suffit de faire

chiffre = key - '0';

Ou key est le char lu au clavier.

Tu mets ça dans une boucle qui tourne tant que ton compteur est inférieur à 4.
À chaque lecture du clavier, tu calcules le nombre auquel s'ajoute ton nouveau chiffre.

nombre = nombre * 10 + chiffre ;

À la fin de la boucle, tu auras ton nombre. Les heures et minutes s'obtiennent par

heure = nombre / 100;
minute = nombre % 100;

% est l'opération modulo.

Salut, le code instructable fonctionne mais ensuite j’ai poursuivi avec ce code la :

char keys = customKeypad.getKey();
  Serial.print(keys);
  
  char chiffre = keys - '0';
  int nombre;
  for (int compteur = 0; compteur <= 4; --compteur)
  {
    nombre = nombre * 10 + chiffre ;
  }

 int heure = nombre / 100;
 int minute = nombre % 100;

 Serial.print(heure);
  Serial.print(minute);

et la il ne me détecte plus du tout les touches que j’appuie

Merci

fa23

C'est plus compliqué que ça. La boucle doit contenir la lecture du clavier.

Pour t'aider, il me faut le code en entier ou au moins le nom de la bibliothèque que tu utilises pour le clavier

Salut, le nom de la bibliotheque c’est Keypad

Keypad.cpp

#include <Keypad.h>

// <<constructor>> Allows custom keymap, pin configuration, and keypad sizes.
Keypad::Keypad(char *userKeymap, byte *row, byte *col, byte numRows, byte numCols) {
 rowPins = row;
 columnPins = col;
 sizeKpd.rows = numRows;
 sizeKpd.columns = numCols;

 begin(userKeymap);

 setDebounceTime(10);
 setHoldTime(500);
 keypadEventListener = 0;

 startTime = 0;
 single_key = false;
}

// Let the user define a keymap - assume the same row/column count as defined in constructor
void Keypad::begin(char *userKeymap) {
    keymap = userKeymap;
}

// Returns a single key only. Retained for backwards compatibility.
char Keypad::getKey() {
 single_key = true;

 if (getKeys() && key[0].stateChanged && (key[0].kstate==PRESSED))
 return key[0].kchar;
 
 single_key = false;

 return NO_KEY;
}

// Populate the key list.
bool Keypad::getKeys() {
 bool keyActivity = false;

 // Limit how often the keypad is scanned. This makes the loop() run 10 times as fast.
 if ( (millis()-startTime)>debounceTime ) {
 scanKeys();
 keyActivity = updateList();
 startTime = millis();
 }

 return keyActivity;
}

// Private : Hardware scan
void Keypad::scanKeys() {
 // Re-intialize the row pins. Allows sharing these pins with other hardware.
 for (byte r=0; r<sizeKpd.rows; r++) {
 pin_mode(rowPins[r],INPUT_PULLUP);
 }

 // bitMap stores ALL the keys that are being pressed.
 for (byte c=0; c<sizeKpd.columns; c++) {
 pin_mode(columnPins[c],OUTPUT);
 pin_write(columnPins[c], LOW); // Begin column pulse output.
 for (byte r=0; r<sizeKpd.rows; r++) {
 bitWrite(bitMap[r], c, !pin_read(rowPins[r]));  // keypress is active low so invert to high.
 }
 // Set pin to high impedance input. Effectively ends column pulse.
 pin_write(columnPins[c],HIGH);
 pin_mode(columnPins[c],INPUT);
 }
}

// Manage the list without rearranging the keys. Returns true if any keys on the list changed state.
bool Keypad::updateList() {

 bool anyActivity = false;

 // Delete any IDLE keys
 for (byte i=0; i<LIST_MAX; i++) {
 if (key[i].kstate==IDLE) {
 key[i].kchar = NO_KEY;
 key[i].kcode = -1;
 key[i].stateChanged = false;
 }
 }

 // Add new keys to empty slots in the key list.
 for (byte r=0; r<sizeKpd.rows; r++) {
 for (byte c=0; c<sizeKpd.columns; c++) {
 boolean button = bitRead(bitMap[r],c);
 char keyChar = keymap[r * sizeKpd.columns + c];
 int keyCode = r * sizeKpd.columns + c;
 int idx = findInList (keyCode);
 // Key is already on the list so set its next state.
 if (idx > -1) {
 nextKeyState(idx, button);
 }
 // Key is NOT on the list so add it.
 if ((idx == -1) && button) {
 for (byte i=0; i<LIST_MAX; i++) {
 if (key[i].kchar==NO_KEY) { // Find an empty slot or don't add key to list.
 key[i].kchar = keyChar;
 key[i].kcode = keyCode;
 key[i].kstate = IDLE; // Keys NOT on the list have an initial state of IDLE.
 nextKeyState (i, button);
 break; // Don't fill all the empty slots with the same key.
 }
 }
 }
 }
 }

 // Report if the user changed the state of any key.
 for (byte i=0; i<LIST_MAX; i++) {
 if (key[i].stateChanged) anyActivity = true;
 }

 return anyActivity;
}

// Private
// This function is a state machine but is also used for debouncing the keys.
void Keypad::nextKeyState(byte idx, boolean button) {
 key[idx].stateChanged = false;

 switch (key[idx].kstate) {
 case IDLE:
 if (button==CLOSED) {
 transitionTo (idx, PRESSED);
 holdTimer = millis(); } // Get ready for next HOLD state.
 break;
 case PRESSED:
 if ((millis()-holdTimer)>holdTime) // Waiting for a key HOLD...
 transitionTo (idx, HOLD);
 else if (button==OPEN) // or for a key to be RELEASED.
 transitionTo (idx, RELEASED);
 break;
 case HOLD:
 if (button==OPEN)
 transitionTo (idx, RELEASED);
 break;
 case RELEASED:
 transitionTo (idx, IDLE);
 break;
 }
}

// New in 2.1
bool Keypad::isPressed(char keyChar) {
 for (byte i=0; i<LIST_MAX; i++) {
 if ( key[i].kchar == keyChar ) {
 if ( (key[i].kstate == PRESSED) && key[i].stateChanged )
 return true;
 }
 }
 return false; // Not pressed.
}

// Search by character for a key in the list of active keys.
// Returns -1 if not found or the index into the list of active keys.
int Keypad::findInList (char keyChar) {
 for (byte i=0; i<LIST_MAX; i++) {
 if (key[i].kchar == keyChar) {
 return i;
 }
 }
 return -1;
}

// Search by code for a key in the list of active keys.
// Returns -1 if not found or the index into the list of active keys.
int Keypad::findInList (int keyCode) {
 for (byte i=0; i<LIST_MAX; i++) {
 if (key[i].kcode == keyCode) {
 return i;
 }
 }
 return -1;
}

// New in 2.0
char Keypad::waitForKey() {
 char waitKey = NO_KEY;
 while( (waitKey = getKey()) == NO_KEY ); // Block everything while waiting for a keypress.
 return waitKey;
}

// Backwards compatibility function.
KeyState Keypad::getState() {
 return key[0].kstate;
}

// The end user can test for any changes in state before deciding
// if any variables, etc. needs to be updated in their code.
bool Keypad::keyStateChanged() {
 return key[0].stateChanged;
}

// The number of keys on the key list, key[LIST_MAX], equals the number
// of bytes in the key list divided by the number of bytes in a Key object.
byte Keypad::numKeys() {
 return sizeof(key)/sizeof(Key);
}

// Minimum debounceTime is 1 mS. Any lower *will* slow down the loop().
void Keypad::setDebounceTime(uint debounce) {
 debounce<1 ? debounceTime=1 : debounceTime=debounce;
}

void Keypad::setHoldTime(uint hold) {
    holdTime = hold;
}

void Keypad::addEventListener(void (*listener)(char)){
 keypadEventListener = listener;
}

void Keypad::transitionTo(byte idx, KeyState nextState) {
 key[idx].kstate = nextState;
 key[idx].stateChanged = true;

 // Sketch used the getKey() function.
 // Calls keypadEventListener only when the first key in slot 0 changes state.
 if (single_key)  {
   if ( (keypadEventListener!=NULL) && (idx==0) )  {
 keypadEventListener(key[0].kchar);
 }
 }
 // Sketch used the getKeys() function.
 // Calls keypadEventListener on any key that changes state.
 else {
   if (keypadEventListener!=NULL)  {
 keypadEventListener(key[idx].kchar);
 }
 }
}

Keypad.h

#ifndef KEYPAD_H
#define KEYPAD_H

#include "utility/Key.h"

// Arduino versioning.
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

// bperrybap - Thanks for a well reasoned argument and the following macro(s).
// See http://arduino.cc/forum/index.php/topic,142041.msg1069480.html#msg1069480
#ifndef INPUT_PULLUP
#warning "Using  pinMode() INPUT_PULLUP AVR emulation"
#define INPUT_PULLUP 0x2
#define pinMode(_pin, _mode) _mypinMode(_pin, _mode)
#define _mypinMode(_pin, _mode)  \
do { \
 if(_mode == INPUT_PULLUP) \
 pinMode(_pin, INPUT); \
 digitalWrite(_pin, 1); \
 if(_mode != INPUT_PULLUP) \
 pinMode(_pin, _mode); \
}while(0)
#endif


#define OPEN LOW
#define CLOSED HIGH

typedef char KeypadEvent;
typedef unsigned int uint;
typedef unsigned long ulong;

// Made changes according to this post http://arduino.cc/forum/index.php?topic=58337.0
// by Nick Gammon. Thanks for the input Nick. It actually saved 78 bytes for me. :)
typedef struct {
    byte rows;
    byte columns;
} KeypadSize;

#define LIST_MAX 10 // Max number of keys on the active list.
#define MAPSIZE 10 // MAPSIZE is the number of rows (times 16 columns)
#define makeKeymap(x) ((char*)x)


//class Keypad : public Key, public HAL_obj {
class Keypad : public Key {
public:

 Keypad(char *userKeymap, byte *row, byte *col, byte numRows, byte numCols);

 virtual void pin_mode(byte pinNum, byte mode) { pinMode(pinNum, mode); }
 virtual void pin_write(byte pinNum, boolean level) { digitalWrite(pinNum, level); }
 virtual int  pin_read(byte pinNum) { return digitalRead(pinNum); }

 uint bitMap[MAPSIZE]; // 10 row x 16 column array of bits. Except Due which has 32 columns.
 Key key[LIST_MAX];
 unsigned long holdTimer;

 char getKey();
 bool getKeys();
 KeyState getState();
 void begin(char *userKeymap);
 bool isPressed(char keyChar);
 void setDebounceTime(uint);
 void setHoldTime(uint);
 void addEventListener(void (*listener)(char));
 int findInList(char keyChar);
 int findInList(int keyCode);
 char waitForKey();
 bool keyStateChanged();
 byte numKeys();

private:
 unsigned long startTime;
 char *keymap;
    byte *rowPins;
    byte *columnPins;
 KeypadSize sizeKpd;
 uint debounceTime;
 uint holdTime;
 bool single_key;

 void scanKeys();
 bool updateList();
 void nextKeyState(byte n, boolean button);
 void transitionTo(byte n, KeyState nextState);
 void (*keypadEventListener)(char);
};

#endif

Oui, mais je parlais en fait de ton code à toi...

ah d’accord

#include <Wire.h>
#include <DS3231.h>
#include <LiquidCrystal.h>
#include <Keypad.h>

DS3231 clock;
RTCDateTime dt;

int tempPin = 0;
//                BS  E  D4 D5  D6 D7
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 30;       
 
//the time when the sensor outputs a low impulse
long unsigned int lowIn;        
 
//the amount of milliseconds the sensor has to be low
//before we assume all motion has stopped

 
int pirPin = 3;    //the digital pin connected to the PIR sensor's output


const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
//define the cymbols on the buttons of the keypads
char hexaKeys[ROWS][COLS] = {
  {'1','2','3'}
};

byte rowPins[ROWS] = {13}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {5, 4, 2 }; //connect to the column pinouts of the keypad

char* ourCode = "321";
int currentPosition = 0;

//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 

//variables globales
void(* reboot) (void) = 0;

int tonePin = 6;

void setup()
{
  
  lcd.begin(16, 2);
  clock.begin();

  // Send sketch compiling time to Arduino
  clock.setDateTime(__DATE__, __TIME__);
  heure();
  delay(2000);
  lcd.clear();
  comptearebours();
  lcd.clear();
  

  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  digitalWrite(pirPin, LOW);
 
  //give the sensor some time to calibrate
  Serial.print("calibrating3 sensor ");
    for(int i = 0; i < calibrationTime; i++){
      Serial.print(".");
      }
    Serial.println(" done");
    Serial.println("SENSOR ACTIVE");
    Serial.println("Initialize DS1307");

}
void loop()
{
  
  heure();
  if(digitalRead(pirPin) == HIGH){
   temperature();
   lcd.clear();}        
    
   if(digitalRead(pirPin) == LOW){
       
      
     clavier();
   }
}
     

void temperature()
{
  int tempReading = analogRead(tempPin);
  // This is OK
  double tempK = log(10000.0 * ((1024.0 / tempReading - 1)));
  tempK = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * tempK * tempK )) * tempK );       //  Temp Kelvin
  float tempC = tempK - 273.15;            // Convert Kelvin to Celcius
  float tempF = (tempC * 9.0)/ 5.0 + 32.0; // Convert Celcius to Fahrenheit
 
  // Display Temperature in C
  lcd.setCursor(0, 1);
  lcd.print("Temp         C  ");
  
  lcd.setCursor(6, 1);
  // Display Temperature in C
  lcd.print(tempC);
  
  delay(500);
}

void heure()
{
   
   dt = clock.getDateTime();

  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  
  // print the number of seconds since reset:
  //lcd.print(millis()/1000);
 
 
  lcd.setCursor(0, 0);
  lcd.print(dt.hour);   lcd.print(":");
  lcd.print(dt.minute); lcd.print(":");
  lcd.print(dt.second);
  
  
}

void comptearebours()
{

  for (byte digit = 12; digit > 0; --digit) 
  {
    delay(1000);
    lcd.setCursor(0,2);
    lcd.print(digit-2); 
    
    if (digit == 1)
      {
        
        // lancer la musique
        lcd.clear();
        lcd.print("Musique!!"); 
       midi();
      }
      
  }
}

void clavier()
{
char key = customKeypad.getKey();
Serial.print(key); 
  if (int(key) != 0) {
    
    if (key == ourCode[currentPosition])
      {
        ++currentPosition;
        if (currentPosition == 3)
        {
          unlockDoor();
          currentPosition = 0;
        }
      } else {
        invalidCode();
        currentPosition = 0;
      }
  }
}

void invalidCode()
{
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("CODE REFUSE");
  delay(5000);
}

void unlockDoor()
{
  lcd.clear();
  lcd.setCursor(0,1);
  lcd.print("CODE BON");
  delay(5000);
  heure();
  delay(5000);
  reboot();

}

void midi() {

    tone(tonePin, 523, 877.1925);
    delay(974.658333333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 877.1925);
    delay(974.658333333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 877.1925);
    delay(974.658333333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 880, 219.298125);
    delay(243.664583333);
    tone(tonePin, 783, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 587, 1754.385);
    delay(1949.31666667);
    delay(243.664583333);
    tone(tonePin, 523, 877.1925);
    delay(974.658333333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 877.1925);
    delay(974.658333333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 877.1925);
    delay(974.658333333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 880, 219.298125);
    delay(243.664583333);
    tone(tonePin, 783, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 587, 1754.385);
    delay(1949.31666667);
    delay(243.664583333);
    tone(tonePin, 587, 877.1925);
    delay(974.658333333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 440, 219.298125);
    delay(243.664583333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 440, 219.298125);
    delay(243.664583333);
    tone(tonePin, 587, 877.1925);
    delay(974.658333333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 440, 219.298125);
    delay(243.664583333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 877.1925);
    delay(974.658333333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 739, 219.298125);
    delay(243.664583333);
    tone(tonePin, 783, 219.298125);
    delay(243.664583333);
    tone(tonePin, 880, 219.298125);
    delay(243.664583333);
    tone(tonePin, 783, 1754.385);
    delay(1949.31666667);
    delay(243.664583333);
    tone(tonePin, 587, 877.1925);
    delay(974.658333333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 440, 219.298125);
    delay(243.664583333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 440, 219.298125);
    delay(243.664583333);
    tone(tonePin, 587, 877.1925);
    delay(974.658333333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 440, 219.298125);
    delay(243.664583333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 391, 219.298125);
    delay(243.664583333);
    tone(tonePin, 523, 877.1925);
    delay(974.658333333);
    tone(tonePin, 587, 219.298125);
    delay(243.664583333);
    tone(tonePin, 659, 219.298125);
    delay(243.664583333);
    tone(tonePin, 739, 219.298125);
    delay(243.664583333);
    tone(tonePin, 783, 219.298125);
    delay(243.664583333);
    tone(tonePin, 880, 219.298125);
    delay(243.664583333);
    tone(tonePin, 783, 1754.385);
    delay(1949.31666667);
}

Ici, c'est le code de mon projet, donc en gros je veux taper une heure qui se soustrait avec l'heure actuelle pour qu'ensuite ca declenche mon compte a rebours avec la difference entre heure taper et heure actuelle

donc je tape 12h00 et il est 11h

ca doit me declencher un compte a rebours d'une 1h

merci