Adaptateur Tension : Donne les Résistances d'un Pont

[MSG]

Tu as un peut modifier les formules !!!

Moi j'ai trouvé : R2 = Vout * R1 / (Vin - Vout)
Toi , tu as : R2 = R1 / (Vin/Vout -1)

Donc pour te rejoindre , je ne suis pas expert ...je marche sur des œufs ...
R2 = Vout * R1 / (Vin - Vout)
R2 = R1 * Vout / (Vin - Vout)
là , je pense qu'il faut diviser par l'inverse de Vout / (Vin - Vout)
R2 = R1 * 1 / ((Vin - Vout) / Vout)
R2 = R1 / ((Vin - Vout) / Vout)
ce qui donne ... en distribuant Vout à (Vin - Vout)
R2 = R1 / (Vin/Vout - Vout/Vout)
Y a plus qu'à simplifier ...
R2 = R1 / (Vin/Vout - 1)

Et la boucle est bouclée .

J'ai pas fait les calculs à plat (en ligne) , mais en écriture fractionnaire sur papier , j'ai juste retranscrit .

Comme quoi , tous les chemins mènent à Rome ... et à Paris !

[Bud Spencer]

Tu as un peut modifier les formules !!!

simple faute de frappe, j'ai corrigé

J'ai pas fait les calculs à plat (en ligne) , mais en écriture fractionnaire sur papier , j'ai juste retranscrit .

Je pense que l'on fait tous pareil. Pour ce genre de truc, je fais de tête (juste la formule hein, pas le résultat) et des que ca se complique un peu c'est papier crayon et décomposition jusqu'à arriver au plus court avec le moins d'operations possible

[Bud Spencer]

J’ai regardé ton code pour les couleurs et c’est vraiment très bien. Je pensais au premier coup d’œil en regardant juste ton tableau de couleurs que tu étais partie dans un truc infernal, mais finalement les valeurs autre que les noms de couleur ne servent à rien ici et fondamentalement, tu as utilisé exactement la meme méthode que moi qui consiste à ramener la valeur de la résistance à 3 chiffres tout en préservant un indice pour le multiplicateur.

De mon côté, je passe la valeur de la résistance et un paramètre facultatif (booléen) qui spécifie si je veux forcer à 3 bandes de couleurs maxi ou pas et je sors par défaut à 4 bandes pour toutes les résistance au-dessus de 0.1 ohm. J’ai aussi prévue que si la valeur passée est < 0.1 ohm, cela me retourne juste une bande noir (0 ohm).

Il y a toutefois un petit bug dans ton code. Si par exemple tu veux résoudre une résistance de 0.68 ohms, ça marche, mais si tu essais avec 0.681, il te dis que la valeur est trop petite. Je t’accorde que ce sont des valeurs peu probables, mais ce qui compte, c’est la subtilité de l’algo et surtout sa fiabilité . J'ai passé des années a corriger et a noter du code d'élèves, donc forcement il y a des trucs qui ne m'échappent pas

Je te laisse corriger ça et ensuite je te montrerais mon code (en c#, mais c'est le principe qui compte) et je t’expliquerais quelques trucs utiles quand tu veux optimiser du code

[MSG]

Bonjour ,

Je n'ai pas l'habitude de bricoler avec des résistances trop petites ni avec des codes à 4 chiffres .
Donc j'ai un peu improvisé sachant que mon code n'est certainement pas parfait pour les valeurs les plus petites.

Selon le code des couleurs , le multiplicateur le plus petit est le code Argent avec l'exposant -2 , on ne doit pas pouvoir descendre plus bas que :
1 Ω pour le code à 3 chiffres et multiplicateur : 1 0 0 -2 qui correspond à 100 * 1e-2 ou 100 * 10** -2
et
0,1 Ω pour le code à 2 chiffres et multiplicateur 1 0 -2 qui correspond à 10 * 1e-2 ou 10 * 10** -2

A moins que je me trompe et qu'il soit possible d'avoir un code mixte OR + ARGENT qui permet de descendre plus bas avec un multiplicateur à 1e-3 !?

Pour le multiplicateur le plus grand , pareil c'est le Violet 1e7 donc pas plus de :
9,99 GΩ = 999 * 1e7 = 999 * 10** 7
990 MΩ = 99 * 1e7 = 99 * 10** 7

[Bud Spencer]

pour les valeur, c'est bien ca. Une redistance < 1 ohm ne peut être résolu qu'en code 3 couleur et en 3 couleur on ne peut pas résoudre en dessous de 0.1 ohms. j'ai tenu compte de ca dans ma fonction et la première ligne de celle ci redéfinie toutes valeur < 0.1 comme étant 0 et me retourne juste 1 bande noire (marquage standard des résistance 0 ohms).

Le problème n'est pas vraiment la avec ton bug. Le soucis, c'est que si cette résistance est le résultat d'un calcul, elle peut très bien être inferieur à 1 et supérieur à 0.1 et si c'est le cas et qu'il y a plus de 2 décimales, ton code ne fonctionne pas (et pourtant il ne manque pas grand chose). Il retourne même une erreur d'appréciation puisque si ca fonctionne avec 0.68 il ne devrait pas te dire que 0.681 est trop petit.

Autre problème (qui n'est pas un bug, mais plutôt une limite facile à depasser), c'est que ta fonction ne sait pas retourner un code a 4 couleurs si le 3 eme chiffre est un 0. Pourtant une résistance par exemple de 200 homs peut s'écrire en 3 (rouge noir marron) ou en 4 barre (rouge noir noir noir).
Tout ca se trouve dans ton if qui regarde si le 3 eme nombre est un 0 ou pas.

Mon code est très proche du tiens (en fonctionnalité en tous cas). Même déport à gauche et à droite pour arriver a 3 chiffres. La seul différence, c'est que moi je défini la taille du tableau de retour des le début (taille 3 ou 4 suivant la valeur de la résistance et si je veux forcer la imite a 3 couleur ou pas), ce qui me permet de faire pour la suite un code beaucoup plus concis.

color.png (39.16 Kio) Vu 6175 fois

Dans la dernière 'evolution', j'ai cette ligne en début de fonction pour justement ne pas rester planté dans la première itération si on passe une résistance = 0 et pour retourner une seule bande noir si elle est > 0 < 0.1 . La fonction est aussi un peut différente dans le sens ou j'avais remis or et argent en fin de tableau ou avoir un index qui a le même nombre que la couleur

Code : Tout sélectionner

if (r <= 0.1) { return new int[] { 2 }; }

[MSG]

Les tables de résistances commencent toutes à 10 (2 chiffres) ou à 100 (3 chiffres) et non à 0,1 ou 0,01 , donc il est impossible de mettre le 0 sur le premier chiffre , ni sur le second chiffre si le premier est nul aussi , quant au 3eme chiffre n'en parlons pas , ou alors pour indiquer un shunt 00 et 000 .
A moins que je ne me trompe !?

Ensuite , les valeurs de résistances ne se suivent pas , il y a des couleurs (valeurs) que tu ne trouvera pas , comme le 140, 170 190, 210 (deux et trois chiffres), etc , j'ai pas compter , mais sont nombreuses .
Alors pour faire un arrondi , il faut le faire avant de demander la couleur (en comparaison des valeurs de table choisie E12,24,48,96,192) , sinon tu risque de tomber sur un code couleur inexistant .

Les E3 à E24 sont à deux chiffres et les E48 à E192 sont à 3 chiffres d'après Wikipédia .

https://fr.wikipedia.org/wiki/CEI_60063

[Bud Spencer]

Si si, les résistance de 0 et de 0.1 ohm sont assez fréquente (utilisée généralement en strap) et il existe aussi des résistances de précision entre 0.1 et 10 ohm et même certaines bien spécialisées qui sortent du cadre des normes (notamment utilisée dans des systèmes à pont de Wheatstone). Même si avec le numérique et les temps modernes cela devient de plus en plus rare, on trouvait aussi autrefois dans des appareils de mesure des résistance ajustable qui avaient reçues des points de peinture qui correspondaient à la valeur d'étalonnage et qui pourtant ne se trouvait pas dans une norme. Bref, je t'accorde que ce n'est pas courrant du tout et tu n'en auras sans doute jamais besoin, mais d'un point de vue purement 'programmation', ce sont des bugs et Il y en a d'autres.

Si tu passes 0 à ta fonction, ton programme sera bloqué dedans. 0 multiplié par tout ce que tu veux, ca fera toujours 0 et tu sera toujours bloqué dans while x < 100 jusqu'à un éventuel plantage par débordement de e)

Si tu passe une valeur < à 0.1 avec 3 décimales ou une valeur 'impossible' (trop grande par exemple) ta fonction retourne une string alors que si tout se passe bien, elle retourne une list. Ca c'est vraiment une erreur de débutant. Quand tu développes des fonctions (donc avec retour) fais en sorte que le type de sortie soit toujours le même quoi qu'il arrive (surtout avec python, avec d'autres langages 'propre' tu ne pourrais pas faire cette erreur)

Si tu passe par exemple 22,6 au lieu de 22.6 ton programme plantera à X=float(X). Il est impératif de typer correctement les paramètres avant l'appel, sinon le programme plante dans la fonction. Si tu le fais (contrôle de données saisies au clavier par exemple) alors la ligne ne sert a rien et le programme ne peut pas planter dans la fonction. Ca aussi ca concerne surtout python, avec la plupart des langages 'propre' tu planterais en dehors de la fonction.

pour le reste, c'est juste de l'optimisation, donc je n'en parle pas

Ce sont des détails tu va me dires, mais c'est le genre de détails qu'on appel des bugs. La tu as juste une seul fonction et encore elle est petite, mais si un jour tu veux te lancer dans des programmes plus conséquent qui peuvent contenir des dizaines voir des centaines de fonctions qui se passent des valeurs entre elles et que tu ne fais pas attention à ce genre de truc tu ne t'en sortiras jamais. C'est ce que l'on appelle la robustesse du code et la dessus la loi de murphi est très clair. Tout ce qui est improbable arrivera et moins il y a de chance que ca arrive et plus ca arrivera ...

la conversion de mon code c# en python :

colorpy.png (29.71 Kio) Vu 6144 fois

[Bud Spencer]

r0.png (157.41 Kio) Vu 6131 fois

https://www.aliexpress.com/item/3284144 ... 36231d3-19

zéroohm :
http://www.uchidg.com/sale-2038612-low- ... eater.html

[MSG]

Bonjour ,

Voilà , c'est fait , allégé et fonctionne en import sur la console Python ou à lancer .
Avec une petite cerise sur le gâteau , la gestion d'écriture abrégé .

J'avais un bug avec certains nombres décimaux qui me décalait le résultat , ex : "0.47" me sortait le code 046 , mais c'est réparé .
Je ne sais pas si c'est bien ou pas d'arrondir les valeurs , car suivant il faut taper soit au dessus , soit au dessous de la valeur cherché .
C'est fait .

Code : Tout sélectionner

#!/usr/bin/python3

#
# Resistance code couleurs - MSG - (c) 03/2020
#

def Couleurs (R) :
    code = ('noir',     'marron',   'rouge',
            'orange',   'jaune',    'vert',
            'bleu',     'violet',   'gris',
            'blanc',    'argent',   'or')
    g = m = k = 0
    aff = ''
    if type(R) is str :
        R = R.upper()
        R = R.replace( ',', '.' )
        g = R.count('G')
        m = R.count('M')
        k = R.count('K')
        p = R.count('.')
        if not(p) : 
            if g : R = R.replace( 'G', '.' ) + 'G'
            if m : R = R.replace( 'M', '.' ) + 'M'
            if k : R = R.replace( 'K', '.' ) + 'K'
        else :
            if g : R = R.strip('G') + 'G'
            if m : R = R.strip('M') + 'M'
            if k : R = R.strip('K') + 'K'
        aff = ('%s\n' %R)
        R = [x for x in R if '0' <= x <= '9' or x is '.' ]
        if  R.count('.') > 1    or\
            g + m + k > 1       or\
            R == [] :
            R = 'Erreur'
        else :
            R += [g and 'e9' or m and 'e6' or k and 'e3' or '']
            R = ''.join(R)
            R = float(R)
        
    if  type(R) != int      and\
        type(R) != float    :
        return 'Reformulez le nombre'

    if R == 0 :     return 'noir'
    if R < 0.1 :    return 'Valeur trop petite'
    if R >= 1e10 :  return 'valeur trop grande'

    c0 = 0
    while R < 100 :
        R *= 10
        c0 -= 1
        
    while R >= 1000 :
        R /= 10
        c0 += 1
        
    R = int(round(R))
    aff += ('Valeur : %s Ω\n' % str( R*10**c0 ))
    R = str(R)
    c1 = ' ' + code[ int( R[0] )]
    c2 = ' ' + code[ int( R[1] )]
    c3 = ' ' + code[ int( R[2] )]
    c4 = ' ' + code[ int( c0   )]
    R4c = ('R4c : %s %s %s %s\n' %( c1, c2, c3, c4 ))
    if (c0+1) <= 7 :  
        c3 = ' '+ code[ int( c0+1 )]
        R3c = ('R3c : %s %s %s\n' %( c1, c2, c3 ))
    else :      
        R3c = 'R.c : ?\n'
    if c0 < -2 : 
        R4c = ('R4c :  noir %s %s %s \n' % (c1, c2, c3 ))
    if __name__ == '__main__' : 
        return aff + R3c + R4c
    else : 
        print ('> %s' % (aff + R3c + R4c))



#
# Main
#

if __name__ == '__main__' :
    encore = True
    while encore :
        x = input('\nValeur de résistance ?\n')
        R = Couleurs (x)
        print('Resistance id : %s' % R )
        encore = input('Encore ?')
        encore = encore.lower()
        if  encore == 'n' or encore == 'non' : encore = False

[Bud Spencer]

Il y plusieurs façons d’arrondir un nombre décimal. Supposons que z est un nombre décimal :

z = int(z) : ça, ce n’est pas un arrondi, c’est un cast . On change le type de z de decimal en entier et z contient la partie entière.

z = round(z,x) arrondi z par défaut au nombre de décimale x.
z= round(1.9415,2)= 1.94 ; z=round(1.9455,2)=1.95

z = mat.ceil(z) : arrondi z à l’entier égal ou supérieur
z = mat.ceil(1.0000) = 1.0 ; z = mat.ceil(1.0001) = 2.0

z = mat.floor(z) : z est arrondi à la valeur de l’entier
z = mat.floor(1.0000) = 1.0 ; z = mat.floor(1.9999) = 1.0

z = mat.trunc(z) : z est tronqué de sa partie décimale
z = math.trunc(1.0000) = 1 ; z = math.trunc((1.9999) = 1

Dans mon code en c#, j’avais utilisé Math.Trucate(z). Après le while qui amène à une valeur >= 100, ce que j’avais besoin de récupérer, c’était les 3 nombres de l’entier qui composait cette valeur sans aucun arrondi, donc j’ai tronqué la partie décimale.

Il y a d’autre fonctions d’arrondis ou de cast, mais celle-ci sont les plus utilisées

un autre exercice sympa serai de saisir des couleurs (rouge, vert, noir, marron) pour retourner la valeur de la résistance correspondante et sa 'plus proche' dans une norme. Mathématiquement, c'est tout simple, mais la il faut penser a tous les cas et gérer toutes les erreurs de saisie.