• Le capteur de mouvement : Xiaomi Mi Motion Sensor
• L’ampoule Led compatible Aqara

La prise en compte de ces deux produit se fait très facilement en utilisant l’intégration ZHA.

Création de l’automatisation

Dans Home Assistant, pour créer une automatisation, il y a plusieurs solutions :

• directement dans le fichier automations.yaml, cette méthode n’est pas la plus simple pour des néophytes, à l’heure de la rédaction de cet article, j’en suis un, plus j’apprends et plus je me rends compte que je ne sais rien.
• une méthode guidée qui est bien plus simple que la précédente mais demande encore un peu plus de réflexion
• l’utilisation de blueprint, en quelque sorte, il s’agit d’un calque ou modèle sur lequel, tu vas intégrer tes entités, éléments… Je vois l’informatique comme un moyen de se simplifier la vie.

Pour faire simple et le plus instructif possible, je vais partir sur l’utilisation d’un Blueprint.

Tu pourras trouver des Blueprints sur internet, par exemple sur le forum de la communauté Home Assistant.

Revenons à notre projet d’allumer la lumière de la cuisine quand une présence y est détecté.

Commences par ajouter une automatisation en cliquant sur « Ajouter une automatisation » :

Dans le popup qui s’affiche, tu cliques sur « Sélectionner un Blueprint » et tu choisis « Motion-activated Light » :

Ensuite, tu saisies le nom et une description (enfin, ce n’est pas obligé) :

Puis tu choisis :

• ton capteur
• l’appareil, zone ou entité que tu veux allumer
• Le temps pendant lequel tu souhaites que la lumière reste allumée

Puis tu sauvegardes. Ta première automatisation est prête et activée.

Conclusion

Rien de très transcendant à ce niveau, cela peut être très frustrant. Pour avoir appris plusieurs choses seul sur le net, il ne faut jamais se lancer trop vite et commencer par des bases.

L’article Home Assistant, créer sa première automatisation est apparu en premier sur La programmation sur le web.

Il s’agit d’un projet que tu pourras facilement mener à terme même avec un niveau débutant.

Rôle du robot éviteur d’obstacle

Le principe de ce robot est simple: éviter les obstacles. Pour cela, on va utiliser un capteur à ultra-sons HC-SR04, très couramment utilisé grâce à un prix accessible.

Lorsqu’un obstacle sera à moins de 20 cm, le robot tournera et continuera à avancer si le champ est libre.

Voici un exemple de robot éviteur :

Et une autre vidéo avec un robot un peu plus évoluer :

Matériels nécessaires

Pour la réalisation de ce robot, tu vas avoir besoin :

• 1 Raspberry Pi 4 (Amazon) ou Pi 3 (Amazon), voir des modèles en-dessous.
• 1 chassis avec deux moteurs et un boitier batterie, voir le lien Amazon.
• 1 module L298N pour le contrôle des moteurs et ne pas grillé ta carte Arduino, vers le lien Amazon.
• différents fils pour la connexion, voir le lien Amazon.
• 1 capteur à ultra-sons HC-SR04, voir le lien Amazon.
• 1 planche à pain (pas de boulanger) mais pour le branchement du capteur qui te sera toujours utile, pour ma part, j’en ai plusieurs de différentes tailles, voir le lien Amazon.

Avec tout cela, tu devrais avoir ce qu’il te faut. Si tu es amené à faire à faire d’autres projets, je t’invite à éviter les petits lots. Les liens Amazon me permettent de gagner quelques euros dans le mois (pas plus) qui me paie mon nom de domaine et l’hébergement du site.

Montage du robot éviteur d’obstacles

Afin de réaliser ce robot, tu vas devoir assembler les différents éléments.

Les moteurs

Il s’agit de la partie la plus importante de cet article. En effet, vous ne devez surtout pas connecter les moteurs directement sur le Raspberry au risque de détruire votre jouet favoris. L’intensité demandée par les moteurs est bien supérieurs à celle que le Pi peut fournir.

Tu passeras donc par le module L298N dont vous pouvez suivre ce lien pour en apprendre plus.

Pour ce qui est du câblage (le schéma provient de l’excellent site dont le lien est en bas de l’article) :

Pour ce qui est du câblage :

• Broche +12 du L298N: Borne positive de l’alimentation des moteurs (12 V est un maximum).
• Broche GND du L298N: Borne négative de l’alimentation des moteurs et une broche GND du Raspberry Pi.
• OUT1 et OUT2 du L298N branchées à un des moteurs.
• OUT3 et OUT4 du L298N branchées à l’autre moteur
• ENA du L298N broche BCM 25 (BOARD 22) du Raspberry Pi
• IN1 du L298N  broche BCM 23 (BOARD 16) du Raspberry Pi
• IN2 du L298N broche BCM 12 (BOARD 18) du Raspberry Pi
• IN3 du L298N broche BCM 10 (BOARD 19) du Raspberry Pi
• IN4 du L298N broche BCM 9 (BOARD 21) du Raspberry Pi
• ENB du L298N broche BCM 11 (BOARD 23) du Raspberry Pi

Le capteur à ultra-sons HC-SR04

Aucune difficulté du côté du capteur, seulement une réelle attention à porter sur la connexion du capteur sur le Raspberry. Le Raspberry accepte des tensions de 3,3V en entrée (information en conclusion de cet article), le capteur fournira une tension de 5V, un diviseur de tension est mis en place pour ne pas abîmé le Pi :

Pour ce qui est du câblage :

• La broche Vcc du HC-SR04 est branchée à une sortie 5 V (broche numéro 2) du Raspberry Pi.
• La broche Trig du HC-SR04 est branchée à la broche 8 (GPIO 14) du Raspberry Pi 
• La broche Echo du HC-SR04 est branchée à la broche 10 (GPIO 15) du Raspberry Pi, par l’entremise du diviseur de tension schématisé ci-dessus.
• La broche Gnd du HC-SR04 est branchée à une des broches Gnd du Raspberry Pi (la broche 25, par exemple)

Alimentation

Pour ce qui est l’alimentation, différencies bien l’alimentation du Raspberry, tu peux choisir une batterie externe comme celle-ci sur Amazon. L’avantage de celle-ci est que l’adaptateur fera qu’elle sera compatible pour le Pi 3 et Pi 4.

Pour les moteurs, si tu as opté pour le chassis que je t’ai proposé au-dessus, le porte-batterie fera l’affaire (en fonction de la tension nécessaire pour les moteurs.

Programmation Raspberry

Le programme permettra au Pi d’avancer tant qu’il n’y a pas d’obstacle à moins de 20 cm, la mesure est faite par le capteur (voir les détails d’utilisation du capteur sur cette page).

#!/usr/bin/env python
# -*- coding: latin-1 -*-

'''
Robot éviteur d'obstacle basé sur le Raspberry Pi et un HC-SR04.

Pour plus d'infos:

https://electroniqueamateur.blogspot.com/2020/04/robot-eviteur-dobstacles-version.html

'''

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BOARD)

# définition des broches GPIO

Moteur1A = 16      ## premiere sortie du premier moteur, pin 16
Moteur1B = 18      ## deuxieme sortie de premier moteur, pin 18
Moteur1E = 22      ## enable du premier moteur, pin 22

Moteur2A = 19      ## premiere sortie du deuxieme moteur, pin 19
Moteur2B = 21      ## deuxieme sortie de deuxieme moteur, pin 21
Moteur2E = 23      ## enable du deuxieme moteur, pin 23

trigPin = 8        ## entrée trig du HC-SR04 branchée à la broche 8 (GPIO 14) du Raspi
echoPin = 10       ## sortie echo du HC-SR04 branchée à la broche 10 (GPIO 15) du Raspi

# 6 broches sont des sorties
GPIO.setup(Moteur1A,GPIO.OUT)  
GPIO.setup(Moteur1B,GPIO.OUT)
GPIO.setup(Moteur1E,GPIO.OUT)
GPIO.setup(Moteur2A,GPIO.OUT) 
GPIO.setup(Moteur2B,GPIO.OUT)
GPIO.setup(Moteur2E,GPIO.OUT)
GPIO.setup(trigPin,GPIO.OUT)

# 1 broche est une entrée
GPIO.setup(echoPin,GPIO.IN)
GPIO.output(trigPin, False)

while True:

# vérifier si un obstacle est en vue

    GPIO.output(trigPin, True)     ## on envoie une brève impulsion sur la pin Trig
    time.sleep(0.00001)
    GPIO.output(trigPin, False)

    while GPIO.input(echoPin)==0:  ## émission de l'ultrason
        debutImpulsion = time.time()

    while GPIO.input(echoPin)==1:   ## retour de l'écho
        finImpulsion = time.time()

    distance = (finImpulsion - debutImpulsion) * 340 * 100 / 2  ## car vitesse du son = 340 m/s

    if distance > 20:
        # pas d'obstacle: on avance
        GPIO.output(Moteur1A,GPIO.HIGH)
        GPIO.output(Moteur1B,GPIO.LOW)
        GPIO.output(Moteur1E,GPIO.HIGH)
        GPIO.output(Moteur2A,GPIO.HIGH)
        GPIO.output(Moteur2B,GPIO.LOW)
        GPIO.output(Moteur2E,GPIO.HIGH)
    else:
        # obstacle détecté: on tourne sur place
        GPIO.output(Moteur1A,GPIO.LOW)
        GPIO.output(Moteur1B,GPIO.HIGH)
        GPIO.output(Moteur1E,GPIO.HIGH)
        GPIO.output(Moteur2A,GPIO.HIGH)
        GPIO.output(Moteur2B,GPIO.LOW)
        GPIO.output(Moteur2E,GPIO.HIGH)

# on attend un peu avant de vérifier à nouveau
    time.sleep(.5)

Conclusion

Vous voici avec un beau robot qui évitera les obstacles, bien entendu ce projet a un but pédagogique, il te permettra d’appréhender la robotique sur le Raspberry.

Il faudra faire attention aux tensions du Raspberry qui en entrée accepte 3.3V et pas 5V au risque de détruire votre Pi.

Ce tutoriel a été vu pour la première fois sur electroniqueamateur.blogspot.com.

L’article Raspberry, un robot éviteur d’obstacles est apparu en premier sur La programmation sur le web.

Dans ce sens, la réalisation d’un robot suiveur est une première étape et ne nécessitera que peu de connaissance, ce tuto est donc destiné à des novices.

Rôle du robot suiveur

Ce robot suit un itinéraire tracé au sol. Le principe est de disposer une ligne noir sur un sol clair. Les capteurs des robots détecte cette ligne et la suive.

Voici un exemple de robot suiveur :

Ce robot est bien plus pédagogique qu’utile quoi que des systèmes similaires dans des hangars peuvent permettre de transporter des cartons d’un point A à un point B, voir la seconde vidéo :

Matériels nécessaires

Pour la réalisation de ce robot (pas celui des vidéos), tu vas avoir besoin :

• 2 moteurs à courant continu 5V avec un réducteur afin de ne pas faire une sortie de piste, vers le lien Amazon.
• 1 module L298N pour le contrôle des moteurs et ne pas grillé ta carte Arduino, vers le lien Amazon.
• 1 carte Arduino UNO, vers le lien Amazon.
• 1 boitier de pile, voir le lien Amazon.
• 2 led blanche, voir le lien Amazon.
• 2 photo résistance, voir le lien Amazon.
• des résistances, voir le lien Amazon.
• 1 carte de prototypage, voir le lien Amazon.
• différents fils pour la connexion, voir le lien Amazon.
• 1 chassis, le modèle présenté sur le lien possède le boitier pour batterie ainsi que des moteurs, ceux-là risque d’être bien trop rapide pour notre projet mais pourront être réutilisés, voir le lien Amazon.

Avec tout cela, tu devrais avoir ce qu’il te faut. Si tu es amené à faire à faire d’autres projets, je t’invite à éviter les petits lots. Les liens Amazon me permettent de gagner quelques euros dans le mois (pas plus) qui me paie mon nom de domaine et l’hébergement du site.

Montage du robot suiveur

Afin de réaliser un robot suiveur, nous allons devoir assembler tous les composants.

Mise au point du capteur

Le principe du capteur est relativement simple, il est composé de deux éléments.

Emission de la lumière

2 leds émettent une lumière blanche pour bien éclairer le sol, en augmentant ainsi le contraste entre le sol et la ligne blanche.

La valeur de la résistance est à déterminer en fonction de l’alimentation (ici le 5 V de l’arduino), pour déterminer facilement quelle valeur est nécessaire, je vous laisse suivre ce lien sur http://fantaisyland.fr/. tu prendras une résistance de 140 ohms.

La photo-résistance

Pour la photo-résistance, tu devras déterminer sa valeur en prenant la valeur de la résistance lorsque la surface claire est éclairée et lorsque la bande noire est éclairée. avec les valeurs obtenues :

R_fixe = (R_min + R_max )^1/2

Attention, la somme des deux résistances doit être divisée par 2. En fonction des valeurs Rmin et Rmax, ta résistance fixe variera.

Afin de ne pas polluer la valeur de la photo-résistance par l’émission de la led, tu as deux possibilités (que tu peux combiner) :

• mettre un écran entre la led et la photo-résistance
• faire en sorte que la led soit en arrière de la photo-résistance (pas derrière mais ne retrait)

Pour le câblage sur l’Arduino, la photo-résistance de gauche est connecté à l’entrée analogique A0 et celle de droite à l’entrée A1.

Les moteurs

Afin d’éviter que ton robot ne s’emballe, sa vitesse ne doit pas être trop rapide, d’où l’utilisation de moteur 5 V avec un réducteur.

Le pont L298N

Le module L298N permet de pouvoir fournir la puissance nécessaire au moteur sans tirer directement sur l’Arduino (dont les sorties ne supporterait certainement pas ce choc). L’Arduino commandera le pont qui lui fournira la puissance (pour plus de détails, voir sur ardwinner.jimdofree.com.

Concernant le câblage, le voici :

• Sorties OUT1 et OUT2 du L298N: premier moteur
• Sorties OUT3 et OUT4 du L298N: deuxième moteur
• Entrées +12 V et GND du L298N: alimentation des moteurs
• Broche ENA du L298N: broche 9 de l’Arduino
• Broche IN1 du L298N: broche 3 de l’Arduino
• Broche IN2 du L298N: broche 4 de l’Arduino
• Broche IN3 du L298N: broche 5 de l’Arduino
• Broche IN4 de L298N: broche 6 de l’Arduino
• Broche ENB du L298N: broche 10 de l’Arduino

Alimentation

Comme je l’ai dit tout de suite, l’Arduino ne peut pas fournir la puissance nécessaire aux moteurs, il faut donc une alimentation externe adaptatée aux caractéristiques de vos moteurs.

Pour alimenter l’Arduino, tu peux passer par une alimentation sur le port USB ou te brancher sur l’alimentation externe des moteurs, si celle-ci est bien de 5V, attention cependant, la demande en courant des moteurs pourrait ne plus être suffisante.

Programme Arduino

Dans votre Arduino, tu vas saisir :

/*
   Robot suiveur de ligne à base d'Arduino Uno.
   
   Pus d'informations:
   https://electroniqueamateur.blogspot.com/2020/04/robot-suiveur-de-ligne-version-arduino.html

*/

// définition des broches

#define capteurGauche A0
#define capteurDroite A1

#define brocheMoteur1a 3 // Premier moteur
#define brocheMoteur1b 4 // Premier moteur
#define brocheEnable1 9 // broche enable du L298N pour le premier moteur
#define brocheMoteur2a 5 // Deuxième moteur
#define brocheMoteur2b 6 // Deuxième moteur
#define brocheEnable2 10 //  broche enable du L298N pour le deuxième moteur

const int sensibilite = 50; // écart admissible par rapport à la valeur initiale

int initialDroite; // état initial du capteur de droite
int initialGauche; // état initial du capteur de gauche

int vitesse = 600; // 0 à 1023 PWM qui contrôle la vitesse des moteurs

void setup() {

  // réglage des sorties
  pinMode(brocheMoteur1a, OUTPUT);
  pinMode(brocheMoteur1b, OUTPUT);
  pinMode(brocheEnable1, OUTPUT);
  pinMode(brocheMoteur2a, OUTPUT);
  pinMode(brocheMoteur2b, OUTPUT);
  pinMode(brocheEnable2, OUTPUT);

  // on demeure immobile pour l'instant
  digitalWrite(brocheEnable1, 0);
  digitalWrite(brocheEnable2, 0);

  // réglage en marche avant
  digitalWrite(brocheMoteur1a, HIGH);
  digitalWrite(brocheMoteur1b, LOW);
  digitalWrite(brocheMoteur2a, HIGH);
  digitalWrite(brocheMoteur2b, LOW);

  delay(2000); // on se donne le temps de placer le robot à son point de départ

  // lecture des valeurs initiales (on suppose que les capteurs sont de part et d'autre de la ligne)
  initialDroite = analogRead(capteurDroite);
  initialGauche = analogRead(capteurGauche);

}

void loop() {
  int valeurDroite, valeurGauche;

  valeurDroite = analogRead(capteurDroite);
  valeurGauche = analogRead(capteurGauche);

  if ((abs(valeurDroite - initialDroite) < sensibilite) && (abs(valeurGauche - initialGauche) < sensibilite)) {
    // on continue tout droit
    analogWrite(brocheEnable1, vitesse);
    analogWrite(brocheEnable2, vitesse);
  }
  else if ((abs(valeurDroite - initialDroite) < sensibilite) && (abs(valeurGauche - initialGauche) >= sensibilite)) {
    // on tourne à gauche
    digitalWrite(brocheEnable1, 0);
    analogWrite(brocheEnable2, vitesse);
  }

  else if ((abs(valeurDroite - initialDroite) >= sensibilite) && (abs(valeurGauche - initialGauche) < sensibilite)) {
    // on tourne à droite
    analogWrite(brocheEnable1, vitesse);
    digitalWrite(brocheEnable2, 0);
  }

  else {
    // on s'arrête
    digitalWrite(brocheEnable1, 0);
    digitalWrite(brocheEnable2, 0);
  }

  delay(100);
}

Utilisation du robot suiveur

A la mise sous tension, le robot devra être bien positionné afin qu’il prenne en mémoire les valeurs initiales.

Ce tutoriel a été vu sur l’excellent electroniqueamateur.blogspot.com.

L’article Robot suiveur de ligne, version Arduino est apparu en premier sur La programmation sur le web.