Un programme qui reçoit la commande d'asservissement du contrôleur radio, interrompt la tarte aux râpes et l'enregistre.

Code mémoire pour tarte aux râpes

filename.py

import pigpio
import time
import signal
import csv

#T
wfilename='wlogfile_1.csv'
rfilename='rlogfile_1.csv'

time_HI_STR_N=1520#Temps HAUT dans l'état neutre d'entrée côté direction[us]
time_HI_STR_MAX=2020
time_HI_STR_MIN=1020
time_HI_DRV_N=1520#Temps HIGH dans l'état neutre d'entrée côté variateur[us]
time_HI_DRV_MAX=2020
time_HI_DRV_MIN=1020
DUTY_MOT_MAX=20

frec_PWM_STR=50#Hz
frec_PWM_DRV=50#Hz
frec_logic=50#Hz

GAIN_DRV=DUTY_MOT_MAX/(time_HI_DRV_N-time_HI_DRV_MIN) #Grand temps[us]× constante = rapport cyclique
DRV_TH=1*10000 #Seuil de zone morte[%*10000]

#▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲


#T Pas de changement
#Réglage du numéro de broche
#Deux broches compatibles PWM matérielles pour la sortie ne peuvent pas être modifiées
pin_PWM_STR=12
pin_PWM_DRVF=13
pin_PWM_DRVR=19
#Peut être changé pour l'entrée
pin_IN_STR=16
pin_IN_DRV=20

#création d'instance pigpio
pi=pigpio.pi()

#output pin setup
pi.set_mode(pin_PWM_STR,pigpio.OUTPUT)
pi.set_mode(pin_PWM_DRVF,pigpio.OUTPUT)
pi.set_mode(pin_PWM_DRVR,pigpio.OUTPUT)

#input pin setup
pi.set_mode(pin_IN_STR,pigpio.INPUT)
pi.set_pull_up_down(pin_IN_STR,pigpio.PUD_DOWN)
pi.set_mode(pin_IN_DRV,pigpio.INPUT)
pi.set_pull_up_down(pin_IN_DRV,pigpio.PUD_DOWN)

HITIME_TO_OUTDUTY=frec_PWM_STR/(1000*1000)*100*10000#Grand temps[us]× constante = valeur de consigne de service[%*10^4]Quoi
#▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲ Pas de changement

#T
#Variable de calcul des droits d'entrée
time_UP_STR=[0,0]
time_DW_STR=[0,0]
time_UP_DRV=[0,0]
time_DW_DRV=[0,0]

#Variable d'enregistrement du rapport cyclique d'entrée
duty_IN_STR=0
duty_IN_DRV=0
#Variable d'enregistrement à temps élevé d'entrée
time_HI_STR=0
time_HI_DRV=0

#Gestion d'état
mod_req=0
mod_state=0
MODE_INIT=0
MODE_LOGING=1
MODE_REPLAY=2

duty_OUT_STR=0
duty_OUT_DRV=0


#▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

#▼▲▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲
#Entrée PWM pour le rappel d'interruption de direction
def callback_IN(gpio,level,tick):
    #Procédure d'utilisation des variables globales
    global time_UP_STR
    global time_DW_STR
    global duty_IN_STR
    global time_HI_STR
    global time_UP_DRV
    global time_DW_DRV
    global duty_IN_DRV
    global time_HI_DRV
    
    if gpio==pin_IN_STR:#Interruption causée par la direction
        if level == 1:#Monter
            time_UP_STR[1]=time_UP_STR[0]
            time_UP_STR[0]=tick
            duty_IN_STR=(time_DW_STR[0]-time_UP_STR[1])/(time_UP_STR[0]-time_UP_STR[1])*100
            time_HI_STR=(time_DW_STR[0]-time_UP_STR[1])
        else:#Tomber
            time_DW_STR[1]=time_DW_STR[0]
            time_DW_STR[0]=tick
    else:#L'interruption n'est pas causée par la direction (causée par la conduite)
        if level == 1:#Monter
            time_UP_DRV[1]=time_UP_DRV[0]
            time_UP_DRV[0]=tick
            duty_IN_DRV=(time_DW_DRV[0]-time_UP_DRV[1])/(time_UP_DRV[0]-time_UP_DRV[1])*100
            time_HI_DRV=(time_DW_DRV[0]-time_UP_DRV[1])
        else:#Tomber
            time_DW_DRV[1]=time_DW_DRV[0]
            time_DW_DRV[0]=tick
        
    #print(time_HI_STR,time_HI_DRV,duty_IN_STR,duty_IN_DRV)
#▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲


#▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ interrompre
def logic_main(arg1, arg2):
    #Procédure d'utilisation des variables globales
    global time_HI_STR#[us]
    global time_HI_DRV#[us]
    global time_HI_STRtmp#[us]
    global time_HI_DRVtmp#[us]
    global index,index_lim
    #▼▲▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▼
    

    duty_OUT_STR=0
    duty_OUT_DRV=0
    
    if mod_state==MODE_REPLAY:
        if index<index_lim:
            duty_OUT_STR=int(data[index][0])
            duty_OUT_DRV=int(data[index][1])
            index=index+1
        elif index==index_lim:
            print("Fin de la lecture! Appuyez sur la touche Entrée")
            index=index+1
        else:
            duty_OUT_STR=0
            duty_OUT_DRV=0
            
    else:
        #Montant de l'opération de direction
        duty_OUT_STR=int(max(min(time_HI_STRtmp*HITIME_TO_OUTDUTY,100*10000),0))#Limites de limite supérieure et inférieure et conversion
        #Montant du lecteur
        duty_OUT_DRV=int(max(min((time_HI_DRVtmp-time_HI_DRV_N)*GAIN_DRV,DUTY_MOT_MAX),-DUTY_MOT_MAX)*10000)
    
    #production
    pi.hardware_PWM(pin_PWM_STR,frec_PWM_STR,duty_OUT_STR)
    if duty_OUT_DRV>DRV_TH:#Rotation avant
        pi.hardware_PWM(pin_PWM_DRVF,frec_PWM_DRV,duty_OUT_DRV)
        pi.write(pin_PWM_DRVR,0)
        #print(duty_OUT_STR,duty_OUT_DRV,"F")
    elif duty_OUT_DRV<-DRV_TH:#Renversement
        pi.write(pin_PWM_DRVF,0)
        pi.hardware_PWM(pin_PWM_DRVR,frec_PWM_DRV,-duty_OUT_DRV)
        #print(duty_OUT_STR,duty_OUT_DRV,"R")
    else:#Arrêtez
        pi.write(pin_PWM_DRVF,0)
        pi.write(pin_PWM_DRVR,0)
        #print(duty_OUT_STR,duty_OUT_DRV)
    
    if mod_state==MODE_LOGING:
        w.writerow([duty_OUT_STR,duty_OUT_DRV])
    
    #▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
#▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲ interrompre
    
    
#▼▲▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲
pi.callback(pin_IN_STR,pigpio.EITHER_EDGE,callback_IN)#Côté direction
pi.callback(pin_IN_DRV,pigpio.EITHER_EDGE,callback_IN)#Côté entraînement
signal.signal(signal.SIGALRM,logic_main)#Exécution et réglage de la logique principale (interruption de la minuterie) lorsqu'un signal arrive
signal.setitimer(signal.ITIMER_REAL,0.1,0.02)#Interruption de la minuterie avec signal 50Hz
#▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲


#T

time_HI_STRtmp=5000
time_HI_DRVtmp=5000

while 1:
    print('1:Journalisation 2:Lecture 3:Fin')
    try:
        tmp_req=input('> ')
    except KeyboardInterrupt:
        print("stop!")
        break
    
    try:
        mod_req=int(tmp_req)
    except:
        print("miss")
        break
#début
    if mod_req==MODE_LOGING:
        file=open(wfilename,'w')
        w=csv.writer(file)
        mod_state=MODE_LOGING
        print("Enregistrement...")
        print("Appuyez sur la touche Entrée pour arrêter")

    elif mod_req==MODE_REPLAY:
        file=open(rfilename,'r')
        r=csv.reader(file)
        data=[row for row in r]
        index=0
        index_lim=len(data)
        mod_state=MODE_REPLAY
        print("En jouant...")
    else:
        print("END!")
        break
    

#Fin
    try:
        input('> ')
    except KeyboardInterrupt:
        print("stop!")
        break
   
    if mod_req==MODE_LOGING:
        mod_state=MODE_INIT
        mod_req=MODE_INIT
        file.close()
    elif mod_req==MODE_REPLAY:
        mod_state=MODE_INIT
        mod_req=MODE_INIT
        file.close()
    else:
        print("END!")
        break
    
time.sleep(0.1)
#▼▲▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲ ▼ ▲
pi.set_mode(pin_PWM_STR,pigpio.INPUT)
pi.set_mode(pin_PWM_DRVF,pigpio.INPUT)
pi.set_mode(pin_PWM_DRVR,pigpio.INPUT)
pi.stop()
signal.setitimer(signal.ITIMER_REAL,0)
#▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲