Ballon sonde

ok, je me demandais dans quel ordre tout cela devait se passer.
le plus simple, me semble, alors, dans le fichier "temp":
- de créer une fonction timelaps()
- de mettre dans cette fonction les ligne 3 à 11 du fichier "timelaps"
- d'appeler cette fonction en ligne 212 du fichier "temp", juste avant les trois secondes d'attente.

il est également possible de faire un seul programme en gardant les deux fichiers séparés.

@yg_becomme ça :

import smbus
import picamera
import time
from datetime import datetime
from ctypes import c_short
from ctypes import c_byte
from ctypes import c_ubyte

DEVICE = 0x76 # Default device I2C address

bus = smbus.SMBus(1) # Rev 2 Pi, Pi 2 & Pi 3 uses bus 1
# Rev 1 Pi uses bus 0

def getShort(data, index):
# return two bytes from data as a signed 16-bit value
return c_short((data[index + 1] << 8) + data[index]).value

def getUShort(data, index):
# return two bytes from data as an unsigned 16-bit value
return (data[index + 1] << 8) + data[index]

def getChar(data, index):
# return one byte from data as a signed char
result = data[index]
if result > 127:
result -= 256
return result

def getUChar(data, index):
# return one byte from data as an unsigned char
result = data[index] & 0xFF
return result

def readBME280ID(addr=DEVICE):
# Chip ID Register Address
REG_ID = 0xD0
(chip_id, chip_version) = bus.read_i2c_block_data(addr, REG_ID, 2)
return (chip_id, chip_version)

def readBME280All(addr=DEVICE):
# Register Addresses
REG_DATA = 0xF7
REG_CONTROL = 0xF4
REG_CONFIG = 0xF5

REG_CONTROL_HUM = 0xF2
REG_HUM_MSB = 0xFD
REG_HUM_LSB = 0xFE

# Oversample setting - page 27
OVERSAMPLE_TEMP = 2
OVERSAMPLE_PRES = 2
MODE = 1

# Oversample setting for humidity register - page 26
OVERSAMPLE_HUM = 2
bus.write_byte_data(addr, REG_CONTROL_HUM, OVERSAMPLE_HUM)

control = OVERSAMPLE_TEMP << 5 | OVERSAMPLE_PRES << 2 | MODE
bus.write_byte_data(addr, REG_CONTROL, control)

# Read blocks of calibration data from EEPROM
# See Page 22 data sheet
cal1 = bus.read_i2c_block_data(addr, 0x88, 24)
cal2 = bus.read_i2c_block_data(addr, 0xA1, 1)
cal3 = bus.read_i2c_block_data(addr, 0xE1, 7)

# Convert byte data to word values
dig_T1 = getUShort(cal1, 0)
dig_T2 = getShort(cal1, 2)
dig_T3 = getShort(cal1, 4)

dig_P1 = getUShort(cal1, 6)
dig_P2 = getShort(cal1, 8)
dig_P3 = getShort(cal1, 10)
dig_P4 = getShort(cal1, 12)
dig_P5 = getShort(cal1, 14)
dig_P6 = getShort(cal1, 16)
dig_P7 = getShort(cal1, 18)
dig_P8 = getShort(cal1, 20)
dig_P9 = getShort(cal1, 22)

dig_H1 = getUChar(cal2, 0)
dig_H2 = getShort(cal3, 0)
dig_H3 = getUChar(cal3, 2)

dig_H4 = getChar(cal3, 3)
dig_H4 = (dig_H4 << 24) >> 20
dig_H4 = dig_H4 | (getChar(cal3, 4) & 0x0F)

dig_H5 = getChar(cal3, 5)
dig_H5 = (dig_H5 << 24) >> 20
dig_H5 = dig_H5 | (getUChar(cal3, 4) >> 4 & 0x0F)

dig_H6 = getChar(cal3, 6)

# Wait in ms (Datasheet Appendix B: Measurement time and current calculation)
wait_time = (
1.25
+ (2.3 * OVERSAMPLE_TEMP)
+ ((2.3 * OVERSAMPLE_PRES) + 0.575)
+ ((2.3 * OVERSAMPLE_HUM) + 0.575)
)
time.sleep(wait_time / 1000) # Wait the required time

# Read temperature/pressure/humidity
data = bus.read_i2c_block_data(addr, REG_DATA, 8)
pres_raw = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4)
temp_raw = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4)
hum_raw = (data[6] << 8) | data[7]

# Refine temperature
var1 = ((((temp_raw >> 3) - (dig_T1 << 1))) * (dig_T2)) >> 11
var2 = (
((((temp_raw >> 4) - (dig_T1)) * ((temp_raw >> 4) - (dig_T1))) >> 12) * (dig_T3)
) >> 14
t_fine = var1 + var2
temperature = float(((t_fine * 5) + 128) >> 8)

# Refine pressure and adjust for temperature
var1 = t_fine / 2.0 - 64000.0
var2 = var1 * var1 * dig_P6 / 32768.0
var2 = var2 + var1 * dig_P5 * 2.0
var2 = var2 / 4.0 + dig_P4 * 65536.0
var1 = (dig_P3 * var1 * var1 / 524288.0 + dig_P2 * var1) / 524288.0
var1 = (1.0 + var1 / 32768.0) * dig_P1
if var1 == 0:
pressure = 0
else:
pressure = 1048576.0 - pres_raw
pressure = ((pressure - var2 / 4096.0) * 6250.0) / var1
var1 = dig_P9 * pressure * pressure / 2147483648.0
var2 = pressure * dig_P8 / 32768.0
pressure = pressure + (var1 + var2 + dig_P7) / 16.0

# Refine humidity
humidity = t_fine - 76800.0
humidity = (hum_raw - (dig_H4 * 64.0 + dig_H5 / 16384.0 * humidity)) * (
dig_H2
/ 65536.0

• (

1.0
+ dig_H6 / 67108864.0 * humidity * (1.0 + dig_H3 / 67108864.0 * humidity)
)
)
humidity = humidity * (1.0 - dig_H1 * humidity / 524288.0)
if humidity > 100:
humidity = 100
elif humidity < 0:
humidity = 0

return temperature / 100.0, pressure / 100.0, humidity

#################################################################################################

def display_data(nb_for, chip_id, chip_version, temperature, pressure, humidity):
# affichage des données collectées grâce aux librairies readBME280ID & readBME280All
now = datetime.now()
print("\n{}: {}ème fois...".format(now.strftime("%d/%m/%Y %H:%M:%S"), nb_for + 1))
print("Chip ID : ", chip_id)
print("Version : ", chip_version)
print("Temperature : ", temperature, "C")
print("Pression : ", pressure, "hPa")
print("Humidité : ", humidity, "%")

def record_data(chip_id, chip_version, temperature, pressure, humidity):
# mise en forme des données collectées à enregistrer
now = datetime.now()

mesures = "{}\n\nChip ID : {}\nVersion : {}\nTemperature : {}C\nPression : {}hPa\nHumidité : {}%\n\n".format(
now.strftime("%d/%m/%Y %H:%M:%S"),
chip_id,
chip_version,
temperature,
pressure,
humidity,
)
# stockage des données formatées dans un fichier mesures.txt à la racine
with open("mesures.txt", "a") as file:
file.write(mesures)

#################################################################################################

def main():
# fonction principale
print(" start ".center(50, "-"))
for nb_for in range(3): # nb fois que la boucle est parcourrue au total

# récupération des données via les appareils de mesures
chip_id, chip_version = readBME280ID()
temperature, pressure, humidity = readBME280All()

# actionner la fonction display
display_data(nb_for, chip_id, chip_version, temperature, pressure, humidity)
# actionner la fonction record
record_data(chip_id, chip_version, temperature, pressure, humidity)

time.sleep(3) # nb secondes d'attente

print(" end ".center(50, "-"))
time.sleep(1)

######################################################

with picamera.PiCamera() as camera:
for n in range(3):
camera.start_preview()
time.sleep(5)
camera.capture_sequence([
'image%02d.jpg' % i
for i in range(1)
])
camera.stop_preview()

if __name__ == "__main__":
# execution du programme
main()

@codeur_du_01as-tu lu les explications (en dessous de ta question de départ) à propos de comment poster du code?
as-tu testé le code que tu montres?

@yg_beoui j'ai lu les instruction , mais le programme je ne peut pas le tester parce-que je n'est pas de rasberry à la
maison il faut que j'attende la rentrer pour le tester .
mais il n'y a pas d'erreurs de syntaxe quand je le lance .

Traceback (most recent call last):
  File "ballsond.py", line 1, in <module>
    import smbus
ModuleNotFoundError: No module named 'smbus'

es-tu certain de t'être bien exprimé?
peux-tu être plus précis? dans quel ordre doit-il faire tout cela?

@yg_beje pense avoir plus détailler si dessous dans réponse |
\/