Ballon sonde

codeur_du_01 -  
Bonjour, j'ai un problème avec mon code , j'ai un programme timelapse et un programme de température présion que je doit assembler et je n'ai pas les connaissance requise les programmes à assembles son :
pour la temp: 

 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, "-"))

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


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

Et pour la timelaps :
############################### 

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


EDIT : Ajout des balises de code (la coloration syntaxique).
Explications disponibles ici : ICI

Merci d'y penser dans tes prochains messages.

4 réponses

  2. codeur_du_01 Auteur
    je voudrai que le programme prenne la température et la prétion
    puit qu'il prenne les photo
    1. yg_be Contributeur
      es-tu certain de t'être bien exprimé?
      peux-tu être plus précis? dans quel ordre doit-il faire tout cela?
    2. codeur_du_01 Auteur
      @yg_beje pense avoir plus détailler si dessous dans réponse |
      \/
  3. codeur_du_01 Auteur
    le premier programme présenter doit d'abord prendre la température , pression , humidité : ensuit,
    il les enregistre dans un fichier "mesures.txt" .
    Le deuxième programme présenter , qui luit prend plusieurs photo.
    Et donc en ajoutent les deux programmes :
    je voudrais que le programme prenne la température , la pression et l'humidité en les enregistrent dans le fichiée "mesurs.txt" et une fois fais , il faut qu'il prenne des photo.

    je travail sur un rasberry a l'école pour un projet avec le B.I.A ;on envoi un ballon sond , je pourrait donc pas tester le programme pour l'instant en raison du confinement .
    1. yg_be Contributeur
      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.
    2. codeur_du_01 Auteur
      @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()
    3. yg_be Contributeur
      @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?
    4. codeur_du_01 Auteur
      @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'
  4. codeur_du_01 Auteur
    bonjour

    ce sont deux programmes différent qui fonctionne , mais j'aimerais que sa ne soi que un seul programme .

    Discussions similaires

    Comment dégonfler une balle foot à la maison
    gugh

    9 réponses
    Comment dégonfler sa balle de basket ?
    AbdoulDiallo

    2 réponses
    ballon professinell se dégonfle tout seule
    airsec

    2 réponses
    Ballon
    Mar_9535

    1 réponse
    Disfonctionnement de ma station météo Lacrosse
    Lucer31

    2 réponses