Matériel

• Carte micro SD et son adaptateur
• Raspberry pi 4 B
• Une connexion wifi ou câble ethernet

1.Installation de l'OS

• Installer Rapbian sur une raspberry depuis un PC, linux, IOS ou Windows
• Connecter la Raspberry au réseau wifi ou ethernet local

2. Pilotage de la raspberry depuis un ordinateur tiers

• Connexion en SSH (lignes de commandes)
• ou Connexion en VNC (Interface graphique)

3. Assignation d'une IP fixe

• Le tuto qui suit est librement inspiré du tutoriel de raspi.fr

• Ouvrir une interface de commande sur la Raspberry ou via le SSH ou VNC si ils sont paramétrés ;
• Entrer la commande suivante :

  • #Si la raspberry pi est connectée à votre box en ethernet 
    ip route | grep eth0 
    
    #Sinon si la pi est connectée en wifi
    ip route | grep wlan0

• Noter le retour de la commande qui doit être semblable à :

  • default via 192.168.0.1 dev wlan0 src 192.168.0.101 metric 303 
    192.168.0.0/24 dev wlan0 proto dhcp scope link src 192.168.0.101 metric 303

• Ouvrir le fichier dhcpcd.conf en utilisant la commande nano :

  •  sudo nano /etc/dhcpcd.conf 

• Remplacer le contenu par les lignes suivantes (wlan0 si wifi et eth0 si ethernet), changer les adresse IP et le /XX par les adresses renvoyés pas la commande précédente.

  • interface wlan0
    static ip_address=192.168.0.101/24
    static routers=192.168.0.1

• Quitter en enregistrant (ctrl+X puis Y et entr)
• Redémarrez la raspberry :

  • reboot

1. Avec un ordinateur sous Ubuntu

• Dans un premier temps, ne pas brancher la raspberry Pi à l'ordinateur
• Ouvrir l'interface de paramètrages des connexions réseaux

  • nm-connection-editor

• Dans l'arborescence aller sur la connexion ethernet, puis l'onglet des paramètres IPV4.
• Modifier l'item du menu déroulant sur "Partager aux autres ordinateurs"
• Enregistrer les modifications, fermer la fenètre et redémarer l'ordinateur.
• Ouvrir un terminal (ctrl+alt+T)
• Installer putty

  • sudo apt install putty

• Naviguer dans le dossier X11 se trouvant dans le dossier etc

  • cd /etc/X11

• Ouvrir et éditer le fichier "Xwrapper.config"

  • sudo nano Xwrapper.config

• Supprimer la dernière ligne et y écrire ce qui suit à la place :

  • allowed_users=anybody
    needs_root_rights=yes

• Sortir du fichier en l'enregistrant (ctrl+X puis o)
• Sur un terminal entrer :

  • cat /var/lib/misc/dnsmasq.leases

• Noter l'adresse IP qui en ressort en troisième position
• Ouvrir putty
• Dans la fenêtre qui s'affiche à coté de "host name (IP adress)" inscrire l'IP précédament relevé.
• Puis naviguer dans l'arborescence à gauche, dérouler "ssh" et cliquer sur "X11".
• Cocher la case "Enable X11 forwarding"
• Enfin, cliquer sur open,
• Une fenêtre noir s'ouvre avec un massage de sécurité, qu'il convient d'accepter ;
• Pour finir dans la fenêtre noir, entrer l'identifiant de la raspberry, ici : pi
• Puis entrer le mot de passe de la raspberry, pour nous : kosmos20
• La raspberry va se connecter en ssh à l'ordinateur.

• Pour avoir l'image de la raspberry en direct, se connecter avec le même adresse IP sur VNC viewer.
• Attention, il faut que la configuration VNC de la raspberry soit en Enable

Problèmes fréquemment rencontrés

• Connecter la raspberry en ssh ou accéder aux dossier par la carte sd sur votre ordinateur ;
• Dans la partition /boot ou en tapant :

  • cd /boot

• Ouvrir pour édition le fichier config.txt ou en ligne de commande en utilisant :

  • sudo nano config.txt

• Accéder aux deux lignes concernant le hdmi

  • #hdmi_group=1
    #hdmi_mode=2

• Décomenter ces deux ligne et au dessu en ajouter une troisième de manière à obtenir :

  • hdmi_ignore_edid=0xa5000080
    hdmi_group=2
    hdmi_mode=82

• Rebooter la raspberry en ayant débranché tout les ports hdmi de cette dernière ;
• Retenter la connexion VNC

Liens connexes

• Ce tuto est issu de cette vidéo en anglais
• Le forum qui a résolu le problème d'affichage avec VNC

1. Installer VNC server sur la raspberry pi

• Les commandes suivantes ne fonctionnent que sur raspbian, le paquet n'est pas disponible sur les distributions linux.
• Par ligne de commande directement sur la raspberry entrer :

  • sudo apt-get install realvnc-vnc-server realvnc-vnc-viewer

• Si vous utilisez déjà VNC Server ou VNC Viewer, les mêmes commandes installeront la mise à jour.
• Vérifier l'activation de VNC dans le raspi-config

  • sudo raspi-config

• Avant de pour suivre, redémarrer le système :

  • reboot

2. Créer un compte VNCserver

• Sur la raspberry pi ouvrir vnc server en cliquant sur l'icone en haut à droite ;
• En bas de la fenêtre cliquer sur "pour se connecter" ;
• Une fenêtre de connexion s'ouvre, descendre jusqu'au bloc "Get started" ;
• Dans la colonne "sign up for free real VNC account" entrer un mail qui deviendras l'identifiant du compte ;
• Renseignez les différents champs, cochez (ou pas) les cases en bas de la fenêtre, puis cliquez sur SIGN UP ;
• Un mail de vérification vous sera adressé. Cliquer dans ce mail sur "verify Email" ;
• Le server créé est gratuit mais est limité à 5 ordinateurs connectés sur un même compte ;

3. Configurer le VNC server sur le Raspberry pi

• Dans la fenêtre de VNC server, "connectivité", cliquer sur "ouvrir une session ;
• Entrer les informations du login du compte VNC ;
• Le raspberry est accessible sur le compte ;

4. Configurer le VNC sur un pc de commande

• Installer VNC viewer sur votre PC ;
• Pas besoin de VNC server, il est utile uniquement sur les machines qui seront contrôlés ;
• Ouvrir VNC viewer ;
• En haut à droite, cliquer sur "ouvrir une session" ;
• Renseigner les champs par le mail du compte et son mot de passe (cf. ci dessous) ;
• Après avoir validé, dans le cadre blanc, une fenêtre s'ouvre, elle porte un nom tel que "raspberrypi" ;
• Si la raspberry pi est allumé, avec VNC server ouvert et une connexion internet quel qu'elle soit, il sera possible de s'y connecter ;
  • Pour cela double-cliquer sur cette icone ;
  • Renseigner l'identifiant de la raspberry et son mot de passe (les même que pour le ssh) ;
  • Valider ;
  • On voit ainsi l'écran de la raspberry et il devient possible de la contrôler de n'importe où.

5. Compte VNC server KOSMOS

• login : ghe.leguen@gmail.com
• mp : KosmosOnline

Liens connexes

• Connectez vous de n’importe où à votre Raspberry Pi avec VNC CONNECT

1. Le stockage sur carte SD externe

• Le support micro SD externe est complexe à paramétrer ;
• On optera plutôt pour une clé USB voir un adaptateur USB carte micro SD ou même un disque dure ssd ;
• Le branchement sur port USB est beaucoup plus simple sur raspberry, pourquoi s'embêter avec un module branché sur les GPIO ?
• Si les stockages SD ou USB suffisent en terme de capacité de stockage, on les préférera à un disque dure qui lorsqu’il prends l'eau ne permets plus la récupération des données.

Liens connexes

• Brancher l'adaptateur micro SD sur Arduino
• infos sur l'adaptateur en thaï
• GND est branché sur le port 39, le VCC sur le port 2 (5V), MISO sur 21, MOSI sur 19, SCK sur 37 ??, CS sur 35

Moteur à courant continue

Matériel

• Raspberry Pi 4B ;
• Motor driver HAT Wav Share ;
• Fil électrique et connectiques de prototypage ;
• Batterie ou alimentation de 12v ;

1. Montage électrique de prototypage

• Monter le motor driver HAT sur les pins GPIO de la raspberry, en disposant les dominos vers l'intérieur du raspberry ;
• Brancher le moteur sur les dominos A (moins --> MA2; plus --> MA1) ;
• Brancher la batterie ou l'alimentation 12V sur les deux dominos centraux (moins --> GND ; plus --> Vin) ;

2. Essai script de démo

• Partis des drivers pythons pour Raspberry disponible sur le wiki de wave share ;
• On placera les deux fichiers "main.py" et "PCA9685.py" dans le dossier "python" de la raspberry,
  • Pour y parvenir, on peut passer par le FTP avec Filezila sur port 22 ;
  • Ou placer les fichiers sur la carte SD de la raspberry via le lecteur de carte SD ou USB d'un PC ;
• Lancer un premier essai dans le dossier python avec la commande :

  • python main.py

• Le moteur doit tourner dans un sens durant 5s, puis tourner dans l'autre sens 5s supplémentaires ;

3. Script moteur pour le KOSMOS

• Le code si-dessous est le main.py du constructeur, mais il est dépendant d'un script main (que l'on nommera dans notre projet kosmos-main.py) qui lui donnera les valeur de temps et de puissance à utiliser pour l'action ;
• Dans le dossier python de la raspberry, supprimer les drivers moteurs précédemment installés et y importer le script suivant en lui donnant le nom moteur-main.py ;

  • #!/usr/bin/python
    
    from PCA9685 import PCA9685
    import time
    import sys
    
    Dir = [
        'forward',
        'backward',
    ]
    pwm = PCA9685(0x40, debug=False)
    pwm.setPWMFreq(50)
    
    class MotorDriver():
        def __init__(self):
            self.PWMA = 0
            self.AIN1 = 1
            self.AIN2 = 2
            self.PWMB = 5
            self.BIN1 = 3
            self.BIN2 = 4
    
        def MotorRun(self, motor, index, speed):
            if speed > 100:
                return
            if(motor == 0):
                pwm.setDutycycle(self.PWMA, speed)
                if(index == Dir[0]):
                    pwm.setLevel(self.AIN1, 0)
                    pwm.setLevel(self.AIN2, 1)
                else:
                    pwm.setLevel(self.AIN1, 1)
                    pwm.setLevel(self.AIN2, 0)
     else:
                pwm.setDutycycle(self.PWMB, speed)
                if(index == Dir[0]):
                    pwm.setLevel(self.BIN1, 0)
                    pwm.setLevel(self.BIN2, 1)
                else:
                    pwm.setLevel(self.BIN1, 1)
                    pwm.setLevel(self.BIN2, 0)
    
        def MotorStop(self, motor):
            if (motor == 0):
                pwm.setDutycycle(self.PWMA, 0)
            else:
                pwm.setDutycycle(self.PWMB, 0)
    
    #verifier le nombre de parametres
    if len( sys.argv ) != 3 :
        print( "\tusage:  temps (s) vitesse(%)" )
        exit()
    
    try :
            temps = int( sys.argv[1] ) #argument 1
            vitesse =  int( sys.argv[2] ) #argument 2
    
            Motor = MotorDriver()
            print("forward ...")
            #moteur/ sens / vitesse
            Motor.MotorRun(0, 'forward', vitesse)
            print "moteur temps :%d vitesse %d" % ( temps, vitesse)
            time.sleep(temps)
            Motor.MotorStop(0)
            print("stop")
    
    except ValueError : 
       print( "pb arguments")
    #
     

Info moteur

• connecteur T Mâles et femelles

Liens connexes

• Manuel utilisateur du motor driver HAT
• Manipulation des arguments du script avec sys.argv
• Information sur le module motor driver HAT
• Manuel d'utilisateur
• Wiki

Matériel nécessaire

• Raspberry pi 4
• ESC 30 A
• Batterie lipo 3S
• Moteur Brushless F2838

1. Installer la librairie pigpio

• Installer la librairie en suivant les instructions sur le site de pigpio : http://abyz.me.uk/rpi/pigpio/download.html

  • wget https://github.com/joan2937/pigpio/archive/master.zip
    unzip master.zip
    cd pigpio-master
    make
    sudo make install

2. Faire tourner le moteur

• Brancher le data de l'esc sur le GPIO4 (07)
• Brancher la masse sur un pin ground
• Nous sommes parties du code proposé dans le tutoriel instructable
• Créer un nouveau script python que l'on nommera moteur-main.py

  •  # This program will let you test your ESC and brushless motor.
    # Make sure your battery is not connected if you are going to calibrate it at first.
    # Since you are testing your motor, I hope you don't have your propeller attached to it otherwise you are in trouble my friend...?
    # This program is made by AGT @instructable.com. DO NOT REPUBLISH THIS PROGRAM... actually the program itself is harmful                                             pssst Its not, its safe.
    
    import os     #importing os library so as to communicate with the system
    import time   #importing time library to make Rpi wait because its too impatient 
    os.system ("sudo pigpiod") #Launching GPIO library
    time.sleep(1) # As i said it is too impatient and so if this delay is removed you will get an error
    import pigpio #importing GPIO library
    
    ESC=4  #Connect the ESC in this GPIO pin 
    
    pi = pigpio.pi();
    pi.set_servo_pulsewidth(ESC, 0) 
    
    max_value = 2000 #change this if your ESC's max value is different or leave it be
    min_value = 700  #change this if your ESC's min value is different or leave it be
    print "For first time launch, select calibrate"
    print "Type the exact word for the function you want"
    print "calibrate OR manual OR control OR arm OR stop"
    
    def manual_drive(): #You will use this function to program your ESC if required
        print "You have selected manual option so give a value between 0 and you max value"    
        while True:
            inp = raw_input()
            if inp == "stop":
                stop()
                break
    	elif inp == "control":
    		control()
    		break
    	elif inp == "arm":
    		arm()
    		break	
            else:
                pi.set_servo_pulsewidth(ESC,inp)
                    
    def calibrate():   #This is the auto calibration procedure of a normal ESC
        pi.set_servo_pulsewidth(ESC, 0)
        print("Disconnect the battery and press Enter")
        inp = raw_input()
        if inp == '':
            pi.set_servo_pulsewidth(ESC, max_value)
            print("Connect the battery NOW.. you will here two beeps, then wait for a gradual falling tone then press Enter")
            inp = raw_input()
            if inp == '':            
                pi.set_servo_pulsewidth(ESC, min_value)
                print "Wierd eh! Special tone"
                time.sleep(7)
                print "Wait for it ...."
                time.sleep (5)
                print "Im working on it, DONT WORRY JUST WAIT....."
                pi.set_servo_pulsewidth(ESC, 0)
                time.sleep(2)
                print "Arming ESC now..."
                pi.set_servo_pulsewidth(ESC, min_value)
                time.sleep(1)
                print "See.... uhhhhh"
                control() # You can change this to any other function you want
                
    def control(): 
        print "I'm Starting the motor, I hope its calibrated and armed, if not restart by giving 'x'"
        time.sleep(1)
        speed = 1500    # change your speed if you want to.... it should be between 700 - 2000
        print "Controls - a to decrease speed & d to increase speed OR q to decrease a lot of speed & e to increase a lot of speed"
        while True:
            pi.set_servo_pulsewidth(ESC, speed)
            inp = raw_input()
            
            if inp == "q":
                speed -= 100    # decrementing the speed like hell
                print "speed = %d" % speed
            elif inp == "e":    
                speed += 100    # incrementing the speed like hell
                print "speed = %d" % speed
            elif inp == "d":
                speed += 10     # incrementing the speed 
                print "speed = %d" % speed
            elif inp == "a":
                speed -= 10     # decrementing the speed
                print "speed = %d" % speed
            elif inp == "stop":
                stop()          #going for the stop function
                break
            elif inp == "manual":
                manual_drive()
                break
    	elif inp == "arm":
    		arm()
    		break	
            else:
                print "WHAT DID I SAID!! Press a,q,d or e"
                
    def arm(): #This is the arming procedure of an ESC 
        print "Connect the battery and press Enter"
        inp = raw_input()    
        if inp == '':
            pi.set_servo_pulsewidth(ESC, 0)
            time.sleep(1)
            pi.set_servo_pulsewidth(ESC, max_value)
            time.sleep(1)
            pi.set_servo_pulsewidth(ESC, min_value)
            time.sleep(1)
            control() 
            
    def stop(): #This will stop every action your Pi is performing for ESC ofcourse.
        pi.set_servo_pulsewidth(ESC, 0)
        pi.stop()
    
    #This is the start of the program actually, to start the function it needs to be initialized before calling... stupid python.    
    inp = raw_input()
    if inp == "manual":
        manual_drive()
    elif inp == "calibrate":
        calibrate()
    elif inp == "arm":
        arm()
    elif inp == "control":
        control()
    elif inp == "stop":
        stop()
    else :
        print "Thank You for not following the things I'm saying... now you gotta restart the program STUPID!!

• La première fois il faut calibrer l'ECS ... il y a un procédure à suivre dans le programme python ... l'ESC fait différents bip bip ... il faut suivre le programme
• Ensuite on doit utiliser arm pour redémarrer le moteur.
• Pour l'instant on commande entre 1100 et 2000 (je ne sais pas l'unité c'est des µs ?)
• Pour la suite il faudra intégrer cette commande arm avant de lancer le moteur ...

Liens connexes

• Librairie pour générer des signaux carrées sur les GPIO
• Programmer un moteur Brushless sur raspberry pi 4

• Brancher la caméra Pi Cam HQ sur le port MIPI CSI port camera interfaces
• Activez la caméra avec la commande "sudo raspi-config". Allez au menu 6 (Enable Camera) et répondez par Yes
• Redémarrer la raspberry "reboot"
• On peut tester le bon fonctionnement de la caméra en entrant la commande suivante :

  • raspivid -o test.h264

• Cette commande Raspivid est une commande UNIX ce qui fait qu'elle est intégrable dans un script bash (.sh). Elle permet l’acquisition vidéo et accepte plusieurs arguments (détaillés dans la doc de Picamera), comme par exemple :

  • raspivid -t 5000 --raw-format yuv -r monfichier.yuv

• Il s'agit d'une commande qui lance une acquisition vidéo pendant 5000 ms (5s) au format brut .yuv dans monfichier.yuv

• Librairie Python, avec fonctions spécial Picam. On peut la télécharger avec la commande :

  • sudo apt-get install python-picamera python3-picamera

• En début de script inscrire les commandes suivantes :

  • from piamera import PiCamera
    camera= PiCamera() 

• On a essayés le script ch5listing6.py qui permet d’enregistrer un fichier image ;
• Mais on préférera utiliser la fonction "wait_recording()" que "time.sleep()" car dans la première fonction, la détection d’erreur continue à tourner ce qui est plutôt pratique ;
• Pour ne pas avoir la camera en live sur l’écran, enlever les commandes "start" et "stop_preview" ;

• En python on peut importer la librairie de commande caméra par la commande :

  • python -c "import picamera"

Transformation du fichier H264 en MP4

• Après avoir enregistré le fichier en h264, il peut être nécéssaire de faire une transformation en MP4. Pour ce on a besoin d'un logiciel "ffmpeg"

  • sudo apt install ffmpeg

• Puis on utilise le commande suivante (adapter les noms de fichiers et leur accés) :

  • ffmpeg -framerate 24 -i input.264 -c copy output.mp4

Lien connexes

• Utiliser une PICam
• Autre tuto
• Documentation
• La doc officielle
• Commander une caméra Sony avec raspberry

• Le système ILS permets sur le STAVIRO et le MICADO de démarrer et arrêter le process ;
• Sur la version KOSMOS, nous imaginons un coupe circuit blue robotics etanche pour alimenter ou non la Raspberry.
• Toutefois, il faut veiller à bien finir le script avant de couper l'alimentation du Raspberry. En effet, il faut un signal au script pour que ce dernier se termine afin qu'il enregistre les données collectées ;
• On imagine ainsi installer deux ILS sur les GPIO de la Raspberry qui permettront de démarrer le script kosmos-main.sh pour le premier, et le finir pour le second.

• Verrou Set/Reset pour alimenter/désalimenter le système, les portes NON peuvent être faites avec des transistors NMOS
  • La batterie se brancherait entre 5V et la masse, et le système en parallèle de la diode et la résistance
  • autre schéma du verrou Reset/Set, mais une résistance reste alimentée pendant l'état "off"
    • La batterie se brancherait entre 5V et la masse, et le système entre l'Emetteur d'un transistor (patte du bas) et la masse
  • Circuit électronique STAVIRO: face (gauche), arrière (milieu), schéma (droite).
  • A faire 2 ils sur 2 GPIO différents,
    • un ILS pour Rec, active la fonction enregistrement et vidéo
    • un ils pour stop et enregistrement des vidéos
    • un bouton on off pour couper le circuit.
    • Ce circuit utilise un circuit intégré dont la datasheet ici

Archive

#!/bin/bash


#temps entre deux rotations
temps_entre_rot=23
#temps rotation en secondes
temps_rot=7
#vitesse entre 1 et 100
vitesse_rotation=100
#temps_video=1200000
temps_video=5000

log=logs.txt

echo temps video $temps_video >> $log

fichier_date=`date '+%Y-%m-%d_%H-%M'`
nomfichier=ma_video_$fichier_date

#recherche le nom de la clef
clef=`ls /media/pi`

echo le fichier sera : /media/pi/$clef/$nomfichier >> $log

#lancement camera ici mettre la commande video avec un '&' à la fin pour que le script contine le temps est en ms
#raspivid -t $temps_video --raw-format yuv -r $nomfichier.yuv &
raspivid -t $temps_video -o $nomfichier.h264 & >> $log

# attendre avant le premier tour
echo attendre $temps_entre_rot >> $log
#sleep $temps_entre_rot

#rotation du moteur 40 fois
for i in `seq 1 30`
  do echo "tour de boucle $i" >> $log
  python /home/pi/python/moteur_main.py $temps_rot $vitesse_rotation >> $log
  echo attendre $temps_entre_rot >> $log
  sleep $temps_entre_rot
done

#passage sur clé usb
#cp ./$nomfichier.yuv   /media/pi/clekosmos
sudo mv ./$nomfichier.h264 /media/pi/$clef >> $log
echo enregistre sur cle usb >> $log

Archives anciens scripts

#!/bin/bash


#temps entre deux rotations
temps_entre_rot=5
#temps rotation en secondes
temps_rot=3
#vitesse entre 1 et 100
vitesse_rotation=100

temps_video=$((($temps_entre_rot*6+5+$temps_rot*6)*1000))
echo temps video $temps_video

fichier_date=`date '+%Y-%m-%d_%H-%M'`
nomfichier=ma_video_$fichier_date
nomfichier=$nomfichier.yuv
echo $nomfichier

#lancemdate '+%Y-%m-%d-%T'ent camera ici mettre la commande video avec un '&' à la fin pour que le script contine le temps est en ms
raspivid -t $temps_video --raw-format yuv -r $nomfichier &


# attendre avant le premier tour
echo attendre $temps_entre_rot
sleep $temps_entre_rot

#rotation du moteur 5 fois
for i in `seq 1 5`
  do echo "tour de boucle $i"
  python ~/python/moteur_main.py $temps_rot $vitesse_rotation
  echo attendre $temps_entre_rot
  sleep $temps_entre_rot
done
#passage sur clé usb
mv ./$nomfichier   /media/pi/EMTEC\ D250/
echo enregistre sur cle usb 

Pistes d'amélioration

• Passage sur USB : trouver une commande qui permette de passer la vidéo vers n’importe quelle clé USB

  • mv ./video_test2.h264   /media/pi/EMTEC\ D250/

• Afin de palier à un problème lié au montage on a ajouté une ligne dans le code visant à intéroger le disque dure sur le nom de la clé USB.
• Attention, il faut veiller à ne pas brancher 2 clé USB à la fois sur le Raspberry pendant l’exécution du script.

1. Premier essais

• Brancher une led avec une résistance d'une centaine d'ohm
• Connecter la masse à une masse sur la raspberry et le + sur la broche 11 (GPIO17)
• Créer un nouveau script python dans le dossier python (home/pi/python) que l'on nommera "led.py"
• Y entrer le code suivant (ce code est inspiré de celui proposé par raspberry-pi.fr) :

  • #!/usr/bin/env python3
    #-- coding: utf-8 --
    # clignotage d'une led sur le GPIO
    # argument 1 : le port (11 par defaut)
    # argument 2 : le temps (3 minutes par defaut)
    #
    # D Hanon 20 octobre 2020
    
    
    import RPi.GPIO as GPIO #Importe la bibliotheque pour contrôler les GPIOs
    import sys 
    import time #bibliotheque pour delay
    
    GPIO.setmode(GPIO.BOARD) #Definit le mode de numerotation (Board)
    GPIO.setwarnings(False) #On desactive les messages d'alerte
    
    #verifier le nombre de parametres
    if len( sys.argv ) != 3 :
    	LED = 11 # n° de port
    	total_time = 3 * 60	 
    else :
    	try :
    		LED = int( sys.argv[1] ) #argument 1 n° de port GPIO
    		total_time =  int( sys.argv[2] ) #argument 2 temps de clignotage.
    	
    	except ValueError : 
    		print( "pb arguments")
    
    LED = 11 #Definit le numero du port GPIO qui alimente la led
    
    GPIO.setup(LED, GPIO.OUT) #Active le controle du GPIO
    
    cur_time = 0
    time_step = 0.5
    while cur_time < total_time :
    	if GPIO.input(LED) : 
        		GPIO.output(LED, GPIO.LOW)
    	else :
        		GPIO.output(LED, GPIO.HIGH)
    	time.sleep(time_step)
    	cur_time=cur_time+time_step
    
    GPIO.output(LED, GPIO.LOW)

• Ce code permet uniquement de faire clignoter une led pendant un temps définis

Liens connexes

• Piloter un LED avec une raspberry pi

1. Branchement du bouton poussoir étanche

• Brancher le bouton poussoir comme suit :

Liens connexes

• Tutoriel raspberry pour utiliser un bouton poussoir

• Capteur de pression

• Noir --> GND
• Rouge --> 3,3v
• Vert --> SL1
• Blanc --> SDA1

• Sur la commande de la raspberry, installer le SMbus :

  • sudo apt-get install python-smbus

• Télécharger le répertoire en saisissant la commande suivante

  • git clone https://github.com/bluerobotics/ms5837-python

• Cette commande télécharge le ms5837, ce dossier se trouve 2 programmes pythons ;
• Accéder au menu de configuration avec la commande :

  • sudo raspi-config

• Un menu déroulant s'ouvre, choisir Interfacing option
• Activer le P5 I2C
• Toujours sur raspi-config, dans le cas d'une connexion en ssh, activer l'accès en ligne en choisissant P8 Remote GPIO
• Quitter cette fenêtre en accédant au bouton "back" puis "finish" à l'aide de la touche tab puis entr ;
• Copier /coller le fichier example.py dans le dossier "python" ;

  • sudo cp home/pi/example.py home/pi/python/example.py

• Changer les droits d'auteur

  • chmod a+xwr example.py

• Copier/coller la librairie dans le dossier python

  • cp ms5837.py ms5837.pyc /home/pi/python

• On a enlevé les retours d'affichage concernant les données non utiles à savoir les pressions autre que mbar et °C ;

• Au moment "sensor.ns.....=" en début de code, on ne met rien dans le Bus pour que la raspberry prenne le bus par défaut, au final on ne touche pas depuis le code exemple.py ;

• Il reste à faire
  • Modifier le script python pour enlever l'affichage de données sur le moniteur ;
  • Pour le remplacer par l'edition d'un fichier .txt ou .csv ;
  • Intégrer à main l'appel du script python ;
  • renommer exemple.py ;

• Le capteur indique des données éronnées, d'après Jean-Charles il faut ajouter un régulateur de niveau pour abaisser le signal à 3,3V.
• Voilà le composant chez Blue robotics
• On a commandé Celui-ci pour faire des essais.

• Solution à l'étalonnage mauvais

• 

• Liens connexes

• Info vendeur
• Data sheet
• Schème de montage capteur
• Utiliser un capteur 30 BR sur Raspberry
• Code de pilotage plus capteur de température
• Enregistrer les données en csv

Installer le driver gpsd

• Installer gpsd

  • sudo apt install gpsd

Localiser le port USB qu'utilise le GPS

• Brancher le capteur GPS BU-353S4 sur un port USB de la raspberry dont on notera la position ;
• Par une invite de commande de la raspberry, naviguer jusqu'au dossier "dev" qui est placé à la racine de l'arborescence ;
• Utiliser la commande "ls -l" pour consulter les ports series en ttyUSB* ;
• Débrancher le capteur GPS et renouveler la commande "ls -l" pour déterminer le port ttyUSB* qui n'est plus présent (l'étoile sera remplacé par un chiffre). On notte cette adresse, c'est l'adresse du port série où est branché le capteur GPS ;

Un premier code pour enregistrer la position GPS sur un log

• Naviguer vers le dossier python :

  • cd /home/pi/python

• Créer un nouveau script python

  • sudo nano gps.py

• Y coller (par clic droit), le code suivant ;

  • import serial
    import csv
    
    ser = serial.Serial( '/dev/ttyUSB0', 4800, timeout = 5 )
    print 'Go'
    
    while 1:
    
            line = ser.readline()
            splitline = line.split(',')
    
            if splitline[0] == '$GPGGA':
                    print splitline[2]
                    heureUTC = splitline[1]
                    latitude = splitline[2]
                    latDirec = splitline[3]
                    longitude = splitline[4]
                    longDirec = splitline[5]
                    with open('log.csv', 'a') as log_file:
                            log_writer = csv.writer(log_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIM$
                            log_writer .writerow([heureUTC, latitude, latDirec, longitude, longDirec ])
                    break
    

Mettre à l'heure le système par le GPS

• Dans le dossier Python (/home/pi/python), créer un nouveau script que l'on nomera "gps-heure.py".
• Dans ce nouveau script, écrire le code suivant (ce code est adapté de celui trouvé sur raspberry-pi.developpez.com).

  • # Script pour mettre a jour l'heure du system grace au GPS branche en USB
    # David Hanon 20 octobre 2020
    #
    
    import serial	#libairie python pour liaison serie
    import os	#libairie python pour lancer une commande system
    
    # Declaration de la liaison serie avec le capteur GPS
    ser = serial.Serial(
        port='/dev/ttyUSB0',\
        baudrate=4800,\
        parity=serial.PARITY_NONE,\
        stopbits=serial.STOPBITS_ONE,\
        bytesize=serial.EIGHTBITS,\
            timeout=1)
    
    
    # Main program loop:
    quiter = False
    while quiter == False :
        line = ser.readline()
        if "$GPRMC" in line: #On cherche les trames RMC
            gpsData = line.split(',') #on decoupe la trame entre les virgules
    	if (gpsData[2] == "A") : 
    		
    		#La trame est valide
    		gpsDate = gpsData[9] #Donnee date
    		gpsHeure = gpsData[1] #Donnee heure		
    		
    		#Mise en forme de la date Mois / jour / annee
    		sysDate=gpsDate[2:4]+'/'+ gpsDate[0:2]+'/20'+ gpsDate[4:6]
    		print (gpsDate)
    		print (sysDate)
    		sysDate= "sudo date -s " + sysDate
    		print (sysDate)
    		#lancement de la commande system
    		ret1=os.system(sysDate)
    	
    		#Mise en forme de l'heure
    		print(gpsHeure)
    		gpsHeure = gpsHeure[0:2] + ':' + gpsHeure[2:4] + ':' + gpsHeure[4:6]
    		gpsHeure = "sudo date -s " + gpsHeure
    		
    		#lancement de la commande system
    		ret2=os.system(gpsHeure)	
    		print(gpsHeure)
    		#On verifiera les codes retour plus tard.
    		#print('retour 1 = ' + ret1)
    		#print('retour 2 = ' + ret2) 		
    		quiter = True

Liens connexes

• Le tuto le plus précis
• Installer un BU-353S4
• Configure BU-353S4
• Mettre à l'heure le raspberry pi par le GPS
• Un code pour mettre à l'heure le raspberry pi
• Forme de la trame GPS

Exemple d'un script qui marche

• Le script suivant pioché sur Real Python et modifié pour notre programme permet de stoker sur un fichier csv existant une nouvelle lign

  • #La commande import est à ajouter au tout début du code
    import csv
    
    #Cette seconde partie de code est à coller dans la boucle d'assignation de variables
    with open('log.csv', mode='w') as log_file:
        log_writer = csv.writer(log_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
        log_writer.writerow([heureUTC,latitude,longitude])

• Ouvrir le fichier rc.local se situant dans le dossier "etc".

  • sudo nano /etc/rc.local

• Repérer la ligne où est inscrit "exit 0"
• Juste au dessus de cette ligne, inscrire la commande d'execution du script bash en veillant à indiquer le chemin complet.

  • bash /home/pi/python/kosmos-main.sh

• Enregistrer et sortir de l'éditeur puis redémarrer la Raspberry.
• Si tout est correct, le script défini va démarrer.

Liens connexes

• Executer un programme au démarrage

1.0 : Programmation

2.0 : Montage électronique

• Débrancher la RTC du KOSMOS
• Souder 4 broches mâles Dupont supplémentaire de l'autre coté de la RTC
• Modifier l'alimentation de la RaspBerry : on l'alimente désormais avec le module transistor relié à la carte Adafruit Trinket en branchant le V+ et V- à la RaspBerry .
• On branche l'alimentation 5V sortant du transformateur au module transistor sur Vin et GND
• On branche la broche GPIO ( broche 1 ) de l'Adafruit à la broche Sig du module transistor et le 5V et le GND respectivement au VCC et GND du module transistor
• On Connecte désormais le module RTC à l'Adafruit et à la RaspBerry : Sur les prise Dupont mâles ajoutées précédemment on branche les broches VCC, GND, SCL( broche 2) et SDA ( broche 0) de l'adafruit et de l'autre côté on branche simplement le SCL et SDA de l'I2C au module RTC.
• On a écarté la possibilités de brancher les I2C de l'Adafruit et de la RaspBerry sur le même module RTC car celui-ci semble perdu lorsque l'on est dans ce cas.
• On mettra donc deux modules RTC ( à revalider ) dans le KOSMOS possédant l'option MIKADO
• On a ensuite écarté le module transistor car connecté à la RaspBerry il ne fonctionnait pas et nous sommes passé à un relais 5V qui est beaucoup plus simple et fonctionne bien.

Ressources