ES33A08 ES33B08 ESP32 MicroPython code collez le code dans Thonny (https://thonny.org/)
Partager
from machine import Pin, ADC
import time
# Définition des broches pour le registre à décalage 74HC595
CLOCK_595 = 27 # Broche d'horloge pour 74HC595
LATCH_595 = 14 # Broche de verrouillage pour 74HC595
DATA_595 = 13 # Broche de données pour 74HC595
OE_595 = 4 # Activation de la sortie pour 74HC595, active à l'état bas
# Définition des broches pour le registre à décalage d'entrée 74HC165
CLOCK_165 = 18 # Broche d'horloge pour 74HC165
LOAD_165 = 19 # Broche de chargement pour 74HC165
DATA_165 = 21 # Broche de données pour 74HC165
# Définition de la broche pour le capteur PIR
PIR_PIN = 5
# Initialisation des broches GPIO pour 74HC595
clock_595 = Pin(CLOCK_595, Pin.OUT)
latch_595 = Pin(LATCH_595, Pin.OUT)
data_595 = Pin(DATA_595, Pin.OUT)
oe_595 = Pin(OE_595, Pin.OUT)
# Initialisation des broches GPIO pour 74HC165
clock_165 = Pin(CLOCK_165, Pin.OUT)
load_165 = Pin(LOAD_165, Pin.OUT)
data_165 = Pin(DATA_165, Pin.IN)
# Initialisation de la broche GPIO pour le capteur PIR
pir_sensor = Pin(PIR_PIN, Pin.IN)
# Initialisation de l'ADC pour LM324DR (traitement du signal analogique)
analog_input = ADC(Pin(32)) # Utilisation de GPIO32 pour l'entrée analogique
# Désactivation de la sortie pendant la configuration
oe_595.value(1) # Désactivation de la sortie (active à l'état bas)
# Mappage des nombres à afficher pour le 7 segments (représentation décimale)
number_mapping = {
0: 252, # 0b11111100, 0xFC, Configuration pour '0'
1: 96, # 0b01100000, 0x60, Configuration pour '1'
2: 218, # 0b11011010, 0xDA, Configuration pour '2'
3: 242, # 0b11110010, 0xF2, Configuration pour '3'
4: 102, # 0b01100110, 0x66, Configuration pour '4'
5: 182, # 0b10110110, 0xB6, Configuration pour '5'
6: 190, # 0b10111110, 0xBE, Configuration pour '6'
7: 224, # 0b11100000, 0xE0, Configuration pour '7'
8: 254, # 0b11111110, 0xFE, Configuration pour '8'
9: 246 # 0b11110110, 0xF6, Configuration pour '9'
}
# Mappage du texte à afficher pour le 7 segments (configuration à cathode commune)
text_mapping = {
'A': 238, # 0b11101110, 0xEE, Configuration pour 'A'
'b': 62, # 0b00111110, 0x3E, Configuration pour 'b'
'C': 156, # 0b10011100, 0x9C, Configuration pour 'C'
'd': 122, # 0b01111010, 0x7A, Configuration pour 'd'
'E': 158, # 0b10011110, 0x9E, Configuration pour 'E'
'F': 142, # 0b10001110, 0x8E, Configuration pour 'F'
'G': 188, # 0b10111100, 0xBC, Configuration pour 'G'
'H': 110 # 0b01101110, 0x6E, Configuration pour 'H'
}
# Activation des chiffres (représentation décimale, en supposant une cathode commune par simplicité, à modifier si vous utilisez une anode commune)
digit_activation = {
1: 14, # 0b1110, 0xE, Active le premier chiffre (le plus à gauche)
2: 13, # 0b1101, 0xD, Active le deuxième chiffre
3: 11, # 0b1011, 0xB, Active le troisième chiffre
4: 7 # 0b0111, 0x7, Active le quatrième chiffre (le plus à droite)
}
# Bits de contrôle des canaux (représentation décimale)
channel_mapping = {
1: 32768, # 0b1000000000000000, 0x8000
2: 16384, # 0b0100000000000000, 0x4000
3: 8192, # 0b0010000000000000, 0x2000
4: 4096, # 0b0001000000000000, 0x1000
5: 2048, # 0b0000100000000000, 0x0800
6: 1024, # 0b0000010000000000, 0x0400
7: 512, # 0b0000001000000000, 0x0200
8: 256 # 0b0000000100000000, 0x0100
}
# Bits de contrôle d'entrée pour 74HC165 (D0 à D7, représentation décimale)
input_mapping = {
1: 1, # 0b00000001, 0x01
2: 2, # 0b00000010, 0x02
3: 4, # 0b00000100, 0x04
4: 8, # 0b00001000, 0x08
5: 16, # 0b00010000, 0x10
6: 32, # 0b00100000, 0x20
7: 64, # 0b01000000, 0x40
8: 128 # 0b10000000, 0x80
}
# Bits d'entrée de tension (V1 à V4, représentation décimale)
v_mapping = {
1: ADC(Pin(32)), # V1, GPIO32
2: ADC(Pin(33)), # V2, GPIO33
3: ADC(Pin(34)), # V3, GPIO34
4: ADC(Pin(35)) # V4, GPIO35
}
# Bits d'entrée de courant (I1 à I4, représentation décimale)
i_mapping = {
1: ADC(Pin(36)), # I1, GPIO36
2: ADC(Pin(37)), # I2, GPIO37
3: ADC(Pin(38)), # I3, GPIO38
4: ADC(Pin(39)) # I4, GPIO39
}
# Fonction pour écrire une valeur dans le registre à décalage
def write_shift_register(value):
latch_595.value(0) # Préparation au verrouillage des données
for i in range(32): # Décalage de 32 bits de données
data_595.value((value >> i) & 1)
clock_595.value(1)
time.sleep_us(10)
clock_595.value(0)
latch_595.value(1) # Verrouillage des données à la sortie des registres à décalage
oe_595.value(0) # Activation de la sortie pour prendre effet
# Fonction pour lire une valeur du registre à décalage d'entrée
def read_shift_register():
load_165.value(0) # Chargement de l'entrée parallèle dans le registre à décalage
time.sleep_us(10)
load_165.value(1)
value = 0
for i in range(8): # Lecture de 8 bits de données
value |data_165.value() << (7 - i))
clock_165.value(1)
time.sleep_us(10)
clock_165.value(0)
return value
# Fonction pour contrôler CH1 en fonction de l'état de IN1 et du capteur PIR
def control_ch1():
input_status = read_shift_register()
in1_status input_status >> 0) & 1 # Lecture de l'état de IN1
pir_status = pir_sensor.value() # Lecture de l'état du capteur PIR
if in1_status == 1 or pir_status == 1: # Si IN1 ou PIR est haut
combined_value = channel_mapping[1] # Activation de CH1
else: # Si IN1 et PIR sont bas
combined_value = 0 # Désactivation de tous les canaux
write_shift_register(combined_value)
# Fonction pour lire les entrées analogiques (V* et I*)
def read_analog_inputs():
analog_values = {}
for key, adc in v_mapping.items():
analog_values[f"V{key}"] = adc.read()
for key, adc in i_mapping.items():
analog_values[f"I{key}"] = adc.read()
return analog_values
# Fonction pour indiquer si quelque chose est connecté aux entrées
def indicate_input_connections(input_status):
for i in range(8):
if (input_status >> i) & 1:
print(f"IN{i+1} est connecté")
# Boucle principale
while True:
# Contrôle CH1 en fonction de l'état de IN1 et du capteur PIR
control_ch1()
# Lecture de l'état d'entrée et indication des connexions
input_status = read_shift_register()
indicate_input_connections(input_status)
# Affichage des valeurs numériques
digital_values = {f"IN{i+1}": (input_status >> i) & 1 for i in range(8)}
print("Valeurs numériques:", ", ".join([f"IN{i+1}: {val}" for i, val in enumerate(digital_values.values())]))
# Lecture de l'entrée analogique (par ex., depuis LM324DR)
analog_values = read_analog_inputs()
print(f"Valeurs analogiques: {analog_values}")
# Cycle à travers les nombres de 0 à 9 et les canaux correspondants
for channel in range(1, 9):
# Calcul du motif de bits du canal (OUT 16 à OUT 9 correspond aux canaux 1 à 8)
channel_bit_pattern = 1 << (16 - channel)
# Obtention du nombre à afficher et calcul de la valeur combinée pour le registre à décalage
number_to_display = channel % 10 # Affiche le même nombre que le canal
combined_value number_mapping[number_to_display] << 24) | \
(digit_activation[1] << 20) | \
channel_bit_pattern
# Écriture de la valeur combinée dans le registre à décalage
write_shift_register(combined_value)
# Affichage de l'état actuel pour le débogage
print(f"Le canal {channel} est actif, affichant le nombre {number_to_display}")
# Attente avant de passer au nombre et au canal suivants
time.sleep(1)
# Délai supplémentaire avant de répéter le cycle, si nécessaire
time.sleep(1)