Version du 4 avril 2017 à 09:46 (voir la source) Hdelbrou (discussion | contributions) (→‎Partie électronique) ← Modification précédente		Version actuelle datée du 18 juin 2017 à 22:30 (voir la source) Tcattela (discussion | contributions) (→‎Séances supplémentaires)
(4 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 284 :		Ligne 284 :
	=== Partie informatique ===		=== Partie informatique ===
−	prise en main CAN sur carte arduino	+	prog de Altium designer et réalisation du comparateur de température
		+	prog CAN sur carte arduino
−	== Séance supplémentaire 1 ==	+	== Séances supplémentaires ==
	=== Partie électronique ===		=== Partie électronique ===
		+
		+	Montage de la maquette avec les différents élements pour la présentation.
	=== Partie informatique ===		=== Partie informatique ===
		+
		+	==== Schéma de fonctionnement ====
		+
		+	Afin de mettre en place le système, le schéma suivi sera le suivant :
		+
		+	1) Requête de la page WEB par l'envoi d'un caractère.
		+
		+	2) Réception du serveur programmé en C, tournant en tâche de fond, traitement et envoi de la requète à l'arduino par la port série.
		+
		+	3) Réception de la requête par l'Arduino, traitement et envoi de la réponse en série.
		+
		+	4) Réception de la réponse de l'Arduino par le programme C.
		+
		+	5) Transmission de la réponse à la page WEB.
		+
		+
		+	==== Sources GIT ====
		+
		+
		+	https://archives.plil.fr/tcattela/2017_TD1_2/tree/master
		+
		+
		+	==== Page WEB ====
		+
		+	La page web va émettre des requêtes pour chacune des données :
		+	-1 pour afficher la valeur du potentiomètre
		+	-2 pour afficher la valeur de capteur de luminosité
		+	-3 pour afficher la valeur de capteur de température
		+	-4 pour afficher l'état des lampes (l'allumage et l'extinction étant gérés par l'Arduino)
		+	-5 pour afficher l'état du chauffage (l'allumage et l'extinction étant gérés par l'Arduino)
		+
		+	Afin de lancer ces requêtes automatiquement, un créé une boucle javascript avec les fonctions :
		+
		+	1) setTimeout qui permet de lancer une fonction après une autre après un certain temps (ici 200ms)
		+
		+	2) setInterval qui permet de lancer une fonction avec un intervalle régulier dès que la page est lancée (ici 1000ms)
		+
		+
		+	function autoSend0(){
		+	websocket.send('0');
		+	setTimeout('autoSend1();', 200);
		+	}
		+	function autoSend1(){
		+	websocket.send('1');
		+	setTimeout('autoSend2();', 200);
		+	}
		+	function autoSend2(){
		+	websocket.send('2');
		+	setTimeout('autoSend3();', 200);
		+	}
		+	function autoSend3(){
		+	websocket.send('3');
		+	setTimeout('autoSend4();', 200);
		+	}
		+	function autoSend4(){
		+	websocket.send('4');
		+	}
		+	setInterval(autoSend0, 1000);
		+
		+
		+
		+	La requête est lancée en websocket grâce à la commande "websocket.send('x')", x étant la caractère à envoyer.
		+
		+	Cette requête sera donc réceptionnée par le serveur tournant en tache de fond, serveur programmé en C.
		+
		+	Une fois tout le traitement effectué, la réponse est alors recue de la forme suivante : xxxxi
		+
		+	i représente le numéro de l'instruction
		+
		+	xxxx représente les données correspondant à l'instruction
		+
		+	De cette manière, on peut grâce à une simple condition if, modifier la variable correspondante, qui sera donc actualisée régulièrement sur la page WEB.
		+
		+
		+	==== Partie Arduino ====
		+
		+	Le programme de l'arduino est divisé en deux grandes parties :
		+
		+	Le fonctionnement de manière autonome, c'est à dire qu'il n'est pas nécessaire que le Raspberry et la page WEB soient lancés, l'Arduino peut exécuter ses fonctions d'allumage et d'extinction de lumière et de chauffage de manière autonome.
		+
		+	On utilise ici le CAN intégré à l'Arduino afin d'acquérir des valeurs de potentiomètre, de luminosité et de température, et de les traiter.
		+
		+	Dans ce programme, lorsque la luminosité est trop faible, une lumière s'allume, et lorsque la température est trop basse le chauffage s'allume :
		+
		+
		+	if (temperature < 27)
		+	{
		+	digitalWrite(led2, HIGH);
		+	ledstate2=1;
		+	}
		+	else
		+	{
		+	digitalWrite(led2, LOW);
		+	ledstate2=0;
		+	}
		+	if (analogRead(A1) < 300)
		+	{
		+	digitalWrite(led1, HIGH);
		+	ledstate1=1;
		+	}
		+	else
		+	{
		+	digitalWrite(led1, LOW);
		+	ledstate1=0;
		+	}
		+
		+
		+	On a pu remarquer que dans la pratique, le capteur de température est relativement instable et imprécis, ce qui engendre un comportement relativement aléatoire.
		+
		+
		+	La partie série, c'est la partie dédiée à la communication de l'Arduino avec une interface série, ici le Raspberry.
		+
		+	Lorsqu'un caractère est reçu, ici un entier correspondant à l'instruction, l'Arduino fait la conversion Analogique-Digitale de la valeur envoyée sur le pin correspondant, et la stocke dans une variable.
		+
		+	Une fois stockée, cette variable sera transmise en série bit par bit, il faut donc que le premier bit transmis soit la longueur de l'entier à transmettre.
		+
		+	Pour cela, on utilise la formule :
		+
		+	n = (log10(sensorValue) + 1)
		+
		+	avec n la longueur de sensorValue.
		+
		+	int sensorValue = analogRead(A0);
		+	int n = (log10(sensorValue) + 1);  // nombre de chiffres composant le nombre
		+	itoa(n, lengh, 10);
		+	itoa(sensorValue, value, 10);
		+	strcat(lengh,value);
		+	Serial.println(lengh);
		+
		+	La valeur finale transmise en série sera donc de la forme nxxxx.
		+
		+
		+	==== Partie serveur ====
		+
		+	Le programme C est celui qui fera la liaison entre les communications série et le WebSocket.
		+
		+	Il va recevoir par le websocket un entier correspondant à l'instruction et le stocker dans l'entier message :
		+
		+	case LWS_CALLBACK_RECEIVE:
		+	printf("received data: %s\n",(char *)in);
		+	message=malloc(len+LWS_SEND_BUFFER_PRE_PADDING+LWS_SEND_BUFFER_POST_PADDING);
		+
		+	Un appel à la fonction serial_read est ensuite fait.
		+
		+	Cette fonction va aller lire bit par bit chaque caractère du message transmis en série. Elle prend en argument l'instruction "rec"
		+
		+	serial_read(&rec)
		+
		+	Un envoi en série de l'instruction est ensuite fait :
		+
		+	if(write(sd,&c,sizeof(char))!=1){ perror("main.write"); exit(-1); }
		+
		+	Une fois l'envoi fait, la lecture des données peur commencer. On commence par lire le nombre de bits que contient le mot :
		+
		+	if(read(sd,&n,sizeof(char))!=1){ perror("main.read"); exit(-1); }
		+	n=n-48;
		+
		+	Cette donnée est donc stockée dans l'entier n, qui nous sert à faire la boucle for suivante :
		+
		+	for (i=0;i<n;i++)
		+	{
		+	if(read(sd,&c,sizeof(char))!=1){ perror("main.read"); exit(-1); }
		+	value=value+(c-48)*pow(10,n-i-1);
		+	}
		+
		+	Cette boucle for permet donc la construction de l'entier reçu en série, ce dernier nécessitant alors d'être converti en str grâce à sprintf, auquel on ajoute en fin de mot l'instruction afin que le serveur web puisse repérer la nature de la donnée.
		+
		+	sprintf (value, "%d", (10*serial_read(&rec))+rec);
		+
		+	Le résultat final est envoyé en websocket.
	== Conclusion ==		== Conclusion ==
		+
		+	La réalisation de ce projet fut relativement plus compliquée que ce à quoi nous nous attendions. En effet, l'utilisation du FPGA nous a forcés à revoir à la baisse nos espérances.
		+
		+	Malgré cela, l'utilisation du websocket ainsi que des bibliothèques série furent une bonne expérience, l'envie d'approfondir et d'améliorer le projet est réelle, mais en raison d'un manque considérable de temps et du départ en stage et à l'étranger des membres du groupe, nous n'avons pas pu aller aussi loin que nous l'aurions voulu.
		+
		+	Ce fut de plus une première pour l'utilisation du javascript, langage relativement intéressant pour l'actualisation automatique des valeurs entre autre.
		+
		+	Le projet s'est révélé très formateur, et serait approfondi/abouti avec joie.

---

Version actuelle datée du 18 juin 2017 à 22:30

Projet IMA3-SC 2016/2017 : Maison connectée

Cahier des charges

Description du système

• L'écologie étant un point clé des futures années, il nous a semblé intéressant d'associer ce thème aux systèmes communicants. Le but est donc de mener à bien le projet d'une maison intelligente et communicante.

• La maison aura donc diverses fonctions gérées par l'utilisateur à distance, tel que l'éclairage, le chauffage, l'état de ses portes, l'état du garage...

• Tout étant géré à la fois via une interface web et une application Android.

• L'application laissera la possibilité de programmer ses routines afin que la maison devienne par définition autonome.

• Les mouvements dans la maison peuvent être détectés et l'application informe l'utilisateur en cas de mouvements imprévus (alerte voleur !)

Liste des fonctions à réaliser

• Mesure de la température (en °C) et de la luminosité (en lux).

• Détection de mouvement pour l'éclairage et les intrusions.

• Communication des informations sur une page web et une application Android.

• Automatisation de la commande de chauffage et d'éclairage.

• Automatisation des entrées et sorties de la maison (porte de garage..)

• Prévision de la consommation

Le matériel

Pour mener à bien ce projet il nous faudra :

• Raspberry PI3

• Carte SD 8GB

• Arduino Nano

• Servo-moteur

• Capteur de luminosité, capteur de température (pour Arduino)

• 5 leds

• module peltier et un radiateur

• Transformateur 230V/12V

• Relais 3.3V

• Capteur PIR (Passive Infra-Rouge)

• Maquette imprimée en 3D au fabricarium (la modélisation étant réalisée par nos soins.)

Séance 1

Durant cette séance, nous avons consacré notre temps principalement aux tests des différents modules qui s'appareillent avec la carte arduino. Cette étape est très crucial pour avoir un aperçu des caractéristiques de chacun des composants.

Partie électronique

• Pour une prise en main rapide et facile, nous avons tout d'abord utilisé des fonctions basiques en alternant sur les états des pins de l'arduino afin d'allumer et d'éteindre des LEDs qui feront office de lumière dans la maison. Les LEDs seront connectées en série avec une résidence pour ne pas dépasser la tension de seuil. (Tension sortie arduino > tension seuil LED)

• En deuxième test, on a utilisé la photorésistance. Une photorésistance est un composant dont la résistivité dépend de la luminosité ambiante. Pour faire simple, c'est une résistance dont la valeur change en fonction de la lumière qu'elle reçoit. On peut donc utiliser une photorésistance pour mesurer la luminosité ambiante. Voici quelques ordres de grandeurs de l'éclairement lumineux en fonction des endroits :

  Nuit de pleine lune : 0,5 lux
  Rue de nuit bien éclairée :20 à 70 lux
  Local de vie : 100 à 200 lux
  Appartement bien éclairé : 200 à 400 lux
  Local de travail : 200 à 3 000 lux
  Stade de nuit : 150 à 1 500 lux
  Extérieur par ciel couvert : 500 à 25 000 lux
  Extérieur en plein soleil : 50 000 à 100 000 lux

Le but de la démonstration était de tout simplement mesurer la luminosité ambiante d'une pièce et d'envoyer la valeur mesurée vers l'ordinateur via le câble USB et de visualisé la valeur sur le moniteur série. Le schéma de montage est le suivant :

La résistance de 10kOhm en série avec la photorésistance forme un pont de résistance (diviseur de tension). Après compilation et test, voici le résultat obtenu :

N.B. : La valeur mesurée n'a pas d'unité ! C'est une valeur purement indicative. Si on veut mesurer une mesure en lux, il aurait fallu calibrer la photorésistance et intégrer les données de calibration dans le code. Savoir calibrer un capteur n'est pas le but de cette demonstration.

• Nous avons également fait les tests de température sur le capteur de thermique 36GZ qui a les caractéristiques suivantes :

  - Tension d'entrée: 2,7 à 5,5 Vcc
  - 10 mV/°C
  - Précision: ±2°C 
  - Linéarité: 0,5°C
  - Plage d'utilisation: -40°C à +125°C 

Le but de ce montage sera de tout simplement mesurer la température ambiante de l'atelier et d'envoyer la température en degré Celsius vers l'ordinateur via le câble USB.

• On utilisera un module Peltier pour jouer le rôle du chauffage. L’effet Peltier est le déplacement de chaleurs en présence d’un courant électrique. L’effet se crée entre deux matériaux conducteurs de différentes natures liés par des jonctions. L’une des jonctions se refroidit pendant que l’autre se chauffe.

Le module Peltier transforme le courant électrique une différence de température. Changer la polarité du Peltier permet de refroidir ou chauffer le bloc métallique sur lequel il sera en contact avec de la graisse thermique pour assurer la transformation de la chaleur maximale. Le module Peltier qu'on utilise peut générer un gradient de température allant jusque 70°C et possède les caractéristiques électriques suivantes : une tension d’entrée maximale de 3,8V et une intensité d’entrée de 8,5A.

• Le dernier test de cette séance a été consacré au servomoteur. Les servomoteurs sont des moteurs un peu particuliers, qui peuvent tourner avec une liberté d'environ 180° et garder de manière relativement précise l'angle de rotation que l'on souhaite obtenir. Les servomoteurs ont pour rôles dans cette maquette d'ouvrir et de fermer le volet et la porte du garage. Il suffit de donner une consigne au servomoteur ("reste à 45°" par exemple) et le servomoteur fera son maximum pour rester au plus près de cette consigne. Voici le schéma de montage du servomoteur avec la carte arduino :

Il est très important et crucial de bien brancher la broche "pulse" du servomoteur sur une pin PWM de la carte (Pulse Width Modulation, pin P9 sur le schéma par exemple). La consigne est transmise au moyen d'un signal numérique, d'une impulsion pour être précis.

Pour que le servomoteur reste à une position donnée, il faut transmettre toutes les 20 millisecondes (soit à une fréquence de 50Hz) une impulsion d'une longueur comprise entre 1 et 2 millisecondes.

Une impulsion de 1 milliseconde correspond à un angle de 0°.

Une impulsion de 2 millisecondes correspond à un angle de 180°.

En envoyant une impulsion d'une longueur intermédiaire, on obtient des angles différents, 90° avec une impulsion de 1.5 milliseconde par exemple.

N.B. La plupart des servomoteurs fonctionnent en 5 volts, mais certains fonctionnent en 3.3 volts. Pensez à bien lire la documentation du servomoteur avant de l'utiliser.

Partie informatique

• Afin d'allumer et d'éteindre les LEDs, il faut tout d'abord initialiser le pin en question en sortie. Pour allumer la LED, on met le pin à l'état haut pour une durée de 5000 cycles qui équivaut à 1 seconde et pour l'éteindre on effectue les mêmes instructions en mettant le pin à l'état bas.

  // the setup function runs once when you press reset or power the board
  void setup() {
    // initialize digital pin LED_BUILTIN as an output.
    pinMode(2, OUTPUT);
  }
  // the loop function runs over and over again forever
  void loop() {
    digitalWrite(2, HIGH);   // turn the LED on (HIGH is the voltage level)
    delay(5000);                       // wait for a second
    digitalWrite(2, LOW);    // turn the LED off by making the voltage LOW
    delay(5000);                       // wait for a second
  }

• Pour le capteur de température, l'arduino reçoit une tension. On multiplie la valeur reçue par la valeur de l'alimentation qui est de 5V. On divise par 1024 cette valeur. 1024 est le nombre d'octet sous lequel est codé la précision du capteur de température.

     //TMP36 Pin Variables
   int sensorPin = 0;         // the analog pin the TMP36's Vout (sense) pin is connected to
                                         // the resolution is 10 mV / degree centigrade with a
                                         // 500 mV offset to allow for negative temperatures
  void loop()                    // run over and over again
  {
   //getting the voltage reading from the temperature sensor
   int reading = analogRead(sensorPin);  
   // converting that reading to voltage, for 3.3v arduino use 3.3
   float voltage = reading * 5.0;
   voltage /= 1024.0; 
   // print out the voltage
   Serial.print(voltage); Serial.println(" volts");
   // now print out the temperature
   float temperatureC = (voltage - 0.5) * 100 ;  //converting from 10 mv per degree wit 500 mV offset
                                                                        //to degrees ((voltage - 500mV) times 100)
   Serial.print(temperatureC); Serial.println(" degrees C");

• Pour la photorésistance, le principe étant de lire l'information qui arrive sur la broche à laquelle est branché le module. Pour cela, une acquisition continue avec un écart de 250ms suffira dans notre cas.

  // Fonction setup(), appelée au démarrage de la carte Arduino
  void setup() {
    // Initialise la communication avec le PC
    Serial.begin(9600);
  }
  // Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
  void loop() {
    // Mesure la tension sur la broche A0
    int valeur = analogRead(A0);
    // Envoi la mesure au PC pour affichage et attends 250ms
    Serial.println(valeur);
    delay(250);
  }

• Le module Peltier fonctionne en continue sans réel consigne c'est à dire qu'il suffira de jouer sur l'état d'un interrupteur pour qu'il chauffe ou pas. Il sera alimenté par une source de tension externe car l'arduino ne répond pas aux besoin nécessaire du module.

• Le dernier module programmé est le servomoteur, la valeur de l'angle est entre 0° et 179°, le résultat sera entre 1 000 et 2 000 microsecondes (donc entre 1 et 2 millisecondes). Grâce à cette formule, on peut obtenir toutes les valeurs d'impulsions pour des positions entre 0° et 179°. Ce programme est un programme test pour comprendre le bon fonctionnement d'un servomoteur.

  int periode=20000;// période entre chaque début d'impulsion en microsecondes
  int pinServo=8; // variable pour le pin connecté à la commande du servo
  void setup() {
    pinMode(pinServo,OUTPUT);// on prépare le pin en mode OUTPUT
    digitalWrite(pinServo,LOW); // on l'initialise à l'état bas
  }
  //boucle principale
  void loop() {
    for (int angle=0;angle<=180;angle+=20){//on fait varier l'angle de 0 à 180° par tranche de 20°
      setAngle(angle);// on appelle la fonction setAngle définie plus bas
    }
  }
  //fonction setAngle pour envoyer les impulsions
  void setAngle(int a){
    int duree=map(a,0,179,1000,2000);// on transforme l'angle en microsecondes et on stocke dans la variable duree
    digitalWrite(pinServo,LOW);//on met le pin à l'état bas
    // la boucle qui suit est nécessaire 
    // pour laisser le temps au servo d'aller à sa position
    for (int t=0;t<300;t++){ 
      digitalWrite(pinServo,HIGH);// on envoie l'impulsion
      delayMicroseconds(duree); // pendant la bonne durée
      digitalWrite(pinServo,LOW); // on stoppe l'impulsion
      delayMicroseconds(periode-duree); // on attend le temps restant pour atteindre la période
    }
  }

• En parallèle avec ce travail de programmation sur arduino, on réalise des plans de la maquette de la maison pour ensuite la faire passer à la découpeuse laser grâce au logiciel inkscap.

Séance 2

Lors de la séance 2, nous avons reçu le capteur PIR, étudié sa datasheet pour pouvoir l'utilisé et le programmer avec la carte arduino. Pendant ce temps là, en parallèle est finalisé le design et la conception de la maquette de la maison connectée.

Partie électronique

• Un capteur infrarouge permet de détecter un mouvement dans son champ de vision en se basant sur l’infrarouge. On parle aussi de capteur pyroélectrique ou PIR. Les PIR sont capable de détecter une variation des ondes infrarouges, ce qui génère un courant électrique. Dans le cas de notre capteur, il est en fait divisé en deux partie différente reliées ensemble afin de détecter une variation lors qu’une des moitiés capte plus qu’une autre. On a ainsi un relevé d’une différence, et non plus d’une valeur simple. Lors d’un mouvement, la variation des deux moitiés vont varier, et on va donc capter cette variation positive.

Les spécifications techniques du capteur PIR HC SR501 sont les suivantes :

  Entrée : Tension continue de 4.5 à 20V , courant 65mA
  Sortie : High 3.3 V / Low 0V (Détection ou non)
  Angle : <100 °
  Dimension : 32 mm * 24 mm
  Délai : de 5 à 200 secondes (ajustable)
  Portée : de 3 à 7 mètres (ajustable).
  Au repos : 50 uA

En ce qui concerne le montage, on s'aide d'une LED pour vérifier l'état et le passage devant le PIR. On branche donc :

Le VCC du PIR sur le 5V de l’arduino Le GRD du PIR sur le GRD de l’arduino La dernière branche sur le pin 2 de l’arduino On ajoute une led de contrôle entre le pin 13 et un GRD de l’arduino

Partie informatique

• Pour la programmation du PIR, il est important de lui laisser au moins 30 secondes pour se calibrer, puis une fois que cela est fait, on va en boucle relever la valeur que nous renvoi le capteur : 0 ou 1. 0 signifiant pas de signal et 1 signifiant qu’il détecte une variation infrarouge. Une LED s'allume pour valider l'état.

  //the time we give the sensor to calibrate (10-60 secs according to the datasheet)
  int calibrationTime = 30;
  int ledPin = 13;                // choose the pin for the LED
  int inputPin = 2;               // choose the input pin (for PIR sensor)
  int pirState = LOW;             // we start, assuming no motion detected
  int val = 0;                    // variable for reading the pin status
  void setup() {
    pinMode(ledPin, OUTPUT);      // declare LED as output
    pinMode(inputPin, INPUT);     // declare sensor as input
    Serial.begin(9600);
    Serial.print("calibrating sensor ");
    for(int i = 0; i < calibrationTime; i++){
      Serial.print(".");
      delay(1000);
    }
  }
  void loop(){
    val = digitalRead(inputPin);  // read input value
    Serial.println(val);
    if (val == HIGH) { // check if the input is HIGH
      digitalWrite(ledPin, HIGH);  // turn LED ON
      delay(150);
      if (pirState == LOW) {
        // we have just turned on
        Serial.println("Motion detected!");
        // We only want to print on the output change, not state
        pirState = HIGH;
      }
    } else {
      digitalWrite(ledPin, LOW); // turn LED OFF
      delay(300);
      if (pirState == HIGH){
        // we have just turned of
        Serial.println("Motion ended!");
        // We only want to print on the output change, not state
        pirState = LOW;
      }
    }
  }

Après avoir compiler et téléverser le programme dans l'arduino, on peut constater dans le moniteur série l'état et le fonctionnement du PIR en directe.

• Le design maquette a été revue en détail durant la séance pour les petites corrections et pouvoir lancer le découpage et ensuite la monter proprement sans soucis de dimensionnement.

Séance 3

Partie électronique

Prise en main de Altium designer et réalisation du comparateur de température prise en main CAN sur carte arduino

Partie informatique

prog de Altium designer et réalisation du comparateur de température prog CAN sur carte arduino

Séances supplémentaires

Partie électronique

Montage de la maquette avec les différents élements pour la présentation.

Partie informatique

Schéma de fonctionnement

Afin de mettre en place le système, le schéma suivi sera le suivant :

1) Requête de la page WEB par l'envoi d'un caractère.

2) Réception du serveur programmé en C, tournant en tâche de fond, traitement et envoi de la requète à l'arduino par la port série.

3) Réception de la requête par l'Arduino, traitement et envoi de la réponse en série.

4) Réception de la réponse de l'Arduino par le programme C.

5) Transmission de la réponse à la page WEB.

Sources GIT

https://archives.plil.fr/tcattela/2017_TD1_2/tree/master

Page WEB

La page web va émettre des requêtes pour chacune des données :

  -1 pour afficher la valeur du potentiomètre
  -2 pour afficher la valeur de capteur de luminosité
  -3 pour afficher la valeur de capteur de température
  -4 pour afficher l'état des lampes (l'allumage et l'extinction étant gérés par l'Arduino)
  -5 pour afficher l'état du chauffage (l'allumage et l'extinction étant gérés par l'Arduino)

Afin de lancer ces requêtes automatiquement, un créé une boucle javascript avec les fonctions :

1) setTimeout qui permet de lancer une fonction après une autre après un certain temps (ici 200ms)

2) setInterval qui permet de lancer une fonction avec un intervalle régulier dès que la page est lancée (ici 1000ms)

  function autoSend0(){
  websocket.send('0');
  setTimeout('autoSend1();', 200);
  }
  function autoSend1(){
  websocket.send('1');
  setTimeout('autoSend2();', 200);
  }
  function autoSend2(){
  websocket.send('2');
  setTimeout('autoSend3();', 200);
  }
  function autoSend3(){
  websocket.send('3');
  setTimeout('autoSend4();', 200);
  }
  function autoSend4(){
  websocket.send('4');
  }
  setInterval(autoSend0, 1000);
  

La requête est lancée en websocket grâce à la commande "websocket.send('x')", x étant la caractère à envoyer.

Cette requête sera donc réceptionnée par le serveur tournant en tache de fond, serveur programmé en C.

Une fois tout le traitement effectué, la réponse est alors recue de la forme suivante : xxxxi

i représente le numéro de l'instruction

xxxx représente les données correspondant à l'instruction

De cette manière, on peut grâce à une simple condition if, modifier la variable correspondante, qui sera donc actualisée régulièrement sur la page WEB.

Partie Arduino

Le programme de l'arduino est divisé en deux grandes parties :

Le fonctionnement de manière autonome, c'est à dire qu'il n'est pas nécessaire que le Raspberry et la page WEB soient lancés, l'Arduino peut exécuter ses fonctions d'allumage et d'extinction de lumière et de chauffage de manière autonome.

On utilise ici le CAN intégré à l'Arduino afin d'acquérir des valeurs de potentiomètre, de luminosité et de température, et de les traiter.

Dans ce programme, lorsque la luminosité est trop faible, une lumière s'allume, et lorsque la température est trop basse le chauffage s'allume :

   if (temperature < 27)
   {
     digitalWrite(led2, HIGH);
     ledstate2=1;
   }
   else 
   {
     digitalWrite(led2, LOW);
     ledstate2=0;
   }
   if (analogRead(A1) < 300)
   {
     digitalWrite(led1, HIGH);
     ledstate1=1;
   }
   else 
   {
     digitalWrite(led1, LOW);
     ledstate1=0;
   }
   

On a pu remarquer que dans la pratique, le capteur de température est relativement instable et imprécis, ce qui engendre un comportement relativement aléatoire.

La partie série, c'est la partie dédiée à la communication de l'Arduino avec une interface série, ici le Raspberry.

Lorsqu'un caractère est reçu, ici un entier correspondant à l'instruction, l'Arduino fait la conversion Analogique-Digitale de la valeur envoyée sur le pin correspondant, et la stocke dans une variable.

Une fois stockée, cette variable sera transmise en série bit par bit, il faut donc que le premier bit transmis soit la longueur de l'entier à transmettre.

Pour cela, on utilise la formule :

   n = (log10(sensorValue) + 1)

avec n la longueur de sensorValue.

   int sensorValue = analogRead(A0);
   int n = (log10(sensorValue) + 1);  // nombre de chiffres composant le nombre
   itoa(n, lengh, 10);
   itoa(sensorValue, value, 10);
   strcat(lengh,value);
   Serial.println(lengh);

La valeur finale transmise en série sera donc de la forme nxxxx.

Partie serveur

Le programme C est celui qui fera la liaison entre les communications série et le WebSocket.

Il va recevoir par le websocket un entier correspondant à l'instruction et le stocker dans l'entier message :

  case LWS_CALLBACK_RECEIVE:
     printf("received data: %s\n",(char *)in);
     message=malloc(len+LWS_SEND_BUFFER_PRE_PADDING+LWS_SEND_BUFFER_POST_PADDING);
   	

Un appel à la fonction serial_read est ensuite fait.

Cette fonction va aller lire bit par bit chaque caractère du message transmis en série. Elle prend en argument l'instruction "rec"

  serial_read(&rec)

Un envoi en série de l'instruction est ensuite fait :

  if(write(sd,&c,sizeof(char))!=1){ perror("main.write"); exit(-1); }

Une fois l'envoi fait, la lecture des données peur commencer. On commence par lire le nombre de bits que contient le mot :

  if(read(sd,&n,sizeof(char))!=1){ perror("main.read"); exit(-1); }
  n=n-48;

Cette donnée est donc stockée dans l'entier n, qui nous sert à faire la boucle for suivante :

  for (i=0;i<n;i++)
  {
     if(read(sd,&c,sizeof(char))!=1){ perror("main.read"); exit(-1); }
     value=value+(c-48)*pow(10,n-i-1);
  }

Cette boucle for permet donc la construction de l'entier reçu en série, ce dernier nécessitant alors d'être converti en str grâce à sprintf, auquel on ajoute en fin de mot l'instruction afin que le serveur web puisse repérer la nature de la donnée.

  sprintf (value, "%d", (10*serial_read(&rec))+rec);

Le résultat final est envoyé en websocket.

Conclusion

La réalisation de ce projet fut relativement plus compliquée que ce à quoi nous nous attendions. En effet, l'utilisation du FPGA nous a forcés à revoir à la baisse nos espérances.

Malgré cela, l'utilisation du websocket ainsi que des bibliothèques série furent une bonne expérience, l'envie d'approfondir et d'améliorer le projet est réelle, mais en raison d'un manque considérable de temps et du départ en stage et à l'étranger des membres du groupe, nous n'avons pas pu aller aussi loin que nous l'aurions voulu.

Ce fut de plus une première pour l'utilisation du javascript, langage relativement intéressant pour l'actualisation automatique des valeurs entre autre.

Le projet s'est révélé très formateur, et serait approfondi/abouti avec joie.