technologie innovation

Projet IOT et Energétique: SMART CITY

2018-01-29T11:15:00.001-08:00

Objectif:

Éclairage public basé sur l’énergie solaire avec suiveur de soleil commandé automatique, par téléphone, par présence et GPS téléphonique avec autres options intégrées dans l’IOT.

Introduction

L’IOT ouvre la voie de l’amélioration de la connaissance des équipements énergétiques. Les connecter à l’aide de capteurs fournit des informations précieuses et en temps réel sur l’état de fonctionnement. C’est là que réside sa première valeur ajoutée. Ces objets intelligents sont aujourd’hui capables de faciliter la connaissance de l’ensemble des infrastructures énergétiques. Par exemple, en analysant les données issues de ces capteurs, il est possible d’évaluer le comportement des équipements sur la durée et de prévoir les défaillances avant qu’elles ne surviennent.

Dans ce contexte, notre objectif du projet est intégré dans l’IOT des équipements énergétiques alors le projet et une Smart lights vise à minimiser le gaspillage d'énergie / électricité causée par l'utilisation peu pratique des lumières dans les rues (lampadaires), ainsi que la tolérance aux pannes automatisée et le contrôle mobile. Le produit utilise une technique de détection de présence pour déterminer les états de marche / arrêt des lumières ou pour contrôler le niveau de luminosité de ces lumières. Par deux méthodes l’une est contrôlée par les capteurs du détecteur de présence (ou mouvement) et l’autre par une application mobile GPS, aussi le projet contient éclairage public basé sur l’énergie solaire par l’utilisation des panneaux photovoltaïques avec commande automatiquement de déplacement du panneau photovoltaïque c'est à- dire suiveur de soleil. Aussi de commander automatiquement l’éclairage au cours de la nuit.

I) Etat du projet

1) Problématique Les pertes d’énergie dans un réseau de distribution d’électricité.

Coupure fréquente d’éclairage.
Réseau maillé.
Régime transitoire (parfois on trouve des points lumineux qui s’allument pendant la journée).
Difficulté au cours de la recherche d’une panne.
Lampe puissante : consomme 1,2 𝑘𝑤 par jour.
La production d’énergie électrique par réseau STEG adopté souvent sur des sources non renouvelables
Problème de sécurisation des habitants dans la cité.

2) Contexte

C'est une vue commune de nos jours que les lumières dans les couloirs des bâtiments ou des rues sont gardées brillantes, même si il n'y a absolument personne dans les environs pour les utiliser. Dans un contraste aigu à la condition ci-dessus, nous voyons également des cas où il n'y a pas suffisamment d'éclairage à des endroits où il est le plus requis. Une bonne manipulation des deux conditions ci-dessus peut conduire à une utilisation efficace de l'énergie et à une distribution efficace des ressources lumineuses. Le produit développé par nous vise à réaliser ce processus de pontage en mettant en œuvre des systèmes d'éclairage à capteurs.

3) Solution proposée

Notre solution consiste d’abord à faire la conception d’une poste d’éclairage qui contient le panneau solaire relié automatique par un régulateur solaire pour charger la batterie. À partir de ce dernier nous avons alimenté la lampe .Pour maximiser le stockage d’énergie nous avons utilisé quatre capteurs LDR comme un suiveur photovoltaïque afin de commander le sens du panneau photovoltaïque à travers leurs différentes positions du soleil. Ainsi pour la limitation de l’éclairage ; nous avons utilisé un capteur de lumière qui consiste à commander l’éclairage de la lampe qui restera allumée pendant la nuit et éteinte toute la journée.

Pour la partie IOT nous avons utilisé un Cloud IBM pour envoyer certains signaux de commande nécessaires au système Smart Lights.

Par une application mobile ou le Cloud ibm les résidents du quartier ont la liberté de choisir entre l’accès de l’éclairage public pour tout le monde ou pour les habitants dans la cité seulement
**L’accès pour tout le monde : On utilise les capteurs de la présence pour l’éclairage qui détecte la présence du véhicule ou de la personne et par la suite l’éclairage est réalisé
** L’accès pour les habitants dans la cité seulement : se détermine par une application mobile GPS qui envoie la présence de l’habitant au Cloud, cette dernière commande l’éclairage par un logiciel qui s’appelle Node-red. Donc cet accès est autorisé seulement dans le cas d’une présence d'un véhicule ou une personne appartient au résidant du quartier.

II) Eclairage

Dans cette partie notre but est l’éclairage d’une lampe à travers une énergie solaire.

ð On utilise un panneau solaire pour transformer la lumière en énergie électrique, un régulateur solaire pour charger une batterie 12v et une lampe LED pour l’éclairage.

1) Panneau photovoltaïque

Un panneau photovoltaïque transforme la lumière en énergie électrique (courant continue), il se compose d’un ou plusieurs modules, chaque module est composé des cellules.

2) Régulateur

Le circuit suivant permet de charger une batterie grâce à un panneau solaire et offre une alimentation de façon permanente. En utilisant une diode Schottky pour la charge et la protection contre le reflux (retour de courant). Afin d'éviter la décharge de la batterie dans le panneau, on utilise un comparateur. La tension de sortie du panneau doit être prise comme référence à cet effet, on met un potentiomètre à l’entrée du comparateur.

Généralement ce montage permet la protection contre le reflux et la limitation de la tension de charge.

3) Lampe

On utilise une lampe qui est alimentée par une batterie 12v, et qui est composée par des LED et par conséquent la consommation énergétique est très faible par rapport aux lampes qui sont utilisées par STEG, et c’est ça notre but.

Les matériaux semi-conducteurs que les LED utilisent ayant comme fonction de transformer l’énergie électrique en un rayonnement électromagnétique visible, c’est-à-dire en lumière.

II) Capteur et IOT

1) Suiveur de soleil

Pour commander le sens du panneau solaire nous avons utilisé 2 capteurs LDR et Servo-moteur pour déplacer le panneau à gauche et à droit, même principe pour le déplacement au-dessus et au-dessous.

On utilise une carte Arduino pour lire la différente valeur des deux capteurs LDR et ensuite commander le sens du panneau solaire à partir de servomoteur.

CODE:

#include  
 
Servo myservo; 
int pos = 90;   
int sens1 = A0; 
int sens2 = A1; 
int tolerance = 2;
 
void setup() 
{ 
  myservo.attach(9); 
  pinMode(sens1, INPUT);
  pinMode(sens2, INPUT);
  myservo.write(pos);
  delay(2000); 
}  
 
void loop() 
{ 
  int val1 = analogRead(sens1); 
  int val2 = analogRead(sens2); 
 
  if((abs(val1 - val2) <= tolerance) || (abs(val2 - val1) <= tolerance)) {
  } else {    
    if(val1 > val2)
    {
      pos = --pos;
    }
    if(val1 < val2) 
    {
      pos = ++pos;
    }
  }
 
  if(pos > 180) { pos = 180; } 
  if(pos < 0) { pos = 0; } 
  
  myservo.write(pos);
  delay(50);
}

2) Commande de l’éclairement lampe

Nous avons commandé l’éclairage de la lampe qui est allumée au cours de nuit et éteinte au cours de la journée. Alors pour cela on utilise un relais adaptable avec la batterie et un capteur LDR pour detecter la lumière et ensuite commander de l’éclairement. Le but de l’utilisation du relais est de commander les liaisons électriques entre la carte Arduino et la batterie , qu’ils nous permettent l'ouverture/fermeture et facilite le processus de la commande de la lampe.

CODE:

int val;
int led=9;
void setup()
{
 Serial.begin(9600);
}

void loop() 


{
 val = analogRead(0);
int lum=(5.0*val*100.0)/1024.0;
Serial.print(lum);
Serial.println("lum");
delay(300);
if(lum>100){
  digitalWrite(led,LOW);
}
else {
  digitalWrite(led,HIGH);
}
}

3) Détecteur de mouvement et Cloud

Si les habitants à travers le Cloud choisissent l’accès de l’éclairage pour tout le monde alors dans ce cas on utilise un capteur de mouvement ou capteur de présence.

Les capteurs de détection de mouvement sont connectés aux broches d'entrées de la carte Arduino. Ces capteurs peuvent être des capteurs UV ou IR.

Chaque fois qu'il y a un mouvement détecté, il y a un changement d'état du signal envoyé par ces capteurs. Puisque nous essayons de simuler trois blocs d'éclairage, un capteur est utilisé pour chacune des trois branches.

Un serveur est configuré localement pour envoyer les configurations des paramètres comme :

* La luminosité minimum ou maximum.
* Activer ou désactiver la fonction intelligente.

ð Une fois qu'une personne ou un véhicule sera détecté par un capteur du mouvement la carte Arduino envoie un signal pour l’éclairage. Le but de cette partie est l’utilisation de l’intelligence et de l'IOT pour diminuer la consommation énergétique, mais il n’y a pas de sécurisation pour les habitants alors on passe au 2éme choix.

CODE:

int ledPin = 3;               
int inputPin = 2;              
int pirState = LOW;            
int val = 0;                  

void setup() {
  pinMode(ledPin, OUTPUT);     
  pinMode(inputPin, INPUT);     
  Serial.begin(9600);
}
void loop(){
  val = digitalRead(inputPin);  
  Serial.println(val);
  if (val == HIGH) { 
    digitalWrite(ledPin, HIGH);  
    delay(150);
    if (pirState == LOW) {
      Serial.println("Motion detected!");
      pirState = HIGH;
    }
  } else {
    digitalWrite(ledPin, LOW); 
    delay(300);
    if (pirState == HIGH){
      Serial.println("Motion ended!");
      pirState = LOW;
    }
  }
}

4) Accès pour les habitants seulement

Si les résidents du quartier choisissant cette option alors on utilise plusieurs programmes comme l’Arduino ide, Python et surtout Node-red qui est intégré dans le domaine IOT et développé par l’IBM, aussi on utilise un Cloud IBM.

Le principe de ce choix consiste à travers un GPS ou une commande téléphonique de faire basculer ou choisir l’état de l’éclairement :

Par une commande GPS le téléphone via le logiciel Node-red envoie la position d’habitant au Cloud pour assurer l’éclairage selon l’habitant le plus proche.

Par une commande téléphonique, le client choisit les postes à éclairer.

Pour notre programme, on ajoute des options par exemple à travers les postes de l’éclairage les valeurs de température sont captées et les envoyées ensuite dans le Cloud IBM et ce dernier envoie les valeurs aux téléphones des habitants. Ainsi, pour la sécurisation de la citée des photos seront prises à travers la poste de l’éclairage puis envoyées au Cloud pour le stockage, il y a aussi des options pour notre projet comme : les capteurs d’humidité, des SMS mobile pour notifier les habitants, etc

èNotre projet est un programme développé sur un logiciel intégré dans le domaine IOT et IT qui est le Node-Red pour faciliter la programmation.

L’image suivante montre les commandes de l’éclairage par un téléphone de l’habitant.

VIDEO:

Réalisation d'une maison intelligente IOT: raspberry-pi,arduino,node-red...

2017-11-11T13:58:00.000-08:00

Notre but de ce projet est de réalisation d'une maison intelligente En premier lieu notre but c'est la commande de l'éclairage, TV, laveuse... a distancé, au deuxième lieu notre but c'est le contrôle de la maison par caméra, message téléphonique, adresse email, mot de passe, ... aussi GPS, envoyée images après 1h sur téléphone, température, post twitter, reconnaissance faciale.
alors le plan d'une maison est comme suite:

Node-red Pg

pour la commande on utilise node-red (pour l'installation voir article) , alors choisissez les nodes suivantes:

switch Node Input,

Freebord Node,

Arduino out node-red
Inject-node
Function node
sms-free-mobile-node
slider-node
http in node
camerapi-takephoto node
twitter out node
http reponse node
e-mail node
text input node
edit sentiment node

La programmation pour notre projet est traduit sur l'image suivante par l'utilisation des nodes sur un langage de programmation IOT node-red.ce dernier est développée par l'IBM

selon les nodes choisissez on fera les designs hardware donc on a besoin des;

Mobile android

Carte rasberry-pi

Arduino

des resistances

des relais 5v

des transistors

des optocoupleur

camera 15MPX

servo-moteur

clavier 4*4

Les autres composants sont purement software (les rôles principaux sur un carte raspberry-pi) premièrement on installe le carte de commande pour les lampes, les ventilateurs, TV, laveuse... sur la carte de commande pour cela on utilise l'arduino, transistors, optocoupleurs et relais pour chaque charge

Alors le relais se compose de deux parties. Une partie commande à droite sur la photo et composée d’une broche d’alimentation de 5 v pour le relais lui-même, une masse et une broche de commande pour faire basculer l’état. De l’autre côté, à gauche donc on trouve la partie basse tension. C’est cette dernière partie qui sera connectée à votre dispositif. Dans l’exemple ça sera une lampe. Se coter se composent de 3 fiches:

NC : signifie ‘NORMALEMENT FERME’. Cela veut dire que lorsque le relais n’a pas de signal d’entrée (0 sur la broche de commande), le circuit haute tension connecté sera actif. Si on câble comme cela il faut donc envoyer du courant à la partie commande pour faire basculer le relais.
NO signifie ‘NORMALEMENT OUVERT’. Cela veut dire qu’à contrario, une valeur de 5V appliqué au relais (1 sur la broche de commande) coupera le circuit haute tension et inversement.
COM: la masse.

L'arduino envoie un faible courant sur ses ports GPIO qu’ils soient à 1 ou à 0. Ce faible courant suffit à déclencher le relais. Certain peuvent donc directement utiliser le relais. Je vous conseil de le tester. Il vous suffit pour cela de brancher les trois broches du arduino comme suit:

5v du arduino -> Vcc 5V du relais
Ground du arduino -> GND du relais
L’un des port arduino -> La patte de commande du relais (numéroté IN1, IN2, etc.. généralement)

Si la diode du relais s’allume quelque soit l’état du port ARDUINO (LOW ou HIGH), c’est que vous êtes dans le même cas. Il vous faut alors un composant supplémentaire pour bloquer ce courant. Pour cette tache on va utiliser un MOSFET. Un MOSFET est un composant électronique permettant de faire de la commande en puissance. Le principe du fonctionnement de ce type de transistor est que lorsque la tension de la Gate atteint une valeur suffisante, le courant passe entre le Drain et la Source. Certains transistors sont commandés en courant, le Mosfet est commandé en tension.

1 = G = GATE : broche de commande. La commande ici sera le port GPIO.
2 = D = DRAIN : broche qui draine le courant (la charge quoi… c’est ici que l’on va raccorder le relais pour le déclencher)
3 = S = SOURCE : broche source de courant (ou le courant est collecté pour être envoyé vers la charge… dans notre cas, il s’agit de la masse)

Voila le schéma de la petite installation. J’ai utilisé ici un MOSFET

Pour la tester vous pouvez réutiliser le code précédent, ce qui aura pour effet d’enclencher et de déclencher le relais toute les secondes.

Une fois que tout cela fonctionne, il ne vous reste plus qu’a interfacer de l’autre coté l’élément basse tension que vous souhaitez contrôler et bien sur écrire un bout de code qui correspond à vôtre besoin.

Fonctionnement:

On applique un signal de commande de 5𝑉 sur la base du transistor via de la résistance, d’ou le transistor fonctionne comme un interrupteur qui relie la bobine du relais à la masse. Cette dernière est parcourue par un courant, alors le relais est actionné. La diode placée en parallèle de la bobine nous permet d'éviter de détruire le transistor lors de son ouverture. Qui l’on appelle généralement "la diode de roue libre" : cette diode est très importante et ne doit pas être négligée. En effet le pilotage du relais se fait via une bobine : l’ouverture du transistor se fait lors du passage de 1 à 0 logiques à l’entrée. Or le courant ne peut pas s’annuler immédiatement dans l’inductance. Ce qui est créé une surtension au niveau du collecteur du transistor qui peut être très élevée et ainsi supérieure a la tension de claquage Vce max (tension collecteur émetteur maximale préconisée par le constructeur). Les données sont:

T: transistor NPN, 𝛽 = 200, 𝑉𝑐𝑒_𝑠𝑎𝑡 = 0.2𝑉, 𝑉𝑏𝑒_𝑠𝑎𝑡 = 0.7𝑉,

REL: relais,𝑅𝑟𝑒𝑙 = 0.288 𝐾Ω.

D: diode de roue libre. Cette diode sert uniquement à protéger le transistor lorsqu'on le bloque (supprime l’arduino de tension du au relais).

Ve vaut 0 ou 5𝑉. Lorsque 𝑉𝑒 = 0, on veut que le relais ne soit pas alimenté (soit 𝑈𝑟𝑒𝑙 = 0), et lorsque 𝑉𝑒 = 5𝑉, on veut que le relais soit alimenté .

On commence par vérifier pour 𝑉𝑒 = 0:

Si 𝑉𝑒 = 0, alors 𝑉𝑏𝑒 = 0, et 𝐼𝑏 = 0 (la "diode" base émetteur est bloquée).

Donc le transistor est bloque,𝐼𝑐 = 𝐼𝑒 = 0. Donc

𝑈𝑟𝑒𝑙 = 𝑅𝑒𝑙 × 𝐼𝑐

= 288 × 0 = 0.

On fait le calcul de 𝑅 pour 𝑉𝑒 = 5𝑉:

On a 𝑉𝑐𝑐 = 𝑉𝑐𝑒 + 𝑈𝑟𝑒𝑙

Or il faut que le transistor soit saturé.

Donc 𝑉𝑐𝑒 = 𝑉𝑐𝑒_𝑠𝑎𝑡.

D'autre part, 𝑈𝑟𝑒𝑙 = 𝑅𝑟𝑒𝑙 × 𝐼𝑐

Donc V𝑐𝑐 = 𝑉𝑐𝑒_𝑠𝑎𝑡 + 𝑅𝑟𝑒𝑙 × 𝐼

calcul de 𝑅:

Il faut se souvenir que la jonction base émetteur se comporte comme une diode.

On a 𝑉𝑒 = 𝑈𝑟 + 𝑉𝑏𝑒.

Or 𝑉𝑏𝑒 = 𝑉𝑏𝑒_𝑠𝑎𝑡 = 0.7𝑉 (𝑑𝑖𝑜𝑑𝑒)

Donc 𝑉𝑒 = 𝑅 × 𝐼𝑏_𝑠𝑎𝑡 + 𝑉𝑏𝑒_𝑠𝑎𝑡

Soit

𝑅 = (𝑉𝑒 – 𝑉𝑏𝑒𝑠𝑎𝑡) /𝐼𝑏𝑠𝑎𝑡

= (5 − 0.7)/ 0.00030

= 14333 𝑂ℎ𝑚𝑠

= 14 𝑘Ω

Alors on a réalisé un "interrupteur" commandé électriquement:

*Lorsque à la journée : 𝑉𝑒 = 0, le transistor est bloqué, le relais n'est pas aliment donc la lampe éteint.

*Lorsque au nuit : 𝑉𝑒 = 5𝑉, Ib est un "faible" courant de commande, qui laisse passer un "fort" courant entre le colleteur et l'émetteur, d’ou le relais est alimenté donc la lampe est allumée

pour commander fenetre, port... à distance on utilisé un servo-moteur relié automatiquement par un condensateur

C’est un moteur un peu particulier, puisqu’il confond un ensemble de mécanique et d’électronique , mais son principe de fonctionnement reste assez simple. Les parties seront donc assez courtes dans l’ensemble car les servomoteurs contiennent dans leur « ventre » des moteurs à courant continu que vous connaissez à présent. Un servomoteur se décompose essentiellement d’un :

Moteur à courant continue
Système réducteur de vitesse a roues dentées
Potentiomètre
Circuit électronique

La consigne doit être donnée par l’utilisateur (dans notre cas il va s’agir du signal envoyé par la carte Arduino), est comparée par rapport à la position réelle de l’axe du moteur. Ainsi, s’il y a une différence d’angle entre la consigne et l’angle mesuré par le capteur (le potentiomètre qui est fixé sur l’axe du servomoteur) le comparateur va commander le moteur et le faire tourner jusqu’à ce que cette différence s’annule.

Un comparateur est un composant électronique de la famille des circuits intégrés car, il contient en vérité d’autres composants, essentiellement des semi-conducteurs (diodes, transistors) et des résistances. Par la suite le shéma de montage d’un servomoteur est comme suit :

Le comparateur est donné : -

Si 𝑉1 > 𝑉2, alors 𝑉𝑠 = +Vcc

- Si 𝑉1 < 𝑉2, alors 𝑉𝑠 = −𝑉𝑐𝑐

À la place du potentiomètre de commande manuelle on peut utiliser un couple résistance/ condensateur avec 𝑅 et 𝐶, qui permet d’extraire la tension continue du signal dont le rapport cyclique varie de 0 à 100%.

Le signal de commande d'un servomoteur est un signal PWM( pulse wide modelation) de fréquence 50𝐻𝑧 et dont le niveau haut doit être compris entre 1 𝑒𝑡 2𝑚𝑠 (en théorie).

1𝑚𝑠 ∶ −90° en angle de sortie

1.5𝑚𝑠 ∶ 0° en angle de sortie

2𝑚𝑠 ∶ +90° en angle de sortie

Pour utiliser le servomoteur comme un moteur de propulsion (pouvant tourner normalement), il est nécessaire d’effectuer une modification mécanique, pour 0.25𝑠 le servomoteur tourne à 180° donc on détermine la vitesse de rotation :

0.25𝑠--> 180°

0.25×180 /60 = 0.50𝑠 -->360°

Le servomoteur tourne 1 tour en 0.5𝑠 ce qui est permet de déterminer la vitesse de rotation 𝑁𝑠

1𝑡𝑟 -->0.5𝑠

60/ 0.5 = 120𝑡𝑟/𝑚𝑖𝑛 -->60𝑠

D’après la règle de trois 𝑁𝑠 = 120𝑡𝑟/𝑚𝑖𝑛 Par suite on calculer la vitesse angulaire de notre servomoteur :

Ω = 2𝜋𝑁𝑠 /60

= 2×3.14×120 /60

= 12.5𝑟𝑑/𝑠

Le servomoteur consomme 250𝑚𝐴 sous 5𝑉, on calcul la puissance absorbé Pabs

𝑃𝑎𝑏𝑠 = 𝑈 × 𝐼 = 5 × 0,250 = 1,25𝑊

𝐶 = 0.08𝑁. 𝑚 et Ω = 12.5𝑟𝑑/𝑠 donc on calculer la puissance mécanique

𝑃𝑠 = 𝐶 × Ω

= 0,08 × 12.5

= 1𝑊

Par suite on déduire le rendement de notre servomoteur :

rendement = 𝑃𝑠 /𝑃𝑎𝑏𝑠

= 1 /1.25

= 0.8𝑊

Alors le rendement de notre servomoteur est égale à 80%

Nous essayé le servomoteur mais il vibre sans rotation ce qui est indique l’existence d’une chute de tension pour cela on utilise un condensateur dans le but d’avoir une tension sensiblement constante, donc on propose de brancher un ou plusieurs condensateurs en parallèle. Théoriquement plus la valeur de condensateur sera élevée plus le filtrage sera mieux.

𝐶 = 𝐼 /(𝛽×𝑈×F)

Avec : 𝛣 = 20 %, 𝐹 = 50𝐻𝑍

𝐶 = 0.250 /(0.2×5×50) = 4000µf

Vidéo démonstration:

Après l'installation servo-moteur .on passe pour les caméras pour programmation on utilise le langage python et open CV pour reconnaissance et suiveur facial
Détecter un visage
La première fonctionnalité dont nous aurions besoin pour effectuer la reconnaissance faciale est de détecter, dans le champ de vision actuel, un visage est présent. En utilisant la bibliothèque OpenCV, vous pouvez utiliser les filtres en cascade de HAAR pour le faire efficacement.

Au cours de la mise en œuvre, nous avons utilisé Anaconda avec Python 3.5, OpenCV 3.1.0 et dlib 19.1.0. Si vous souhaitez utiliser le code dans cet article, assurez-vous que vous avez ces versions (ou plus récentes).

Afin de faire la détection de visage, nous devons d'abord effectuer quelques initialisations:

import cv2
faceCascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
OUTPUT_SIZE_WIDTH = 775  
OUTPUT_SIZE_HEIGHT = 600
capture = cv2.VideoCapture(0)
cv2.namedWindow("base-image", cv2.WINDOW_AUTOSIZE)  
cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE)
cv2.moveWindow("base-image",0,100)  
cv2.moveWindow("result-image",400,100)
cv2.startWindowThread()
rectangleColor = (0,165,255)

Le reste du code sera une boucle infinie qui récupère la dernière image de la webcam, détecte tous les visages dans l'image, dessine un rectangle autour du plus grand visage et enfin affiche la sortie dans une fenêtre.

Ce qui précède peut être réalisé avec le code suivant dans une boucle infinie:

rc,fullSizeBaseImage = capture.read()
baseImage = cv2.resize( fullSizeBaseImage, ( 320, 240))
pressedKey = cv2.waitKey(2)  
if pressedKey == ord('Q'):  
cv2.destroyAllWindows()  
exit(0)
resultImage = baseImage.copy()
gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2GRAY)  
faces = faceCascade.detectMultiScale(gray, 1.3, 5)
maxArea = 0  
x = 0  
y = 0  
w = 0  
h = 0
for (_x,_y,_w,_h) in faces:  
    if  _w*_h > maxArea:
        x = _x
        y = _y
        w = _w
        h = _h
        maxArea = w*h
    if maxArea > 0 :
        cv2.rectangle(resultImage,  (x-10, y-20),
                    (x + w+10 , y + h+20),
                    rectangleColor,2)

largeResult = cv2.resize(resultImage,  
             (OUTPUT_SIZE_WIDTH,OUTPUT_SIZE_HEIGHT))
cv2.imshow("base-image", baseImage)  
cv2.imshow("result-image", largeResult)

Suivre le visage
Le code ci-dessus pour la détection de visage présente certains inconvénients:

Le code peut être coûteux en termes de calcul
Si la personne détectée tourne légèrement la tête, la cascade du haar pourrait ne plus détecter le visage
Il est très difficile de garder la trace d'un visage entre des images (c'est-à-dire de ne plus faire face à un visage détecté qu'une fois et pas dans chaque boucle).
Une meilleure approche pour cela est de faire la détection du visage une fois et ensuite utiliser le tracker de corrélation de l'excellente bibliothèque dlib pour garder une trace de la région pertinente d'une image à l'autre.

Pour que cela fonctionne, nous devons importer une autre bibliothèque et initialiser des variables supplémentaires:

import dlib
tracker = dlib.correlation_tracker()
trackingFace = 0

Dans la boucle for infinie, nous devrons maintenant déterminer si le traqueur de corrélation dlib suit actuellement une région dans l'image. Si ce n'est pas le cas, nous utiliserons un code similaire comme précédemment pour trouver le plus grand visage, mais au lieu de dessiner le rectangle, nous utilisons les coordonnées trouvées pour initialiser le tracker de corrélation.

if not trackingFace:
    gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2GRAY)
    faces = faceCascade.detectMultiScale(gray, 1.3, 5)
    print("Using the cascade detector to detect face")
    maxArea = 0
    x = 0
    y = 0
    w = 0
    h = 0
    for (_x,_y,_w,_h) in faces:
        if  _w*_h > maxArea:
            x = int(_x)
            y = int(_y)
            w = int(_w)
            h = int(_h)
            maxArea = w*h
    if maxArea > 0 :
        tracker.start_track(baseImage,
                            dlib.rectangle( x-10,
                                            y-20,
                                            x+w+10,
                                            y+h+20))

     
        trackingFace = 1

Maintenant, le dernier bit dans la boucle infinie consiste à vérifier à nouveau si le suiveur de corrélation suit activement un visage (c'est-à-dire qu'il peut simplement détecter un visage avec le code ci-dessus). Si le tracker suit activement un visage dans l'image, nous allons maintenant mettre à jour le tracker. En fonction de la qualité de la mise à jour (c'est-à-dire de la confiance du traqueur sur le suivi du même visage), soit nous dessinons un rectangle autour de la région indiquée par le tracker, soit nous indiquons que nous ne suivons plus aucun visage:

public class HelloWorld {

if trackingFace:
    trackingQuality = tracker.update( baseImage )
    if trackingQuality >= 8.75:
        tracked_position =  tracker.get_position()

        t_x = int(tracked_position.left())
        t_y = int(tracked_position.top())
        t_w = int(tracked_position.width())
        t_h = int(tracked_position.height())
        cv2.rectangle(resultImage, (t_x, t_y),
                                    (t_x + t_w , t_y + t_h),
                                    rectangleColor ,2)

    else:
        trackingFace = 0

Comme vous pouvez le voir dans le code, nous imprimons un message à la console chaque fois que nous utilisons à nouveau le détecteur et envoyée sur telephone du client. Si vous regardez la sortie de la console lors de l'exécution de cette application, vous remarquerez que même si vous vous déplacez un peu sur l'écran, le tracker est assez bon pour suivre un visage une fois qu'il est détecté. Lorsque vous utilisez le code ci-dessus, vous devriez voir un écran similaire au suivant, où le programme indique qu'il a détecté mon visage:

Vidéo Demonstration

Sécurisation par clavier et code de vérification Mobile:
Après détection et suiveur de vissage on parle maintenant sur la sécurisation pour Sela on utilise un clavier 4*4 pour gérer le mot de passe .et si le mot de passe fault le client recevoir un code de vérification sur téléphone (le programme de vérification mobile se fait par le programme node-red. voir partie Node-red pg au-dessus) .alors le fonctionnement de clavier et comme suite:

Nous utiliserons la librarie Password and Keypad pour arduino, en plus d'utiliser la servo-librairie, mais cette partie peut aussi être modifiée en changement le servo-moteur, un moteur pas à pas, ou toute autre idée...

Étape 1: Les pièces de ce partie:

Nous aurons besoin de ces pièces pour ce parties:

Quatre résistances de 910 ohms

Une résistance de 1k

Arduino UNO ou similaire

Servomoteur - Large

CLAVIER 4X4 (ou similaire)

plaque à essai

fils jumper

Étape 2: Préparation du clavier

Eh bien, maintenant nous devons mettre les résistances, rappelez-vous la potion des broches du clavier.

Goupilles de sortie du clavier:

1 pin = col 1
2 pin = col 2
3 pin = col 3
4 pin = col 4

5 pin = row 1
6 pin = row 2
7 pin = row 3
8 pin = row 4

Maintenant, ils doivent mettre trois résistances 10 kohms sur les broches 1, 2 et 3 du clavier, puis mettre dans les broches numériques arduino du formulaire NEXT:

pins keypad | pins arduino

---------------------------------------
          1           |           8
          2           |           7
          3           |           6
          4           |           9
          5           |           5
          6           |           4
          7           |           3
          8           |           2

Étape 3: Préparation du servo

Étape 4: Connexion des LED

Vous devez placer la LED Acceptée (verte) et la LED Refusée (rouge) de cette manière:

Étape 5: (UPDATE) et maintenant, la programmation

Vous avez besoin de ces bibliothèques:

Mot de passe librarie

Keypad librarie

Eh bien, c'est le code pour arduino, il vous suffit de changer cette écriture en gras et de mettre votre mot de passe.

#include <Password.h> /

#include <Keypad.h> /

#include <Servo.h>

Servo myservo;

Password password = Password( "your_password" );

const byte ROWS = 4;

char keys[ROWS][COLS] = {

{'1','2','3','A'},

{'4','5','6','B'},

{'7','8','9','C'},

{'*','0','#','D'}

};

byte rowPins[ROWS] = { 5, 4, 3, 2 };

byte colPins[COLS] = { 8, 7, 6, 9 };

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup(){

Serial.begin(9600);

Serial.write(254);

Serial.write(0x01);

delay(200);

pinMode(11, OUTPUT);

myservo.attach(13);

keypad.addEventListener(keypadEvent);

}

void loop(){

keypad.getKey();

myservo.write(0);

}

void keypadEvent(KeypadEvent eKey){

switch (keypad.getState()){

case PRESSED:

Serial.print("Enter: ");

Serial.println(eKey);

delay(10);

Serial.write(254);

switch (eKey){

case 'A': checkPassword(); delay(1); break;

case 'B': password.reset(); delay(1); break;

default: password.append(eKey); delay(1);

}

void checkPassword(){

if (password.evaluate()){

Serial.println("Accepted");

Serial.write(254);delay(10);

//Add code to run if it works

myservo.write(5);

digitalWrite(11, HIGH);

delay(500); //wait 5 seconds

digitalWrite(11, LOW);

}else{

Serial.println("Denied");

Serial.write(254);delay(10);

myservo.write(0);

digitalWrite(12, HIGH);

delay(500); //wait 5 seconds

digitalWrite(12, LOW);

}

et voila le code arduino et bibliothèques:

code/bib

Comme mentionné ci-dessus, s'il y a une erreur dans le mot de passe, une code de vérification est envoyé sur le télephone du client par l'utilisation d'un logiciel IOT node-red
Comm Raspberry-pi/Arduino
Maintenant il est temps de communication carte IOT dite raspberry-pi avec la carte arduino.

Et alors Pourquoi voudrait-on établir une communication entre un Raspberry Pi et un Arduino? Maintenant que nous avons appris comment utiliser les pins GPIO du Raspberry Pi, ce dernier n'est-il pas capable d'agir de façon autonome?

Voici quelques raisons possibles:

Le Raspberry Pi n'est pas idéal pour accomplir des actions avec un timing précis, car Linux pourrait décider de se consacrer temporairement à une autre tâche. Par exemple, si vous contrôlez un moteur pas à pas,servo-moteur... avec le Raspberry Pi, le moteur pourrait s'arrêter momentanément, de temps à autres. L'Arduino est plus fiable dans ce genre de situation.
Vos capteurs peuvent se trouver sur un shield conçu pour être inséré sur un Arduino. Évidemment, la disposition des pins GPIO du Raspberry Pi n'est pas la même.
Si vous êtes déjà un utilisateur expérimenté de l'Arduino mais un néophyte en Python/Linux/Raspberry Pi, il y a certaines choses que vous savez déjà faire très facilement avec l'Arduino, mais que vous ne savez pas encore comment faire avec le Raspberry Pi.
Vous désirez établir un réseau de plusieurs capteurs satellites qui se rapportent à une seule station centrale, et plusieurs Arduinos coûtent moins cher que plusieurs Raspberry Pi.
La raison la plus importante pour notre projet ce qui est le rôle principal que vous souhaitez jouer carte raspberry-pi est seulement IOT pas d'autre.

La bonne nouvelle, c'est que c'est tout à fait possible, et même relativement facile, d'établir une communication entre un Raspberry Pi et un Arduino. Et ce ne sont pas les options qui manquent: communication série (UART), I2C, Ethernet, communication sans fil...

Dans cette partie, nous abordons l'option qui s'avère probablement la plus simple: la communication série par l'entremise d'un câble USB: vous allez simplement brancher l'Arduino à un des deux ports USB du Raspberry Pi, de la même façon que vous le faites lorsque vous désirez programmer l'Arduino avec un ordinateur conventionnel. Mais attention: avant de brancher l'Arduino au Raspberry Pi, assurez-vous que l'Arduino dispose de sa propre alimentation; le Raspberry Pi pourrait avoir des ratés si sa propre alimentation devait, en plus, alimenter l'Arduino par le port USB.

Installation de la bibliothèque pyserial

Installons d'abord la bibliothèque pyserial dans le Raspberry Pi: elle nous facilitera grandement la tâche lors de la conception de nos scripts en Python. Pour ce faire, vous utilisez cette commande pendant que le Raspberry Pi est branché à l'internet:

sudo apt-get install python-serial

Envoi d'un message de l'Arduino vers le Raspberry Pi
Commençons par une communication unidirectionnelle de l'Arduino vers le Raspberry Pi. Du côté Arduino, l'envoi de messages se fait par la commande "Serial.println". Par exemple, le sketch ci-dessous envoie un message toutes les 3 secondes. J'ai ajouté un compteur pour que le message ne soit pas rigoureusement identique d'une fois à l'autre. Nous pourrons donc vérifier que tous les messages envoyés par l'Arduino sont bel et bien captés par le Raspberry Pi.

int compteur = 0;

void setup(){
  Serial.begin(9600);
}

 
void loop(){
  Serial.print("Message numero ");
  Serial.println(compteur);
  Serial.println("Bonjour, la Framboise, ici l'Arduino!");
  compteur++;
  delay(3000);
}

Comme vous pouvez le constater, c'est exactement comme si vous vouliez afficher un message sur le moniteur série de l'environnement de programmation Arduino; vous pouvez d'ailleurs utiliser le moniteur série pour vérifier dès maintenant que le sketch fonctionne de la façon prévue. Du côté Raspberry Pi, à la condition que la bibliotèque PySerial ait été préalablement installée, la fonction "serial.Serial" nous permet de lire les messages reçus . Le premier paramètre de cette fonction est le nom du port usb occupé par l'Arduino: dans mon cas, c'était ttyACM0; ce sera peut-être la même chose pour vous aussi, mais ce n'est pas certain. Pour en avoir le coeur net, vous pouvez écrire cette ligne de commande:

ls /dev/tty*

Vous devriez avoir un résultat légèrement différent selon que l'Arduino est connecté ou non au Raspberry Pi. Le nom correct devrait être celui qui apparaît dans la liste pendant que l'Arduino est branché, mais qui n'y apparaît pas quand l'Arduino est débranché du port USB. Voici donc un sketch en Python qui permettra au Raspberry Pi d'écouter ce que lui dit l'Arduino, et d'afficher le résultat. (Personnellement, j'utilise le logiciel WinSCP pour installer le fichier dans le Raspberry Pi).

import serial
ser = serial.Serial('/dev/ttyACM0', 9600)
while 1 :
   print(ser.readline())

Pour interrompre le script, vous pouvez utiliser la combinaison Ctrl-C au clavier.
Envoi d'un message du Raspberry Pi vers l'Arduino
Essayons maintenant l'autre direction: branchons quelques LEDs à l'Arduino, et c'est le Raspberry Pi qui indiquera à l'Arduino quelles LEDs il doit éteindre ou allumer.
Donc, une LED (accompagnée de sa résistance protectrice) est branchée à chacune des pins suivantes de l'Arduino: 2, 3 et 4 (attention: le schéma ci-dessous montre par erreur des connexions aux pins 1, 2, et 3!).

Commençons par le sketch Arduino. Grâce à la fonction Serial.read, le sketch ci-dessous allume ou éteint les LEDs en fonction du message reçu: il allume la LED 1 (pin 2) s'il reçoit le message "1", il éteint la LED 2 (pin 3) s'il reçoit le message "5", etc.

#define LED1 2
#define LED2 3
#define LED3 4

int message = 0;


void setup()
{
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  
  Serial.begin(9600);
}

void loop()
{
  if (Serial.available())  {
    message = Serial.read()-'0';  // on soustrait le caractère 0, qui vaut 48 en ASCII
    
    switch (message) {
    case 1:
      digitalWrite(LED1, HIGH);
      break;
    case 2:
      digitalWrite(LED2, HIGH);
      break;
    case 3:
      digitalWrite(LED3, HIGH);
      break;
    case 4:
      digitalWrite(LED1, LOW);
      break;
    case 5:
      digitalWrite(LED2, LOW);
      break;
    case 6:
      digitalWrite(LED3, LOW);
      break;
    }
  }
}

Pourquoi soustraire le caractère '0'? C'est parce qu'au départ, lorsque l'Arduino reçoit le message "1", il s'agit d'un caractère dont le code ASCII est 49. En soustrayant le caractère '0' (dont le code ASCII est 48), le caractère '1' qui a été reçu devient le nombre entier 1. Si vous le désirez, vous pouvez vérifier que ce sketch fonctionne correctement à l'intérieur de l'environnement de programmation Arduino, avant même de brancher l'Arduino au Raspberry: dans le moniteur Série, tapez des nombres entre 1 et 6 et voyez que les LEDs s'allument ou s'éteignent en fonction des nombres que vous envoyez. Et voici le script en Python qui sera exécuté par le Raspberry Pi: c'est maintenant lui qui envoie des informations à l'Arduino:

import serial  
import time    
ser = serial.Serial('/dev/ttyACM0', 9600)
compteur = 0
while True:     
    if compteur < 6:
     compteur = compteur + 1
    else:
     compteur = 0
    ser.write(str(compteur))
    time.sleep(1)

Communication bidirectionnelle entre le Raspberry Pi et l'Arduino

Finalement, voici un exemple où le Raspberry Pi demande une information à l'Arduino (l'état d'un potentiomètre dont le curseur est branché à A0 ), et affiche la réponse que lui a retournée l'Arduino.

Le sketch Arduino:

int message = 0;
void setup()
{ 
  Serial.begin(9600);
}

void loop()
{
  if (Serial.available())  {
    message = Serial.read()-'0';  
    if (message == 5){
      Serial.println(analogRead(A0),DEC);
    }
  }
}

Le script en python du Raspberry Pi:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
5oQCPcBGAYYCw/s1600/4.png" />


# Le Raspbery Pi demande une information à l'Arduino,
# puis il affiche la réponse à l'écran

import serial  # bibliothèque permettant la communication série
import time    # pour le délai d'attente entre les messages

ser = serial.Serial('/dev/ttyACM0', 9600)
time.sleep(4)   #on attend un peu, pour que l'Arduino soit prêt.

while True:     # boucle répétée jusqu'à l'interruption du programme
    ser.write('5')
    print(ser.readline())  #on affiche la réponse
    time.sleep(1)               # on attend pendant 1 seconde

--> Puisque notre but de projet est intéressé dans le domaine IOT alors on utilise une carte bassée a ce dernier qui est la carte rasberry-pi comme exemple dans le GPS, SENTIMENT, TAKE PICTURE,TEMPERATURE... tout, est au-dessus dans la partie node-red qui installé par défaut sur le système d'exploitation raspian (systeme d'exploitation sur rasberry-pi)

Design and Control robot by computer (node-red/cameras)

2017-09-04T11:05:00.000-07:00

This article is about control robot car photovoltaic with laptop and camera So The objective of this project is to design and conception remote control node-red toy or robot. We learn the interface of the commercially available RF transmitter and receiver module coupled with HT12E and HT12Dpair (Encoder/Decoder) to transfer data over the air to the motors in the our robot car.

For complete computer control, we have used two cameras, wireless by program droid-cam starts from it, we did remote by node-red

For loading a battery for remote receiver we have used photovoltaic.

Working Logic for the RC Robot Car

Here is a flowchart to help you understand the working logic of the robot car. First we will go over the basic idea of the RC car and the working logic that is involved in the car. There are two blocks, the Transmitter (remote control using node-red)) and the Receiver (robot car)also this flowchart help you understand Solar charging method by photovoltaic panels Starting from the control of the loader To facilitate remote control, we used two cameras we talk about later

On the transmitter side, you have the switch node-red to give the digital inputs to the encoder IC. The encoder then encodes this data and sends it to the RF Transmitter module. On the receiver side, you will have the RF Receiver which receives the encoded data and passes it on to the decoder. The decoder decodes the data and sends it to the motor driver IC to drive the motors.

Circuit diagrams and description.

Required Components

Transmitter Section:

Optocoupler:

For Arduino control are used in the remote control to move the car backward, forward, left and right.

HT12E Encoder IC :

It is a 2 series encoder IC used for wireless communication applications. It is mainly used to convert 12 bit parallel data (8 address bits and 4 data bits) to serial out so that it can be transmitted using a transmitter Module.

RF Tx Module:

434 MHZ ASK transmitter module for transmission. It is capable of providing a data rate of about 8kbps.

Arduino:

Used for two things, first power the remote and the second for the programming to control remote.

Reciver Section:

RF RX module:

A high sensitivity 434 MHZ ASK Receiver module for receiving the data from remote control.

HT12D Decoder IC:

It is a 12 series decode IC used for wireless communication applications. It converts the serial input to parallel out.

Motor Driver:
L293D is a motor driver IC which has two channels for driving two motors. L293D has two inbuilt Transistor Darrlington pair for current amplification and a separate power supply pin for giving external supply for the motors.

Motors:
Here two B0 motors are used which are driven by the motor driver L293D and both of them are connected to robotic wheels to move the car

Power:

So 9V/12V battery is required to power the circuit.so we will use battery, photovoltaic panel and solar regulator will talk about it later

Remote encoder/ transmitter circuit

Node-RED:Interacting with arduino

Introduction:

Node-RED is a tool for wiring together hardware devices, APIs and online services in new and interesting ways.

Node-RED provides a browser-based flow editor that makes it easy to wire together flows using the wide range nodes in the palette. Flows can be then deployed to the runtime in a single-click.

Why Node-RED?

Open-source

Multi-platform/Cross-platform

Browser based and supported by cloud platforms like Bluemix of IBM.

Visual programming tool

Supports real-time automation of M2M and IoT protocols.

Future of Industrial IoT(Internet of Things)

1-Preparing your Arduino Uno board

Baud-rate should be 57600.

Don't use/open your serial monitor, keep your COM port free.

Keep your arduino board connected to your computer.

testing your arduino

Code firmata
Run Arduino ,open file>examples>firmata>standardfirmata and click to upload

2-Preparing your Node-red

How to install Node-red ?

---->For Windows

Download node.js for your computer, Click here.
-Open the command prompt and install Node-RED with this command.

npm install -g node-red

-Now run your Node-RED, with this command

node-red
Copy the local-server link to your browser(Chrome) http://localhost:1880/#

---->For Ubuntu/linux

-install node-js and npm

install the -legacy version of the package

sudo apt-get install nodejs-legacy

Verify that the installation was successful by checking the version.

node -v

You'll see Node.js output its version number:

Node Package Manager (npm) helps you install and manage Node.js software packages, and we'll use it to install Node-RED. Install npm using apt-get.

sudo apt-get install npm

To verify the install was successful, ask npm to print its version information:

npm -v

-installing node-red

Use npm to install node-red

sudo npm install -g node-red

First, we'll need to open up a port on our firewall. Node-RED defaults to using port 1880, so let's allow that.

sudo ufw allow 1880

And now launch Node-RED itself. No sudo is necessary, as port 1880 is high enough to not require root privileges.

node-red

your ip adress is http://127.0.0.1:1880//

at last welcome to node-red.

Node-red at a glance

Now install the new package Arduino for node-red:

open terminal

create this command

cd ~/.node-red/

and install this package

sudo npm install node-red-node-arduino

or Write in 'Menu>Manage palette>Install' node-red-node-arduino and install this is the last

3-Connect Node-red with arduino

Now it is time to create your project.

Choose the following NODES-

switch Node Input,

Freebord Node,

Arduino out node-red

Copy and Import the following code (Menu>Import>Clipboard)

[{"id":"744bed9a.120ab4","type":"arduino out","z":"282f2cb4.0b1164","name":"","pin":"9","state":"OUTPUT","arduino":"46aa28ae.e4fdc8","x":569,"y":149,"wires":[]},{"id":"76963dab.7db304","type":"arduino out","z":"282f2cb4.0b1164","name":"","pin":"10","state":"OUTPUT","arduino":"46aa28ae.e4fdc8","x":591,"y":203,"wires":[]},{"id":"799bb4e7.ddb5ec","type":"arduino out","z":"282f2cb4.0b1164","name":"","pin":"11","state":"OUTPUT","arduino":"46aa28ae.e4fdc8","x":523,"y":324,"wires":[]},{"id":"3cdf4b80.64ea24","type":"arduino out","z":"282f2cb4.0b1164","name":"","pin":"12","state":"OUTPUT","arduino":"46aa28ae.e4fdc8","x":556,"y":400,"wires":[]},{"id":"111271b9.43e14e","type":"freeboard","z":"282f2cb4.0b1164","name":"v","x":417,"y":102,"wires":[]},{"id":"3f40040b.7d5ddc","type":"freeboard","z":"282f2cb4.0b1164","name":">","x":367,"y":264,"wires":[]},{"id":"65d0128e.be831c","type":"freeboard","z":"282f2cb4.0b1164","name":"<","x":353,"y":352,"wires":[]},{"id":"28e5dd0f.34a2a2","type":"ui_switch","z":"282f2cb4.0b1164","name":"","label":"^","group":"c8f421c4.2b8b1","order":0,"width":0,"height":0,"passthru":true,"decouple":"false","topic":"","style":"","onvalue":"true","onvalueType":"bool","onicon":"","oncolor":"","offvalue":"false","offvalueType":"bool","officon":"","offcolor":"","x":84,"y":158,"wires":[["744bed9a.120ab4","111271b9.43e14e"]]},{"id":"723ffab5.9d0154","type":"ui_switch","z":"282f2cb4.0b1164","name":"","label":"v","group":"c8f421c4.2b8b1","order":0,"width":0,"height":0,"passthru":true,"decouple":"false","topic":"","style":"","onvalue":"true","onvalueType":"bool","onicon":"","oncolor":"","offvalue":"false","offvalueType":"bool","officon":"","offcolor":"","x":81,"y":242,"wires":[["76963dab.7db304","3f40040b.7d5ddc"]]},{"id":"de62a34.7c65f6","type":"ui_switch","z":"282f2cb4.0b1164","name":"","label":"<","group":"c8f421c4.2b8b1","order":0,"width":0,"height":0,"passthru":true,"decouple":"false","topic":"","style":"","onvalue":"true","onvalueType":"bool","onicon":"","oncolor":"","offvalue":"false","offvalueType":"bool","officon":"","offcolor":"","x":82,"y":330,"wires":[["799bb4e7.ddb5ec","65d0128e.be831c"]]},{"id":"a01a4ffa.ea24b","type":"ui_switch","z":"282f2cb4.0b1164","name":"","label":">","group":"c8f421c4.2b8b1","order":0,"width":0,"height":0,"passthru":true,"decouple":"false","topic":"","style":"","onvalue":"true","onvalueType":"bool","onicon":"","oncolor":"","offvalue":"false","offvalueType":"bool","officon":"","offcolor":"","x":84,"y":472,"wires":[["3cdf4b80.64ea24","c3071b0b.9a9c98"]]},{"id":"c3071b0b.9a9c98","type":"freeboard","z":"282f2cb4.0b1164","name":">","x":287.94447326660156,"y":502.2153015136719,"wires":[]},{"id":"46aa28ae.e4fdc8","type":"arduino-board","z":"","device":"/dev/ttyACM0"},{"id":"c8f421c4.2b8b1","type":"ui_group","z":"","name":"Default","tab":"c9dac48d.106528","disp":false,"width":"12"},{"id":"c9dac48d.106528","type":"ui_tab","z":"","name":"Home","icon":"dashboard"}]

You should modify the Nodes, with your custom settings.

And click DEPLOY BUTTON to run your program.

In the end. in order to command in the node-red . Open this adress ip http://127.0.0.1:1880/ui/#/0

So the control of the node-red is ready

Transmitter circuit with Arduino-Uno

Now for the transmitter circuit, you will have to bear in mind that this is your remote. So The HT12E encoder are 12 bit encoders that is they have 8 address bits and 4 data bits. The address bits can be left open or pulled low. In the circuit below, you will see that each of the address pins (A0 to A7) are connected to output arduino pin 9 to 12 . So if the pin arduino is ON then that line is connected to GND (VSS) otherwise the pin is left floating.

The TE (transmit enable) is an active low input to the IC. This enables the transmission. So when the pin-arduino connected to pin 14 is pressed, the 8 address bits along with the 4 data bits (AD8 to AD11) are serially encoded and sent out at the DOUT pin.

For
our application (RC robot car) we will connect TE directly to GND as
we have to keep sending the data as and when they arrive to the rc
car.

The
aim of using the optocoupler is we can also provide electrical
isolation/seprate between an arduino source and an HT12E encoder load
using just light 

Your
use of the Node-red helps you control through the computer to order
to go forward, back or turn left or right through the command set

Unlike
the receiver circuit, this does not need to have a beefy battery. You
could power this circuit with output 5V arduino. This circuit  will
help you understand how the system works and how to install your
project for transmission section




Remote receiver/decoder circuit 

This
is the circuit diagram for the receiver. It handles the RF reception
as well as the motor drive.

The
address pin in the decoder (HT12D) behaves just like that of the encoder. The data is received at the DIN pin from the RF receiver
circuit and then this data is checked 3 times (according to the
datasheet the data is transmitted 3 times and received 3 times and
only if all 3 times the data is same it is decoded) and then decoded
and the IC checks if the address pin connection of the encoder is
same as that of the decoder. If the address configuration of the
decoder matches that in in the received data (from encoder) the data
is decoded and latched on to the data pins (D8 to D11).

This
decoded data is then sent as control signals to the motor driver IC.
L293d is a dual H-bridge motor driver to be short. It is used to
drive the motor in both forward and back ward direction. Read about
the
basics
of DC motor drive and their speed control
to
get a better understanding of this concept.

The
VT (valid transmit) pin is used to indicate if there is a valid
transmission between the encoder and decoder. This pin can be left
open or like in the circuit below, an LED with series resistance can
be used to give a visual indication.



Power Solar

For
Circuit power supply You will use a Panel PV 12V, a Regulator and a
battery 12V

Photovoltaic
panel (PV)  is used to directly transform sunlight into electricity
since they are made of semiconductor materials based on silicon.
store directly on 12v battery by using a solar charger

The solar charger controller has two functions:

*Protection against
reflux.

*Limitation of the load
voltage.

It is easy to spot
reflux protection in the circuit. If the voltage at the terminals of
the accumulator exceeds that of the panel, the Schottky diode D3
prevents the current from circulating from the positive pole of the
accumulator to that of the solar panel independently of the state of
the rest of the circuit. The load current passes freely in the
opposite direction. The voltage loss at the terminals of the power
diode is approximately. The solar current can also pass through D4
and T2 when the transistor conducts. The transistor is controlled by
the operational amplifier which acts as a comparator. T1 and P1 make
it possible to provide an equalized reference voltage equal to
approximately half of the final load voltage. The operational
amplifier compares the reference voltage with the voltage of the
accumulator halved by R1 and R2 and by D2. the output of the AOP
remains low as long as the battery voltage is less than the final
charging voltage, so that the channel through T2 is inhibited. LED D1
is off. However, if the voltage at the terminals of the battery
exceeds the voltage at the end of charging, the output of the
comparator jumps to the high level (D1 lights up), switching T2 and
short-circuiting the solar panel.With the aid of solar charge
regulator, the charge of the battery is ensured which allows us to
supply the control receiver circuit

Cameras

For remote monitoring.
You have to install droid-cam One on two mobile androids and the
other on your computer

for computer droidcam Open up a V4L2 compatible program (VLC player, Skype, Cheese, etc) and you should see DroidCam listed as a video device.

Install:-->For mobile: All you have to do is download application DroidCam from playstore
-->For computer ubuntu/lunix: Download DroidCam Linux client from the official links below:

droid-cam for linux 32-bit

droid-cam for linux 64-bit

Extract and open the result folder in terminal by selecting “Open in Terminal” from its context menu.

When the terminal opens, run the install script to make and install the client in your system:

Type in your password when it asks (no visual feedback) and hit Enter.

Once installed, you should be able to launch the client by running droidcam command in terminal.

To create a launcher shortcut, run command to create an empty configuration file:

gedit ~/.local/share/applications/droidcam.desktop

And paste below lines when the files opens and save it.

[Desktop Entry]
Version=1.0
Type=Application
Terminal=false
Name=DroidCam
Exec=droidcam
Comment=Use your Android phone as a wireless webcam or an IP Cam!
Icon=droidcam
Categories=GNOME;GTK;Video;
Name[it]=droidcam

for windows: Download and install directly from this links below:

droid-camwindows

Now you have to use droidcam

-->Launch DroidCam app in your Android device:

-->Launch DroidCam client in Ubuntu machine. Select connection mode, type in ip (if need), and click Connect.

-->Once connected, open a webcam specific app, like Cheese, in Ubuntu and select “DroidCam (v4l2loopback)” as its webcam device.

Finally you’ll see what your Android camera sees in the Cheese window. That’s it.

PCB Art work

Highly optimized PCB design using Eagle Cad is provided below. Both the PCB design for remote control, as well as solar charger is designed as small as possible. Just print these three PCBs and solder it with the electronic components required. After soldering test all the components with a multimeter.

Video :

Robot suiveur de courbe

2017-09-03T13:09:00.000-07:00

Le but de ce projet est utiliser les nouvelles technologies disponibles pour ajouter un peu de charme sur l’image pour satisfaire le spectateur. On sait bien que le domaine de l’audiovisuel se développe rapidement et la concurrence est acharnée donc on doit être à jours. De plus, les intéressés par tous qu’est produit par la caméra ont constaté qu’il y a plusieurs réalisateurs qui ont commencé à introduire ces techniques dans leurs projets et d’intéresser de plus en plus à la caméra qui joue le rôle le plus important puisqu’elle est l’interface entre le réalisateur et le spectateur.

Ce projet est constitué de deux partie, une partie informatique dans laquelle on un logiciel de traçage des courbes et de commande de robot et une partie électronique qui sera le robot ou bien le support de caméra lui-même.

On commence par le schéma synoptique que résume tout le projet dans un schéma simple et clair :

Les robots

Le Petit Larousse définit un robot comme étant un appareil automatique capable de manipuler des objets, ou d'exécuter des opérations selon un programme fixe ou modifiable.

En fait, l'image que chacun s'en fait est généralement vague, souvent un robot est défini comme un manipulateur automatique à cycles programmables.

géneralement la constutitions d'un rebot

On distingue classiquement 4 parties principales dans un robot manipulateur :

Le système mécanique articulé (S.M.A.) est un mécanisme ayant une structure plus ou moins proche de celle du bras humain. Il permet de remplacer, ou de prolonger, son action (le terme "manipulateur" exclut implicitement les robots mobiles autonomes). Son rôle est d'amener l'organe terminal dans une situation (position et orientation) donnée, selon des caractéristiques de vitesse et d'accélération données. Son architecture est une chaîne cinématique de corps, généralement rigides (ou supposés comme tels), assemblés par des liaisons appelées articulations. Sa motorisation est réalisée par des actionneurs électriques, pneumatiques ou hydrauliques qui transmettent leurs mouvements aux articulations par des systèmes appropriés.

Précisons la notion d'articulation : Une articulation lie deux corps successifs en limitant le nombre de degré de liberté de l'un par rapport à l'autre. Soit m le nombre de degré de liberté résultant, encore appelé mobilité de l'articulation. La mobilité d’une articulation est telle que :

0 ≤ m ≤ 6.

Lorsque m = 1 ; ce qui est fréquemment le cas en robotique, l'articulation est dite simple : soit rotoïde, soit prismatique.

Articulation rotoïde : Il s'agit d'une articulation de type pivot, notée R, réduisant le mouvement entre deux corps à une rotation autour d'un axe qui leur est commun. La situation relative entre les deux corps est donnée par l'angle autour de cet axe

Articulation prismatique : Il s'agit d'une articulation de type glissière, notée P, réduisant le mouvement entre deux corps à une translation le long d'un axe commun. La situation relative entre les deux corps est mesurée par la distance le long de cet axe

Pour être animé, le S.M.A. comporte des moteurs le plus souvent avec des transmissions (courroies crantées), l'ensemble constitue les actionneurs. Les actionneurs utilisent fréquemment des moteurs électriques à aimant permanent, à courant continu, à commande par l'induit (la tension n'est continue qu'en moyenne car en général l'alimentation est un hacheur de tension à fréquence élevée ; bien souvent la vitesse de régime élevée du moteur fait qu'il est suivi d'un réducteur, ce qui permet d'amplifier le couple moteur). On trouve de plus en plus de moteurs à commutation électronique (sans balais), ou, pour de petits robots, des moteurs pas à pas.

Pour les robots devant manipuler de très lourdes charges (par exemple, une pelle mécanique), les actionneurs sont le plus souvent hydrauliques, agissant en translation (vérin hydraulique) ou en rotation (moteur hydraulique).

Les actionneurs pneumatiques sont d'un usage général pour les manipulateurs à cycles (robots tout ou rien). Un manipulateur à cycles est un S.M.A. avec un nombre limité de degrés de liberté permettant une succession de mouvements contrôlés uniquement par des capteurs de fin de course réglables manuellement à la course désirée (asservissement en position difficile dû à la compressibilité de l'air).

La perception permet de gérer les relations entre le robot et son environnement. Les organes de perception sont des capteurs dits proprioceptifs lorsqu'ils mesurent l'état interne du robot (positions et vitesses des articulations) et extéroceptifs lorsqu'ils recueillent des informations sur l'environnement (détection de présence, de contact, mesure de distance, vision artificielle).

La partie commande synthétise les consignes des asservissements pilotant les actionneurs, à partir de la fonction de perception et des ordres de l'utilisateur.

S'ajoutent à cela :

- L'interface homme-machine à travers laquelle l'utilisateur programme les tâches que le robot doit exécuter,

- Le poste de travail, ou l'environnement dans lequel évolue le robot.

La robotique est une science pluridisciplinaire qui requiert, notamment, des connaissances en mécanique, automatique, électronique, électrotechnique, traitement du signal, communications, informatique.

Les générations de robot :

Des progressions s'opèrent dans tous les domaines : - Mécanique,

- Micro-informatique,

- Energétique,

- Capteurs – actionneurs.

A l'heure actuelle, on peut distinguer 3 générations de robots :

1. Le robot est passif : Il est capable d'exécuter une tâche qui peut être complexe, mais de manière répétitive, il ne doit pas y avoir de modifications intempestives de l'environnement.

L'auto-adaptativité est très faible. De nombreux robots sont encore de cette génération.

2. Le robot devient actif : Il devient capable d'avoir une image de son environnement, et donc de choisir le bon comportement (sachant que les différentes configurations ont été prévues). Le robot peut se calibrer tout seul.

3. Le robot devient « intelligent » : Le robot est capable d'établir des stratégies, ce qui fait appel à des capteurs sophistiqués, et souvent à l'intelligence artificielle.

Programmation des robots :

Classiquement, 2 étapes sont utilisées pour faire en sorte qu'un robot connaisse la tâche à exécuter.

1. L'apprentissage :

- Enregistrement dans une mémoire de la trajectoire à exécuter, sous contrôle d'un opérateur humain,

- Pantin : Structure mécanique identique à celle du robot, qui est déplacée et qui mémorise les points "pertinents",

- Syntaxeur : Un manche de pilotage (joystick) commande les déplacements de l'organe terminal,

- Boîte à boutons : Un interrupteur par actionneur.

2. La génération de trajectoires et les opérations à réaliser le long de ces trajectoires, ce qui permet de définir la tâche à réaliser : On fait appel à un logiciel qui, à partir du modèle du robot, et des trajectoires à réaliser, élabore la succession des commandes des actionneurs. Les langages de programmation les plus courants sont : WAVE, VAL (Unimate), LM (Hitachi). Nous utiliserons pour notre part les langages associés au robot Stäubli RX 90 (langage V+) et au robot FANUC ARC ou LR.

Pour notre projet on utilise le microcontrôleur PIC 16F877 a des caracteristique :

- Consommation : moins de 2mA sous 5V à 4 MHz.

- Architecture RISC : 35 instructions de durée 1 ou 2 cycles.

- Durée du cycle : Période de l'oscillateur quartz divisée par 4 soit 200 ns pour un quartz de 20 MHz.

- Deux bus distincts pour le code programme et les data.

- Code instruction : mot de 14 bits et compteur programme (PC) sur 13 bits, ce qui permet d'adresser 8 K mots (de h'0000' à h'1FFF')

- Bus DATA sur 8 bits.

- 33 Ports Entrée-Sortie bidirectionnels pouvant produire 25 mA par sortie. PORTA contient 6 bits et PORTB, PORTC et PORTD contiennent chacun d’eux 8bits et pour le PORTE, il contient 3 bits.

- 4 sources d'interruption :

- Externe par la broche partagée avec le Port B : PB0.

- Par changement d'état des bits du Port B: PB4 PB5 PB6 ou PB7.

- Par un périphérique intégré dans le chip: écriture de Data en EEPROM terminée, conversion analogique terminée, réception USART ou I2C.

- Par débordement du Timer.

- 2 Compteurs 8 bits et 1 compteur 16 bits avec pré diviseur programmable.

- Convertisseur analogique 10 bits à 8 entrées pour le 16F877.

- USART pour transmission série synchrone ou asynchrone.

- Interface I2C.

- 2 modules pour PWM avec une résolution de 10 bits.

- Interface avec un autre micro: 8 bits + 3 bits de contrôle pour R/W et CS.

- 368 Octets de RAM

- 256 Octets d'EEPROM Data.

- 8K mots de 14 bits en EEPROM Flash pour le programme (h'000' à h'1FFF').

- 1 registre de travail : W et un registre fichier : F permettant d'accéder à la RAM ou aux registres internes du PIC. Tous les deux sont des registres 8 bits.

on utilise aussi d’un moteur pas à pas

Pour le moteur pas à pas il ne y’a pas d’asservissement, c’est pourquoi le système est plus simple.

A chaque impulsion du signal de commande correspond au niveau de rotor un déplacement angulaire défini appelé « pas » ou « incrément mécanique ». Donc le moteur pas à pas transforme une impulsion électrique en une énergie mécanique.

La vitesse de rotation est fonction de la fréquence des impulsions.

Le circuit MAX232 :

La conversion des niveaux :

Les cartes électroniques à base de microcontrôleurs fonctionnent très souvent avec des niveaux TTL soit 0-5Volt, 0V pour le niveau 0 et 5Volt pour le niveau1. Brancher donc directement une ligne RS232 sur un microcontrôleur n’aurait donc aucun sens et pourrait aussi endommager le système en imposant des tensions de 25volt.

Pour rendre compatible une ligne RS232 avec une carte de ce type il existe un composant très simple d’utilisation que nous allons étudier : le max232. En regardant son schéma interne ci-dessous, nous constatons directement qu’il est premièrement doté d’un convertisseur de tension, au travers des capacités C1 et C3 il génère une tension de 10Volt depuis les 5Volt (doubleur de tension), et au moyen des capacités C2 et C4 il génère une tension de -10Volt a partir de la tension de 10Volt. Il est bien sur évident que la puce est munie de tout un système, avec un oscillateur, des diodes et ... afin d’intégré ce convertisseur DC-DC. Il existe une version de cette puce, le max233, où les capacités sont intégrées directement dedans, mais nous ne rentrerons pas dans ce détail. La valeur des capacités va dépendre de la version de la puce :

Le circuit L298N :

Gestion d'un afficheur à cristaux liquides (LCD) :

L'utilisation d'un afficheur à cristaux liquides ou LCD est assez courante sur les systèmes embarqués. C'est un écran de faible dimension employé pour informer l'utilisateur sur l'état du système ou pour afficher les mesures effectuées par différents capteurs.

Il existe un standard très populaire qui permet de gérer les communications avec la grande majorité des modèles d'afficheurs LCD quel que soit le fabricant. Ce standard est connu sous le nom HD44780U. Ce nom correspond au contrôleur qui reçoit les données du microcontrôleur et qui les communique directement avec l'afficheur à cristaux liquides.

La standard HD44780U utilise 3 signaux de contrôle ainsi que 4 ou 8 lignes d'entrée-sortie pour le bus de données. L'utilisateur peut choisir si l'afficheur à cristaux liquides doit fonctionner avec un bus de données de 4 bits ou un bus de données de 8 bits. Si un bus de données de 4 bits est utilisé l'afficheur LCD utilise un total de 7 lignes (3 signaux de contrôle plus les 4 lignes pour le bus de données). Si un bus de données de 8 bits est utilisé l'afficheur LCD utilise un total de 11 lignes (3 signaux de contrôle plus les 8 lignes pour le bus de données).

Les trois signaux de contrôle sont appelés : EN, RS et RW.

EN, enable :

Le signal enable est utilisé pour indiquer à l'afficheur à cristaux liquides qu'on va lui envoyer des données. Pour envoyer des données à l'afficheur, le programme doit s'assurer que le signal est au niveau bas (0) avant de faire évoluer les deux autres signaux de contrôle et de placer des données sur le bus de données. Quand l'ensemble des autres lignes sont correctement positionnées,

le signal EN doit être placé au niveau haut (1) et il faut attendre un temps minimum requis par le composant (ce temps varie d'un afficheur à l'autre) avant de le placer au niveau bas (0) à nouveau.

RS, register select :

Le signal register select est utilisé pour distinguer les instructions de commande des données à afficher. Si on place RS au niveau bas (0), les données sont traitées comme une commande ou instruction spéciale (effacer l'écran, positionner le curseur de position, etc.). Si on place RS au niveau haut (1), les données envoyées sont des caractères que l'écran doit afficher.

RW, read/write :

Le signal read/write est utilisé pour distinguer si les informations sur le bus de données sont lues ou écrites. Si on place le signal RW au niveau haut (1), le programme interroge l'afficheur à cristaux liquides sur son état (Get LCD status). Dans tous les autres cas des commandes sont écrites. Ainsi, le signal RW sera presque toujours au niveau bas.

Outils de développement et de simulation

Mikropascal :

C’est un langage de programmation orienté vers la programmation de quelques composants développés tels que les microcontrôleurs, les microprocesseurs, les DSP.

Isis :

Isis est simulateur des cartes électroniques intégré dans le logiciel proteus de l’entreprise LabcenterElectrnics. L’utilisation de ce logiciel est simple grâce à l’interface graphique qui rend claires tous les commandes.

La bibliothèque est géante et contient presque tous les composants électroniques connus. De plus la recherche et l’importation sont simples.

Isis est orienté vers les électroniciens débutants, ainsi que les développeurs et les professionnels.

Ares :

C’est un outil de conception des cartes électroniques imprimées, intégré dans le logiciel proteus de l’entreprise LabcenterElectronics. Apres avoir écrit un programme et le compiler, on peut faire la simulation de la carte à l’aide de Isis. Lorsque on constate que le programme fonctionne correctement et que les composants sont bien placés, on peut donc passer à la conception de la carte imprimée sous Ares.

Parmis les lescaracteristiques de ce logiciel on peut siter qu’il permet l’utilisateur d’ajouter n’importe quelle empreinte qui n’existe pas dans la bibliothèque. De plus, l’utilisation de ce logiciel est simple et facile.

Réalisation et test

Les composants sont:

- 1 microcontroleur 16f877.

- 1 afficheur lcd.

- 1circuit Max232.

- 2 circuits L298N.

- 1 quartz.

- 2 capacités céramiques de 22pF, 2 autres de 100nF.

- 5 capacités chimiques de 470uF.

- 1 Potentiomètre de 10kΩ.

- 16 diodes.

- 6 résistances.

- 1 diode led.

- 5 boutons.

- 1 connecteur HDB9.

alors le Typon de la carte :

La carte en 3 dimensions :

Partie Informatique :

Dans un repère orthonormé, chaque point est défini par son abscisse et son ordonnée. On peut calculer donc le module et l’argument de chaque point ainsi que la distance entre deux points et l’angle faite par la droite (P1P2) et l’axe OX par ces deux formules :

Arg= arctg[(y2-y1)/(x2-x1)].

Mod=√[(x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)].

Le module mod traduit la distance parcourue par le robot pour qu’il se déplace de point P1 pour arriver au point P2. L’argument arg est l’angle de déviation pour que le robot s’oriente vert le point destinataire.

Exemple :

Soit P1(10,10) et P2(50,60) : le robot initialement est dirigé vers le sens des x croissant : donc il fait un angle α=0 avec l’axe OX.

Mod=√[(50-10)*(50-10) + (60-10)*(60-10)]=64mm.

Arg= arctg[(60-10)/(50-10)]=51.34°.

La distance mod se traduit par un tel nombre des pas exécuté par les deux moteurs ensemble.

L’angle arg se traduit par un fonctionnement d’un moteur tout en gardant l’autre moteur fixe.

51.34x3,14=161.2.

161.2/5,2=31 pas : l’un parmi les deux moteurs doit tourner 31 pas et l’autre doit rester fixe.

64/5.2=12.3 soit 12 pas : ensuite le deux moteurs doivent se tourner de 12 pas de la meme vitesse.

La partie Mécanique :

D’après le schéma on a :

- La distance entre les centres de gravité de deux roues est A=180mm.

- Le rayon de roue est R=40mm.

- Le diamètre d’une roue est D=2xΠxR=251mm.

- Le nombre des pas par tour de nos moteurs est 24 pas/tour ou bien 48 demi-pas par tour.

- La distance par pas est : 251/48=5.2mm/pas.

- On fixe la roue M1et on tourne la roue M2 360 degrés : la distance parcourue par M2 est 2xΠxA=1131mm.

- La distance par degré est 1131/360=3,14mm/dég. Donc pour que le robot tourne d’un dégré il faut qu’une roue reste stable et l’autre se deplace de 3,14mm

-->Pour telecharger le code et le shéma ISIS CLIQUER SUR LIEN

-->Pour télecharger le carte de routage CLIQUER SUR LIEN

-->pour telecharger la commande CLIQUER SUR LIEN

What is IoT ?

2017-04-04T13:36:00.000-07:00

The Internet of Things (IoT) is a system of interrelated computing devices, mechanical and digital machines, objects, animals or people that are provided with unique identifiers and the ability to transfer data over a network without requiring human-to-human or human-to-computer interaction.

Where is IoT?

IOT It’s everywhere

Smart Home: The smart home is likely the most popular IoT application at the moment because it is the one that is most affordable and readily available to consumers. From the Amazon Echo to the Nest Thermostat, there are hundreds of products on the market that users can control with their voices to make their lives more connected than ever.

Wearables: Wearables have experienced a explosive demand in markets all over the world. Companies like Google, Samsung have invested heavily in building such devices. But, how do they work?
Wearable devices are installed with sensors and softwares which collect data and information about the users. This data is later pre-processed to extract essential insights about user.

These devices broadly cover fitness, health and entertainment requirements. The pre-requisite from internet of things technology for wearable applications is to be highly energy efficient or ultra-low power and small sized.

Connected Car: These vehicles are equipped with Internet access and can share that access with others, just like connecting to a wireless network in a home or office. More vehicles are starting to come equipped with this functionality, so prepare to see more apps included in future cars.

Industrial Internet:Industrial Internet is the new buzz in the industrial sector, also termed as Industrial Internet of Things ( IIoT ). It is empowering industrial engineering with sensors, software and big data analytics to create brilliant machines.

Smart Cities: The IoT has the potential to transform entire cities by solving real problems citizens face each day. With the proper connections and data, the Internet of Things can solve traffic congestion issues and reduce noise, crime, and pollution.

IoT in agriculture:With the continous increase in world’s population, demand for food supply is extremely raised. Governments are helping farmers to use advanced techniques and research to increase food production. Smart farming is one of the fastest growing field in IoT.

Energy Engagement: Power grids of the future will not only be smart enough but also highly reliable. Smart grid concept is becoming very popular all over world.

The basic idea behind the smart grids is to collect data in an automated fashion and analyze the behavior or electricity consumers and suppliers for improving efficiency as well as economics of electricity use.

The Smart Internet of things School

The IoT Market:
As of 2013, 9.1 billion IoT units
Expected to grow to 28.1 billion IoT devices by 2020

Revenue growth from $1.9 trillion in 2013 to $7.1 trillion in 2020
Why be concerned about IoT?
It’s just another computer, right?
-All of the same issues we have with access control, vulnerability management, patching,
monitoring, etc.
-Imagine your network with 1,000,000 more devices
-Any compromised device is a foothold on the network
Attacking IoT:
Default, weak, and hardcoded credentials
Difficult to update firmware and OS
Lack of vendor support for repairing vulnerabilities
Vulnerable web interfaces (SQL injection, XSS)
Coding errors (buffer overflow)
Clear text protocols and unnecessary open ports DoS / DDoS

Physical theft and tampering

The Future:

Software:

RIOT OS: is an operating system for Internet of Things (IoT) devices. It is based on a microkernel and designed for: energy efficiency, hardware independent development, a high degree of modularity.

Thingsquare Mist: brings resilient wireless mesh networking and true Internet-connectivity to the Internet of Things. The Thingsquare Mist open source firmware is exceptionally lightweight, battle-proven, and works with multiple microcontrollers with a range of radios.

Sapphire os: is a full stack, open source, low power wireless platform from the hardware pin up to the web and beyond. Sapphire combines flexible low cost hardware, a lightweight but powerful embedded operating system, and network connectivity tools to help you connect anything to everything.

Nimbits: is a collection of software for recording time series data to the cloud.

When your systems send new numeric, json, or xml data into a Nimbits Data Point using the REST web services, new values can trigger cascading calculations, alerts, statistics and more.

Use Nimbits Server as a backend to your applications, generating charts and data visualisations with javascript using the public cloud, or download and build your own infrastructure.

ThingSpeak: is an open source “Internet of Things” application and API to store and retrieve data from things using HTTP over the Internet or via a Local Area Network. With ThingSpeak, you can create sensor logging applications, location tracking applications, and a social network of things with status updates.

All joyn: An open source project which provides a universal software framework and core set of system services that enable interoperability among connected products and software applications across manufacturers to create dynamic proximal networks so that products – for the home, automotive and the enterprise – can interact in new, exciting and useful ways that will engage and delight users.

openAlerts: is free, open source software to remotely monitor and control sensors over IP networks. With openAlerts you can configure, control and monitor sensors from a web browser, receive e-mail and text message alerts, and trigger control commands based on sensor conditions.

The IoT Toolkit: is an Open Source project to develop a set of tools for building multi-protocol Internet of Things Gateways and Service gateways that enable horizontal co-operation between multiple different protocols and cloud services. The project consists of the Smart Object API, gateway service, and related tools.

Conception et maintenance d’une machine Komax

2016-10-10T14:17:00.000-07:00

1-Présentation de la machine

La machine Komax rend possible l’usinage entièrement automatique de deux câbles individuels au mètre avec torsadage consécutif et de nombreux contrôles de qualité intégrés. La structure modulaire du système garantit une flexibilité maximale. Quatre stations d’usinage au début du câble et deux à la fin du câble offrent d’innombrables possibilités d’usinage. Cette machine admet un rendement élevé.

2-Composition de la machine

2.1-Unité de dressage

Permet le redressement du câble. Elle est composée de rondelle de protection et disque à trous

2.2-Unité de pivotement

Dans la machine komax il existe deux unités de pivotement :

2.2.1-Unité de pivotement face 1

Fait pivoter le câble et le positionne sur les stations d’usinage face 1, détermine la longueur d’extraction sur la première face du câble, elle composé par tuyaux de guidage de câble(5),Adapteur (6),moteur d’entrainement unité de pivotement (7),moteur d’entrainement unité d’extraction( 8),pince de guidage de câble(9) et Mâchoire de pince (10)

2.2.2-Unité de pivotement face 2

Fait pivoter le câble et le positionne sur les stations d’usinage face 2, détermine la longueur d’extraction sur la deuxième face du câble, elle composé par d’entrainement unité de pivotement (7), moteur d’entrainement unité d’extraction(8) et Mâchoire de pince (10)

2.3-Tète de coupe

Coupe le câble et le dénude, sépare en outre les câbles défectueux, elle est composée par vérin et couteaux.

2.4-Passerelle de transfert

La passerelle du transfert repend les câbles de l’unité d’introduction du cable et les transmet à l’unité de torsadage, elle contient un moteur électrique et vérin.

2.5-Module de transfert face 2

Les câbles sont remis par un mouvement du pivotement du module de transfert de l’unité de pivotement face 2 au module de maintient face 2.contient un moteur, un vérin et deux pinces.

2.6-Module de maintien face 2

Le module de maintien maintient le câble pendant l’operateur de torsadage.

2.7-Unité de torsagage

L’unité de torsadage exécute, via des axes asservi dynamiques, le mouvement de rotation est longitudinal pour le torsadage .Un coulisseau de protection empêche l’endommagement des pièces de butée pendant le torsadage.

2.8-Commande

2.8.1-Armoire de commande 1

C’est l’armoire de la machine de base, contient l’alimentation électrique toute la commande et la pc machine.

2.8.2-Armoire de commande 2

C’est l’armoire de l’unité de torsadage, contient un transformateur, cloque réseau combinatoire 24 VCC et commande détecteur de force de torsadage.

3-Fonctionnement de la machine

3.1-Description du Fonctionnement :

A l’état initial, le capteur de présence des fils l10 sera actionné .Une action sur le bouton de mise en marche dcy engendre successivement les opérations suivantes :

-le dressage des fils par l’unité de dressage puis le triage des fils par rotation du moteur M4 jusqu'à l’action sur le capteur l12.

-la sortie de la tige du vérin C1 pour faire la découpage des fils jusqu'à l’action sur le capteur s01 .

-la rentrée de la tige du vérin C1 jusqu'à l’action sur le capteur s00.

- la sortie de la tige du vérin C1, l’action sur le capteur s01 entraine à la fois :

*la dénudage des fils côté A par la rentrée de la tige de vérin C2,(action sur le capteur s02), puis la sortie de la tige de vérin(action sur le capteur s03).

*la dénudage des fils coté B par la rentrée de la tige de vérin C3,(action sur le capteur s04), puis la sortie de la tige de vérin(action sur le capteur s05).

-la rentrée de la tige du vérin C1, l’action sur le capteur s00 entraine à la fois :

*le pivotâge des câble côté A par la rotation du moteur M2 jusqu'à l’action sur le capteur l13 .sortie de la tige du vérin C4 (action sur le capteur s07) pour faire la sertissage des fils côté A par des cosses puis la rentrée de la tige du vérin (action sur le capteur s06).la rotation de moteur M4 pour faire la transformation des fils côté A vers l’unité de torsadage jusqu'à l’action sur le capteur l11.la sortie de la tige du vérin C7 pour faire la serrage des fils côté A par l’unité de torsadage ,le capteur s13 est actionnée.

*le pivotâge des câble côté B par la rotation du moteur M3 jusqu'à l’action sur le capteur l19 .la sortie de la tige du vérin C5 (action sur le capteur s09) pour faire la sertissage des fils côté B par des cosses puis la rentrée de la tige du vérin (action sur le capteur s08).la sortie de la tige du vérin C6 (action sur le capteur s11) pour faire le sertissage des fils côté B par des tulles .la rentrée de la tige du vérin (action sur le capteur s10). la rotation de moteur M5 pour faire la transformation des fils côté B vers module du maintien jusqu'à l’action sur le capteur l15.la sortie de la tige du vérin C8 pour faire la serrage des fils côté B par le module du maintien ,le capteur s13 est actionnée.

- le déplacement de l’unité du torsadage à droite par rotation du moteur dans les sens avant jusqu’a l’action sur le capteur l16.

- le torsadage des fils par rotation du moteur M7, l’action sur le capteur l18 entraine à la fois :

*la rentrée de la tige du vérin C7 pour faire le desserrage des fils côté A jusqu'à l’action sur le capteur s12.

*la rentrée de la tige du vérin C8 pour faire le desserrage des fils coté B jusqu'à l’action sur le capteur s14

3.2-Tableau d’indentification et tableaux d’affectation

3.2.1-tableaux d’identification

Actions	Actionneurs	Préactionneur	Capteurs
		Présence fils	l10
Triage des fils	Moteur M1	Contacteur KM1	l12
Découpage des fils	Vérin à double effet C1	Distributeur 5/2 14M1 Distributeur 5/2 12M1	s01 s00
Dénudage des fils côté A	Vérin à double effet C2	Distributeur 5/2 14M2 Distributeur 5/2 12M2	s02 s03
Dénudage des fils côté B	Vérin à double effet C3	Distributeur 5/2 14M3 Distributeur 5/2 12M3	s04 s05
Pivotage des fils côté A vers les stations d’usinage face A	Moteur M2	Contacteur KM2	l13
Sertissage des fils côté A par des cosses	Vérin à double effet C4	Distributeur 5/2 14M4 Distributeur 5/2 12M4	s06 s07
Pivotage des fils côté B vers les stations d’usinage face B	Moteur M3	Contacteur KM3	l19
Sertissage des fils côté B par des cosses	Vérin à double effet C5	Distributeur 5/2 14M5 Distributeur 5/2 12M5	s09 s08
Sertissage des fils côté B par des tulles	Vérin à double effet C6	Distributeur 5/2 14M6 Distributeur 5/2 12M6	s11 s10
Transformation des fils côté A vers l’unité de torsadage	Moteur M4	Contacteur KM4	l14
Serrage/Desserrage des fils côté A par l’unité de torsadage	Vérin à double effet C7	Distributeur 5/2 14M7 Distributeur 5/2 12M7	s13 s12
Transformation des fils côté B vers le module de maintien	Moteur M5	Contacteur KM5	l15
Serrage/desserrage des fils côté B par le module de maintien	Vérin à double effet C8	Distributeur 5/2 14M1 Distributeur 5/2 12M1	s15 s14
Déplacement l’unité de torsadage	Moteur M6	Contacteur KM61 (sens avant) Contacteur KM62 (sens arrière)	l16 l17
Torsadage des fils	Moteur M7	Contacteur KM7	l18

3.2.1-tableaux d’affectation

Affectation des entrées				Affectation des sorties
dcy	I0.2	s03	I1.3	14M1	Q0.4	14M7	M2.6
l10	I0.0	s04	I1.4	12M1	Q1.3	12M7	M3.5
l12	I0.2	s05	I1.5	14M2	M0.6	14M8	M3.0
l13	I0.3	s06	I1.6	12M2	M0.5	12M8	M3.7
l14	I0.4	s07	I1.7	14M3	M1.1	KM1	M0.1
l15	I0.5	s08	I1.8	12M3	M1.0	KM2	M1.4
l16	I0.6	s09	I1.9	14M4	M1.5	KM3	M1.7
l17	I3.0	s10	I2.0	12M4	M1.6	KM4	M2.5
l18	I0.7	s11	I2.1	14M5	M2.0	KM5	M2.7
l19	I3.1	s12	I2.2	12M5	M2.1	KM61	M3.3
s00	I1.0	s13	I2.3	14M6	M2.3	KM62	M4.1
s01	I1.1	s15	I2.5	12M6	M2.4	KM7	M3.4
s02	I1.2

3.3-Grafcet

.3.1-Grafcet d’un point de vue du système

3.3.2-Grafcet d’un point PC

3.3.3-Grafcet d’un point PO

4- Réglage de quelques pannes électriques de machine Komax

4.1-Encodeur

La roue d’encodeur 1 est enfoncée avec le cylindre 2 sur le câble et mesure la longueur du câble. La force de pression est la butée de fin de course de l’encodeur ont été réglés a l’usine et ne doivent pas, en règle générale, être modifiée.

En cas d’erreur de mesure de l’encodeur pour les câbles spécieux, des ajustements sont toute fois nécessaires.

Réglage de la pression des galets :

Pression : le réglage avec le vis cylindrique 3 (vissage=pression plus grande, dévissage: pression plus faible)

Réglage de la butée de fin de course :

Butée finale de l’encodeur : réglée avec la vis 4 de sorte qu’il y avait une fente d’air d’environ 0.5 mm entre la roue 1 et 5.

4.2-Détecteur

Les détecteurs sont des commutateurs électroniques sensibles fonctionnant sans contacts.

Pour que le détecteur 1 fonctionne sans erreur, la distance jusqu'à la plaquette du circuit imprimé 2 doit être d’exactement 0.5 mm .une réduction de cette distance, c’est-à-dire le contact avec la plaquette du circuit imprimé, peut détruire le détecteur, une distance trop grande entraine des erreurs des commutations.

Réglage

Desserrage du détecteur, le remplacement le cas échéant et le réglage de la distance de commutation avec un calibre de feuille 0.5 mm, puis le resserrage du détecteur.

4.3-Fusibles électriques

En cas de surcharge de la puissance admissible du courant dans un circuit électrique, l’alimentation électrique est interrompue par les fusibles pour protéger l’homme et la machine.

4.3.1-Types de Fusible

Coupe-circuits automatiques

Ils peuvent être réactivés après avoir été déclenchés .si le coupe-circuit automatique est déclenché par un surcharge, il ne peut être réactivé que lorsque le dispositif du déclanchement bimétallique est refroidi.

Pour remettre en service, il faire le basculement du levier vers le haut.

Fusibles fins

En cas de surcharge, ils fondent et doivent être échangés .retirage le fusible du support , vérification si le fil est fondu et remplacement par un fusible exactement de même type et de la même valeur.

4.3.2-Liste des Fusibles