Discussion :

[Asterix20]

Bonjour,
Je possède une carte sur laquelle j'ai implémenté un PID, j'aimerai réaliser un petit simulateur en python qui serait entre autre composé d'une fonction de transfert d'un système et qui réagirait en temps réel à la sortie du PID et renverrai sa réponse à la carte.
Pour ce qui est de la communication entre les cartes, je pense savoir comment le faire, cependant je ne vois pas trop comment réaliser une fonction de transfert qui répondrait à la sortie de la carte ou le PID est implémenté.

Auriez vous une idée de comment réaliser cela ?

Merci d'avance pour votre aide

[robinechuca]

Bonjour

3 pistes me vienent à l'esprit:
-utiliser Scilab avec l'extension Xcos, je sais que des ponts existent entre scilab et python
-utiliser directement les transformées de Laplace avec le module sympy.
-coder Produit, Integral et Dérivée a la main, et ne pas passer dans le domaine de Laplace, rester en temporel en résolvant pas à pas l'équation différentielle avec un euler par example.

Quelles sont la ou les grandeurs physique mises en jeu?

[Asterix20]

Bonjour,
Merci pour votre réponse, j'ai téléchargé la librairie scypi à cet effet, malheureusement, j'arrive seulement à lancer une simulation instantanée.
Pensez vous qu'il est possible avec cette librairie et pyserial de créer une fonction de transfert qui répondrait en temps réel à ma carte électronique ou le pid est implémenté ?*
Je pense également suivre votre conseil et essayer avec scilab, cependant j ai vu que la simulation devait avoir une durée limité, pensez vous que la aussi je puisse effectué la simulation en temps réel ?
J'ai effectué un petit schéma de ce que j'essaye de faire que voici:

http://image.noelshack.com/fichiers/...507-194117.jpg

[robinechuca]

Bonjour si je comprend bien, votre shéma bloc ressemble a ceci: .

Dans le cas ou vorte carte PID prend en entrée un vrai signal qui évolu dans le temps, et qu'elle retourne un signal en traité. Je ne vois pas comment on pourrait si prendre directement dans laplace, sans transformée inverse, par contre, si on arrive à passer H(P) en temporel, on devrait pouvoir s'en sortir. Prenons un example: H(P) = k/(1+TP).
Alors on essai de trouver un sens physique, de trouver les équations différencielles. Ici trouvons H(P) (on pourrait le faire à la main mais faison le avec python pour plus de généralité):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
>>> import sympy
>>> k = sympy.Symbol("k", real=True)
>>> T = sympy.Symbol("T", real=True)
>>> P = sympy.Symbol("P")
>>> t = sympy.Symbol("t")
>>> H = k/(1+T*P)
>>> h = sympy.inverse_laplace_transform(H, P, t)
>>> h
k*exp(-t/T)*Heaviside(t)/T

A ce niveau là, il faut trouver l'equation différencielle, je ne sais pas trop comment automatiser ça... Mais dans notre cas on a directement le resultat usuel de y' = -Ty, ce qui est dans la vrai vie (pas en math) quasi pareil que (y(t+dt)-y(t))/dt = -T*y(t) <=> y(t+dt) = y(t)*(1-T*dt). Cette étape peut facilement s'automatiser (euler)
il reste plus qu'a tout coder, donc dans l'idée, le code ressemblerait a ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
def entrée(t):
   return f(t)#avec f(t) la consigne
def get_pid():
    '''retourne la valeur donnée en temp reel par la carte'''
def give_pid(value):
    '''met a jour l'entrée de la carte avec la valeur 'value' '''
def calcul_sortie(encienne_valeur, dt):
    return encienne_valeur*(1-T*dt)
 
import time
Sortie = [y0] #condition initial de la sortie
t = 0 #début de la simulation
while 1:
    t1 = time.time()
    give_pid(entrée(t)-Sortie[-1]) #on donne du boulot a la carte
    sortie_pid = get_pid()
    Sortie.append(calcul_sortie(sortie_pid, time.time()-t1))
    t += time.time()-t1

Ce n'est pas une solution très générale, je suis certain qu'il y a mieu, en restant dans laplace par example, mais une meilleur idée ne me vient pas!

[robinechuca]

Mais pour vraiment bien comprendre vos attentes, il faudrai que vous nous explicitiez ce qu'est votre pid.
-une carte purement analogique? (ampli-op et autre composants classique...)
-un microprocesseur? qui retourne quoi (du laplace, du temporel)?

Et aussi, voulez vous pouvoir changer kp, ki et kd au cours d'une meme simulation? Ou bien est-ce que ces constantes sont fixées dès le début?

Bonne recherche! (je continu de mon coté de chercher une solution plus 'théorique' (mais ce n'est pas vraiment un problème python, c'est juste un problème de math))

[Asterix20]

Bonjour,
Veuillez m'excuser pour le temps que je met à vous répondre.
Je suis encore en train d'étudier vos solutions je vais essayer d'apporter du nouveau dans les plus brefs délais.
Merci beaucoup pour votre aide

[robinechuca]

Un ami a trouvé un vrai solution.
Lorsqu'on écrit une fonction de transfère dans Laplace, c'est qu'on a fait l'hypothèse que le système est linéaire, et donc que le système de superposition fonctionne. Cela revient à dire que sortie(constante*entrée1(t)+entrée2(t)) = constante*sortie(entrée1(t)) + sortie(entrée2(t)). Or d'après fourier, on peut décomposer toute les fonctions 'gentilles' en somme de cosinusoides. Et il y a un truc magique avec Laplace, c'est que si on a une entrée qui s'écrit cos(w*t) et une fonction de transfer H(p) alors on a A = abs(H(J*w)) et Phi = arg(H(j*w)), et la sortie s'écrit s(t) = A*cos(w*t+Phi). Avec cette méthode, pas besoin de faire du calcul formel, ça fonctionne rapidement, simplement et dans 100% des cas.
En python la structure du code resemblerait à ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
import numpy #je crois bien qu'il est capable de faire une décomposition de fourier
 
def consigne(t):
    """
    retourne la consigne temporelle en fonction du vrai temps
    """
    return sin(t) #c'est une fonction pour l'example, mais ça marche avec n'importe quelle fonctions dont on sait aproximer l'integrale
 
def sortie_correcteur():
    """
    retourne la valeur retournée par la carte PID, une grandeur temporelle
    """
    return ...
 
def fourier(sortie_correcteur):
    """
    retourne le signal de sortie du correcteur sous forme de série de fourier
    """
    dephasages = numpy. ? #liste de chaqun des dephasages
    amplitudes = numpy. ? #liste des amplitudes
    w0 = numpy. ? #pulasion de la fondamentale
    return dephasages, amplitudes #pour un signal de la forme amplitude*cos(w0*i*t+dephasage)
 
def sortie_la_vrai(H):
    """
    aplication du théorème de superposition
    """
    deph = [arg(H(w0*i*J))+dephasages[i] for i in range(n)]
    mod = [abs(H(w0*i*J))*amplitudes[i] for i in range(n)]
    return sum([m*cos(w0*i*t+d) for i, (m,d) in enumerate(zip(mod, deph))])

[Asterix20]

Bonjour,
Merci beaucoup pour vos conseils, ils me sont très précieux, je vais essayer de faire communiquer la carte contenant le PID avec mon programme python ce soir, je vous tiens au courant.

[Asterix20]

Rebonjour,
J'ai oublié de préciser que le PID est implémenté dans un microcontrôleur et que la sortie est un signal 0-10V.
Le correcteur est implémenté en temps discret avec une période d'échantillonnage d'une seconde.

Sinon je me posais une question: La fonction sortie_correcteur doit simplement récupérer la valeur du signal de sortie à l'instant t ou bien plutôt récupérer la valeur du signal à l'instant t et le stocker dans un tableau de manière à pouvoir reconstituer l'allure du signal ?
Si ces deux solutions ne sont pas les bonnes, pourriez vous m'expliquer le fonctionnement global de cette fonction ?

Je suppose que je ne peux pas utiliser la première solution en envoyant une unique valeur dans la fonction fourrier, je me trompe ?

[robinechuca]

La fonction 'sortie_correcteur' doit retourner une fonction au sens matématique. Si elle retourne seulement la valeur à l'instant t, on n'a pas une 'courbe'. Il faut donc qu'elle retourne le point a l'instant t et tous les points d'avant, sinon, on pourra pas faire fourier.

[Asterix20]

Très bien, je vous remercie, je vais essayer de réaliser un programme grâce à vos indications.
Je reviens vers vous des que j'ai du nouveau.