Electronique

image chip.png (5.9kB)

Ici est un espace libre pour réfléchir ensemble au nouveaux système de captation d'images sous-marines inspiré du STAVIRO et du MICADO. N'oubliez-pas il suffit, de double-cliquer sur cette page pour en éditer le contenu.

Archive tuto elec

Pré-conception

L?électronique embarquée servira à orchestrer le système KOSMOS, et permettra de :

  • Piloter la caméra et stocker les vidéos sur une mémoire de carte SD ;
  • Piloter le moteur pour pivoter la caméra de 60° toute les 30 secondes ;
  • Collecter et stocker des données de température et de pression en fonction du temps ;
  • Orchestrer le système suivant des phases de mise en route et des phases de veilles préprogrammées ;

Pour en savoir plus, consultez le PAD regroupant les premières notes de l'équipe optique ou le Forum

Evolution de la conception

A la suite de divers ateliers KOSMOS, la première conception de l'électronique a beaucoup évolué.
  • La motorisation s'oriente d'avantage vers une motorisation bruschless, Un moteur de ROV est submersible, il peut donc se de placer à l?extérieur du caisson étanche.
  • Le capteur de température n'est pas nécessaire, puisque le capteur de pression bar30 de Blue robotics en dispose. Ce dernier admet une précision de l'ordre de 0,1°.
  • Un capteur GPS permettra de renseigner d'une position le fichier log pour chaque plongée (avant la plongée). Mais également, il servira de mise à l'heur du sytème et remplace donc l'horloge RTC.
  • Une clé USB est un périphérique de stockage plus simple à paramétrer mais tout aussi fiable qu'une carte SD.
  • Une batterie 5v fournira le courant pour alimenter à la fois la raspberry et le moteur. Toutefois il faudra peut-être s'attendre à devoir alimenter ce dernier en 12V.
image schmaElecv1.png (0.7MB)
image schmaElecv2.png (0.6MB)

Tutoriel en cours

/!\ Ce tutoriel est non exhaustif, pour la simple raison qu'il n'est pas terminé. Vous pouvez toutefois contribuer et apporter des précisions en double cliquant sur cette page pour l'éditer.

Matériel

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

1.Installation de l'OS


2. Pilotage de la raspberry depuis un ordinateur tiers

Pour les raspberry de KOSMOS : IP Raspberry 1 = 192.168.0.101 IP Raspberry 2 = 192.168.0.87

3. Assignation d'une IP fixe

Une adresse IP est un code de quatre nombres qui se permet à un routeur de retrouver un objet connecté. Cette adresse peut changer à chaque redémarrage. D'où l'intérêt d'assigner à la Raspberry une IP fixe pour ne pas avoir à retrouver l'IP avant chaque connexion ;
  • 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

Pour la Raspberry Kosmos 2, l'adresse IP est 10.42.0.203

Problèmes fréquemment rencontrés

VNC renvoi "Impossible d'afficher le bureau actuellement
Ce problème arrive lorsque l'on a pas connecté d'écran au Raspberry dé son ouverture. Pour y remédier il faut lui indiquer de booter toujours en renvoyant l'interface graphique, que le hdmi soit ou non branché.
  • 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


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


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


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

Alimentation du moteur par un contrôleur ESC, qui est alimenté par une batterie 12v. Une batterie lipo 3s (12,60), (4,20v /s).
Un esc de 30 A
https://hobbyking.com/fr_fr/hobbyking-30a-2-4s-esc-3a-ubec.html?queryID=fc40182403a62d8dc67ffae90a63cbae&objectID=36301&indexName=hbk_live_magento_fr_fr_products

connecteurs dorés males et femelles
https://hobbyking.com/fr_fr/polymax-3-5mm-gold-connectors-10-pairs-20pc.html?queryID=11d9b365b94bc6a0a570d36b9c0126a4&objectID=43814&indexName=hbk_live_magento_fr_fr_products

Batterie 3s
https://hobbyking.com/fr_fr/turnigy-nano-tech-1000mah-3s-20-40c-lipo-airsoft-pack-t-connector.html?queryID=1fe47bcd89a42eb4ba770f1d74cff1e1&objectID=47517&indexName=hbk_live_magento_fr_fr_products

  • connecteur T Mâles et femelles

Câble 30AWG noir, rouge et jaune

Gaine thermoretractable

Liens connexes


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

  • 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

  • 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.

image image1.jpg (1.0MB)
Circuit électronique STAVIRO (face)
image image2.jpg (0.8MB)
Circuit électronique STAVIRO (arrière)
image IMG_20200705_143057.jpg (0.6MB)

Durant la phase de conception, nous avions fait un script "kosmos-main" en bash. Cette solution n'a pas été retenu, mais en voici tout de même l'archive.

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


1. Branchement du bouton poussoir étanche

  • Brancher le bouton poussoir comme suit :
image branchementboutonpoussoir.png (17.9kB)



Liens connexes


  • Capteur de pression

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

Programmation
  • 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 ;

Astuce de Paul
  • 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 ;


  • Solution à l'étalonnage mauvais

  • image branchement_capteur_pression.png (30.4kB)

Nous allons ici créer un code qui permets de lire une position GPS et de l'inscrire sur un fichier CSV log.

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


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


modèle HW-084 DS3231
sudo i2cdetect -y 1
(il utilise l'adresse 68 ?)
Notifier le nouveau composant installé au système :
echo ds3231 0x68 | sudo tee /sys/class/i2c-adapter/i2c-1/new_device
véfier la date du RTC : (doit envoyer le 1/1/2000 si le composant est neuf).
sudo hwclock
Configuration depuis le internet: (choisir le bon fuseau horraire)
sudo dpkg-reconfigure tzdata
ecriture dans le RTC :
sudo hwclock -w
Si pas de réseau : (remplacer par la bonne date et heure)
sudo date -s "Aug 31 2015 13:15:00"
sudo hwclock -w
Lancement de la lecture de l'heure dans le RTC au démarrage :
sudo geany /etc/rc.local
Ajouter à ce fichier les deux lignes suivantes avant la ligne “exit 0” :
echo ds3231 0x68 > /sys/class/i2c-adapter/i2c-1/new_device
hwclock -s
Donner les droits au script
chmod a+xwr kosmos_find_usb.sh
Lancement du programme au démarrage de la cate
Ne pas démarrer l'interface graphique :
sudo raspi-config
1 System Options
5 Boot / Auto Login
B2 Console Autologin


Informations complémentaires

  • Pour lancer un programme python, utiliser python3
  • Pour avoir une image du diagramme de classe : pyreverse -o png -p main -a2 -s1 kosmos_main.py