Ballon sonde

codeur_du_01 -  
 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

  1.
    yg_be Messages postés 23437 Date d'inscription   Statut Contributeur Dernière intervention   Ambassadeur 1 588
     
    bonjour,
    quel comportement attends-tu?
    0
  2. codeur_du_01
     
    je voudrai que le programme prenne la température et la prétion
    puit qu'il prenne les photo
    0
    1. yg_be Messages postés 23437 Date d'inscription   Statut Contributeur Dernière intervention   1 588
       
      es-tu certain de t'être bien exprimé?
      peux-tu être plus précis? dans quel ordre doit-il faire tout cela?
      0
      1. codeur_du_01 > yg_be Messages postés 23437 Date d'inscription   Statut Contributeur Dernière intervention  
         
        je pense avoir plus détailler si dessous dans réponse |
        \/
        0
  3. codeur_du_01
     
    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 .
    0
    1. yg_be Messages postés 23437 Date d'inscription   Statut Contributeur Dernière intervention   1 588
       
      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.
      0
      1. codeur_du_01 > yg_be Messages postés 23437 Date d'inscription   Statut Contributeur Dernière intervention  
         
        comme ç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()
        0
      2. yg_be Messages postés 23437 Date d'inscription   Statut Contributeur Dernière intervention   1 588 > codeur_du_01
         
        as-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?
        0
      3. codeur_du_01 > yg_be Messages postés 23437 Date d'inscription   Statut Contributeur Dernière intervention  
         
        oui 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'
        0
  4. codeur_du_01
     
    bonjour

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

Discussions similaires

Comment dégonfler une balle foot à la maison
gugh -
Lulucici -

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

2 réponses
Ballon
Mar_9535 -
Raymond PENTIER -

1 réponse
ballon professinell se dégonfle tout seule
airsec -
Raymond PENTIER -

2 réponses
Disfonctionnement de ma station météo Lacrosse
Lucer31 -
Lucer31 -

2 réponses