×Fichiers du thème manquants :
themes/yeswiki/squelettes/responsive-1col.tpl.html
themes/yeswiki/styles/blue.css
Le thème par défaut est donc utilisé.

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.

Télécharger le fichier schmaElecv1.png Télécharger le fichier schmaElecv2.png

Etape 3 : Pilotage du moteur DC

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

Etape 3 Bis : Pilotage du moteur Brushless

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

Etape 4 : Paramétrer et intégrer la picam

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

Etape 5 : Le circuit ILS pour démarrer le système par le passage d'un aimant

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

Télécharger le fichier image1.jpg Télécharger le fichier image2.jpg Télécharger le fichier IMG_20200705_143057.jpg

Etape 6 : Script général

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.

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.

Etape 7 : Piloter une LED pour témoin de fonctionnement

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

Etape 8 : Utiliser un bouton poussoir pour stopper le script

1. Branchement du bouton poussoir étanche

Brancher le bouton poussoir comme suit :

Télécharger le fichier branchementboutonpoussoir.png

Liens connexes

Tutoriel raspberry pour utiliser un bouton poussoir

Etape 9 : Intégrer les capteurs de pression et température

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 ;

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
Télécharger le fichier branchement_capteur_pression.png

Etape 10 : Capteur GPS

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

Etape 11 : Stockage des données annexes sur un CSV

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])

Archive tuto elec

Pré-conception

Evolution de la conception

Etape 3 : Pilotage du moteur DC

Moteur à courant continue

Matériel

1. Montage électrique de prototypage

2. Essai script de démo

3. Script moteur pour le KOSMOS

Info moteur

Liens connexes

Etape 3 Bis : Pilotage du moteur Brushless

Matériel nécessaire

1. Installer la librairie pigpio

2. Faire tourner le moteur

Liens connexes

Etape 4 : Paramétrer et intégrer la picam

Transformation du fichier H264 en MP4

Lien connexes

Etape 5 : Le circuit ILS pour démarrer le système par le passage d'un aimant

Etape 6 : Script général

Archive

Archives anciens scripts

Pistes d'amélioration

Etape 7 : Piloter une LED pour témoin de fonctionnement

1. Premier essais

Liens connexes

Etape 8 : Utiliser un bouton poussoir pour stopper le script

1. Branchement du bouton poussoir étanche

Liens connexes

Etape 9 : Intégrer les capteurs de pression et température

Capteur de pression

Solution à l'étalonnage mauvais

Liens connexes

Etape 10 : Capteur GPS

Installer le driver gpsd

Localiser le port USB qu'utilise le GPS

Un premier code pour enregistrer la position GPS sur un log

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

Liens connexes

Etape 11 : Stockage des données annexes sur un CSV

Exemple d'un script qui marche