Domotique et électronique : Arduino, action locale/distante

Bonjour à tous !

Dans les différentes démonstrations effectuées jusqu’à maintenant, nous avons commandé les sorties (GPIO) de l’Arduino uniquement à distance, c'est à dire depuis l’ordinateur.

Je vous propose d’ajouter une commande locale implantée directement sur l’Arduino, matérialisée par des boutons-poussoirs.

Domotique et électronique : Arduino, action locale/distante Bouton10

Ainsi, dans le cas d’une LED, il sera possible de l’allumer ou de l’éteindre aussi bien depuis l’ordinateur que depuis un bouton connecté à l’Arduino.

Du point de vue logiciel, un retour d’information depuis l’Arduino sera reçu et traité par le programme Panoramic pour mettre à jour l’affichage de l’écran du PC.

Cette démonstration s’appuie sur la commande de 6 LEDs connectées à l’Arduino UNO.

Domotique et électronique : Arduino, action locale/distante Arduin18

Le matériel :

- 1 x Arduino UNO ;
- 6 x LEDs ;
- 6 x résistances de 330 ohms ;
- 6 x interrupteurs-poussoirs ;
- 1 x platine de prototypage (Breadboard) ;
- Fil de câblage ;
- Câble USB (entre l’Arduino et l’ordinateur).

Le câblage :

Les LEDs, en série avec une résistance de 330 ohms, sont connectées aux pins 2, 3, 4, 5, 6 et 7 de l’Arduino d’un côté et à la broche GND de l’autre côté.

Domotique et électronique : Arduino, action locale/distante Arduin10

Les boutons-poussoirs sont reliés entre les pins 8, 9, 10, 11, 12 et 13 et la broche GND.

Domotique et électronique : Arduino, action locale/distante Arduin12

Photo en haute définition du câblage à effectuer :

Spoiler:

Le protocole de communication :

Le dialogue série entre Panoramic et l’Arduino consistera par l’envoi et la réception d’un simple octet (byte).
Dans le code-source Panoramic, cet octet porte le nom de « portD% ».
Dans le code-source Arduino, je l’ai appelé « Panoramic ». Vous pourrez ainsi le retrouver facilement.

Chaque bit de l’octet transmis représente l’état d’une LED : 1 = allumée, 0 = éteinte.

Domotique et électronique : Arduino, action locale/distante Arduin11

Pour lire ou modifier l’état d’un bit, on utilise les opérateurs logiques AND et OR. La syntaxe en langage Panoramic est BIN_AND(a,b) et BIN_OR(a,b).

Je n’entre pas plus dans le détail, mais si vous avez des questions, n’hésitez pas à les poser !

Pour ceux qui souhaitent s’exercer avec ces opérateurs logiques, j’ai publié un petit utilitaire ici :
https://panoramic.1fr1.net/t6723-and-or-xor-calculatrice-8-bits

Le code-source Arduino :

Ce code est à téléverser dans l’Arduino UNO :

Code:: /* Déclaration des variables */
const int pin_bouton1 = 8; // création d'une constante pin_bouton1 (connecté à la pin
const int pin_bouton2 = 9; // création d'une constante pin_bouton2 (connecté à la pin 9)
const int pin_bouton3 = 10; // création d'une constante pin_bouton3 (connecté à la pin 10)
const int pin_bouton4 = 11; // création d'une constante pin_bouton4 (connecté à la pin 11)
const int pin_bouton5 = 12; // création d'une constante pin_bouton5 (connecté à la pin 12)
const int pin_bouton6 = 13; // création d'une constante pin_bouton6 (connecté à la pin 13)

const int pin_led1 = 2; // création d'une constante pin_led1 (connectée à la pin 2)
const int pin_led2 = 3; // création d'une constante pin_led2 (connectée à la pin 3)
const int pin_led3 = 4; // création d'une constante pin_led3 (connectée à la pin 4)
const int pin_led4 = 5; // création d'une constante pin_led4 (connectée à la pin 5)
const int pin_led5 = 6; // création d'une constante pin_led5 (connectée à la pin 6)
const int pin_led6 = 7; // création d'une constante pin_led6 (connectée à la pin 7)

bool etat_led1 {0}; // création d'une variable pour l'état de la led 1 (0 pour éteinte, 1 pour allumée)
bool etat_led2 {0}; // création d'une variable pour l'état de la led 2 (0 pour éteinte, 1 pour allumée)
bool etat_led3 {0}; // création d'une variable pour l'état de la led 3 (0 pour éteinte, 1 pour allumée)
bool etat_led4 {0}; // création d'une variable pour l'état de la led 4 (0 pour éteinte, 1 pour allumée)
bool etat_led5 {0}; // création d'une variable pour l'état de la led 5 (0 pour éteinte, 1 pour allumée)
bool etat_led6 {0}; // création d'une variable pour l'état de la led 6 (0 pour éteinte, 1 pour allumée)

bool etat_bouton1 {true}; // création d'une variable pour l'état du bouton 1
bool etat_bouton2 {true}; // création d'une variable pour l'état du bouton 2
bool etat_bouton3 {true}; // création d'une variable pour l'état du bouton 3
bool etat_bouton4 {true}; // création d'une variable pour l'état du bouton 4
bool etat_bouton5 {true}; // création d'une variable pour l'état du bouton 5
bool etat_bouton6 {true}; // création d'une variable pour l'état du bouton 6

/* Fonction d'initialisation de la carte arduino */
void setup()
{
  pinMode(pin_bouton1,INPUT_PULLUP); // La broche 8, qui est reliée au bouton1, est configurée en "entrée" avec résisance de pullup
  pinMode(pin_bouton2,INPUT_PULLUP); // La broche 9, qui est reliée au bouton2, est configurée en "entrée" avec résisance de pullup
  pinMode(pin_bouton3,INPUT_PULLUP); // La broche 10, qui est reliée au bouton3, est configurée en "entrée" avec résisance de pullup
  pinMode(pin_bouton4,INPUT_PULLUP); // La broche 11, qui est reliée au bouton4, est configurée en "entrée" avec résisance de pullup
  pinMode(pin_bouton5,INPUT_PULLUP); // La broche 12, qui est reliée au bouton5, est configurée en "entrée" avec résisance de pullup
  pinMode(pin_bouton6,INPUT_PULLUP); // La broche 13, qui est reliée au bouton6, est configurée en "entrée" avec résisance de pullup

  pinMode(pin_led1, OUTPUT); // La broche 2, qui est reliée à la LED1, est configurée en "sortie"
  pinMode(pin_led2, OUTPUT); // La broche 3, qui est reliée à la LED2, est configurée en "sortie"
  pinMode(pin_led3, OUTPUT); // La broche 4, qui est reliée à la LED3, est configurée en "sortie"
  pinMode(pin_led4, OUTPUT); // La broche 5, qui est reliée à la LED4, est configurée en "sortie"
  pinMode(pin_led5, OUTPUT); // La broche 6, qui est reliée à la LED5, est configurée en "sortie"
  pinMode(pin_led6, OUTPUT); // La broche 7, qui est reliée à la LED6, est configurée en "sortie"

  Serial.begin(9600); // Initialisation du port série avec sa vitesse en bauds
  Serial.setTimeout(50); // Initialisation de la vitesse de rafraichissement du port série, en millisecondes
}

/* fonction exécutée en boucle par la carte arduino */
void loop()
{
  lectureBouton();
  lecturePortSerie();
}

//---------------------------------------------------------
void lectureBouton()
{
  // bouton 1
  if (etat_bouton1 && (digitalRead(pin_bouton1) == LOW))
  {
   etat_bouton1 = false;
   etat_led1 = !etat_led1;
   digitalWrite(pin_led1,etat_led1);
   Serial.write(PIND);
   delay(20);
  }
  if (!etat_bouton1 && (digitalRead(pin_bouton1) == HIGH))
  {
   etat_bouton1 = true;
   delay(20);
  }

  // bouton 2
  if (etat_bouton2 && (digitalRead(pin_bouton2) == LOW))
  {
   etat_bouton2 = false;
   etat_led2 = !etat_led2;
   digitalWrite(pin_led2,etat_led2);
   Serial.write(PIND);
   delay(20);
  }
  if (!etat_bouton2 && (digitalRead(pin_bouton2) == HIGH))
  {
   etat_bouton2 = true;
   delay(20);
  }

  // bouton 3
  if (etat_bouton3 && (digitalRead(pin_bouton3) == LOW))
  {
   etat_bouton3 = false;
   etat_led3 = !etat_led3;
   digitalWrite(pin_led3,etat_led3);
   Serial.write(PIND);
   delay(20);
  }
  if (!etat_bouton3 && (digitalRead(pin_bouton3) == HIGH))
  {
   etat_bouton3 = true;
   delay(20);
  }

  // bouton 4
  if (etat_bouton4 && (digitalRead(pin_bouton4) == LOW))
  {
   etat_bouton4 = false;
   etat_led4 = !etat_led4;
   digitalWrite(pin_led4,etat_led4);
   Serial.write(PIND);
   delay(20);
  }
  if (!etat_bouton4 && (digitalRead(pin_bouton4) == HIGH))
  {
   etat_bouton4 = true;
   delay(20);
  }

  // bouton 5
  if (etat_bouton5 && (digitalRead(pin_bouton5) == LOW))
  {
   etat_bouton5 = false;
   etat_led5 = !etat_led5;
   digitalWrite(pin_led5,etat_led5);
   Serial.write(PIND);
   delay(20);
  }
  if (!etat_bouton5 && (digitalRead(pin_bouton5) == HIGH))
  {
   etat_bouton5 = true;
   delay(20);
  }

  // bouton 6
  if (etat_bouton6 && (digitalRead(pin_bouton6) == LOW))
  {
   etat_bouton6 = false;
   etat_led6 = !etat_led6;
   digitalWrite(pin_led6,etat_led6);
   Serial.write(PIND);
   delay(20);
  }
  if (!etat_bouton6 && (digitalRead(pin_bouton6) == HIGH))
  {
   etat_bouton6 = true;
   delay(20);
  }
}

//---------------------------------------------------------
void lecturePortSerie()
{
  if (Serial.available()>0)
  {
   byte Panoramic = Serial.read();
   PORTD = Panoramic;
   if (Panoramic&4)
   {
   etat_led1 = HIGH;
   }
   else
   {
   etat_led1 = LOW;
   }
   if (Panoramic&8)
   {
   etat_led2 = HIGH;
   }
   else
   {
   etat_led2 = LOW;
   }
   if (Panoramic&16)
   {
   etat_led3 = HIGH;
   }
   else
   {
   etat_led3 = LOW;
   }
   if (Panoramic&32)
   {
   etat_led4 = HIGH;
   }
   else
   {
   etat_led4 = LOW;
   }
   if (Panoramic&64)
   {
   etat_led5 = HIGH;
   }
   else
   {
   etat_led5 = LOW;
   }
   if (Panoramic&128)
   {
   etat_led6 = HIGH;
   }
   else
   {
   etat_led6 = LOW;
   }
  }
}

Le code-source Panoramic :

Code:: ' Panoramic => Arduino UNO
' Logiciel de démonstration
' Commandes locale et distante de 6 LEDs
' Marc - Février 2022
' Ecrit en langage Panoramic

dim portCom%, recept$, i%, portD%

label onOffSerial, choixPortCom, actionLed, redim0, serialReceive, quitter

dessinerInterfaceUtilisateur()

end

sub dessinerInterfaceUtilisateur()
   width 0,width(0) - width_client(0) + 590
   height 0,height(0) - height_client(0) + 180
   left 0,(screen_x - width(0)) / 2
   top 0,(screen_y - height(0)) / 2
   on_resize 0,redim0
   on_close 0,quitter
   caption 0,"PANORAMIC --> Arduino UNO Démonstration : Commande distante et locale de 6 LEDs"
   creerModuleSerial()
   creerModuleInterfaceGpio()
end_sub

sub creerModuleSerial()
   dim_local n%

   command_target_is 0

   container 1
   width 1,100
   height 1,150
   left 1,15
   top 1,15
   caption 1,"Serial"

   command_target_is 1

   combo 2
   parent 2,1
   width 2,70
   top 2,30
   left 2,15
   for n% = 1 to 255
   item_add 2,"COM" + str$(n%)
   next n%
   on_change 2,choixPortCom

   switch1 3
   parent 3,1
   width 3,50
   top 3,70
   left 3,25
   caption 3,"Off|On"
   on_click 3,onOffSerial
   inactive 3
end_sub

sub creerModuleInterfaceGpio()
   dim_local n%,e%,numeroGpio%
   command_target_is 0

   container 10
   width 10,445
   height 10,150
   top 10,15
   left 10,130
   caption 10,"GPIO"

   ' dessiner les interrupteurs de commande des GPIO
   numeroGpio% = 2
   e% = 23

   for n% = 12 to 17
   switch1 n%
   parent n%,10
   width n%,50
   top n%,70
   left n%,e%
   caption n%,str$(numeroGpio%)+": Off|"+str$(numeroGpio%)+": On"
   on_click n%, actionLed
   inactive n%
   e% = e% + 70
   numeroGpio% = numeroGpio% + 1
   next n%

   ' dessiner LEDs au dessus des interrupteurs de commande GPIO
   e% = 36
   for n% = 42 to 47
   led1 n%
   parent n%,10
   top n%,28
   left n%,e%
   color n%,127,127,127
   e% = e% + 70
   next n%
end_sub

choixPortCom:
   portCom% = item_index(2)
   if serial_port_exists(portCom%) = 0
   if message_warning_ok("COM"+str$(portCom%) + " : Liaison série inexistante !") < 2
   inactive 3 :' interrupteur on/off Serial
   return
   end_if
   end_if
   active 3 :' interrupteur on/off Serial
return

onOffSerial:
   if checked(3) = 0
   inactive 2
   initialisationLiaisonSerie()
   serial_open 60
   on_receive 60,serialReceive
   for i% = 12 to 17
   active i%
   next i%
   else
   if object_exists(60) = 1
   serial_close 60
   active 2
   for i% = 12 to 17
   inactive i%
   next i%
   end_if
   end_if
return

sub initialisationLiaisonSerie()
   if object_exists(60) = 0
   serial 60
   end_if
   serial_port 60,portCom%
   serial_baudrate 60,9600
   serial_databits 60,8
   serial_parity 60,0
   serial_stopbits 60,1
end_sub

actionLed:
   select number_click
   case 12 :' LED 1
   if checked(12) = 0
   color 42,0,255,0
   portd% = bin_or(portd%,4)
   else
   color 42,127,127,127
   portd% = bin_and(portd%,251)
   end_if

   case 13 :' LED 2
   if checked(13) = 0
   color 43,0,255,0
   portd% = bin_or(portd%,8)
   else
   color 43,127,127,127
   portd% = bin_and(portd%,247)
   end_if

   case 14 :' LED 3
   if checked(14) = 0
   color 44,0,255,0
   portd% = bin_or(portd%,16)
   else
   color 44,127,127,127
   portd% = bin_and(portd%,239)
   end_if

   case 15 :' LED 4
   if checked(15) = 0
   color 45,0,255,0
   portd% = bin_or(portd%,32)
   else
   color 45,127,127,127
   portd% = bin_and(portd%,223)
   end_if

   case 16 :' LED 5
   if checked(16) = 0
   color 46,0,255,0
   portd% = bin_or(portd%,64)
   else
   color 46,127,127,127
   portd% = bin_and(portd%,191)
   end_if

   case 17 :' LED 6
   if checked(17) = 0
   color 47,0,255,0
   portd% = bin_or(portd%,128)
   else
   color 47,127,127,127
   portd% = bin_and(portd%,127)
   end_if
   end_select

   serial_write 60,chr$(portD%)
return

serialReceive:
   recept$ = serial_read$(60)
   portD% = asc(recept$)

   if bin_and(portD%,4) = 4 :' LED n° 1
   mark_off 12
   color 42,0,255,0
   else
   mark_on 12
   color 42,127,127,127
   end_if

   if bin_and(portD%,8) = 8 :' LED n° 2
   mark_off 13
   color 43,0,255,0
   else
   mark_on 13
   color 43,127,127,127
   end_if

   if bin_and(portD%,16) = 16 :' LED n° 3
   mark_off 14
   color 44,0,255,0
   else
   mark_on 14
   color 44,127,127,127
   end_if

   if bin_and(portD%,32) = 32 :' LED n° 4
   mark_off 15
   color 45,0,255,0
   else
   mark_on 15
   color 45,127,127,127
   end_if

   if bin_and(portD%,64) = 64 :' LED n° 5
   mark_off 16
   color 46,0,255,0
   else
   mark_on 16
   color 46,127,127,127
   end_if

   if bin_and(portD%,128) = 128 :' LED n° 6
   mark_off 17
   color 47,0,255,0
   else
   mark_on 17
   color 47,127,127,127
   end_if
return

redim0:
   width 0,width(0) - width_client(0) + 590
   height 0,height(0) - height_client(0) + 180
return

quitter:
   if object_exists(60) = 1
   serial_close 60
   end_if
return

Domotique et électronique : Arduino, action locale/distante Arduin20

Utilisation :

Dans la zone « Serial », sélectionnez à l'aide du combo le numéro de port COM affecté à l’Arduino. Cliquez sur l’interrupteur pour ouvrir la communication série.

Maintenant, vous pouvez allumer ou éteindre n’importe quelle LED depuis Panoramic et/ou depuis l’Arduino.

Une action sur un bouton-poussoir de l’Arduino enverra instantanément un message à Panoramic pour l’informer de l’allumage ou de l’extinction d’une LED. A l’écran, l’interrupteur concerné basculera dans la position adéquate.

Pour finir, voici une petite vidéo où vous pouvez visualiser l’interaction entre les commandes sur l’Arduino et la mise à jour de la position des interrupteurs dans l’application Panoramic.

A bientôt !

Merci Marc. Tes explications sont toujours au top ! Wink

» Domotique et électronique : Panoramic et l’Arduino DUE.
» Domotique et électronique : deux SUBs pour Arduino NANO/UNO
» Domotique et électronique : deux SUBs pour Arduino MEGA 2560
» Domotique et électronique : 2 LEDs et 2 servomoteurs
» Domotique avec Panoramic : les cartes Arduino