Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
On parle des Pics, sans rapport avec le langage ou la programmation

Modérateur : Jérémy

Utilisation du coprocesseur flottant Micromega uM-FPU
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1126
Enregistré en : juillet 2016
Localisation : Terre

#21 Message par Temps-x » jeu. 28 févr. 2019 01:33

Bonsoir Claudius et à tous,

Claudius a écrit :Source du message Quelle satisfaction intellectuelle !


A que ouais, et je comprends ton point de vu, c'est bien pour cela que je pratique l'assembleur.

Merci ! pour le retour

==> A++
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

Utilisation du coprocesseur flottant Micromega uM-FPU
Claudius
Avatar de l’utilisateur
Amateur
Amateur
Messages : 180
Âge : 64
Enregistré en : septembre 2015
Localisation : ELANCOURT (78 - YVELINES)
Contact :

#22 Message par Claudius » mer. 3 avr. 2019 14:30

Bonjour à tous,

Temps-x a écrit:

Merci ! pour le retour

==> A++

Comme convenu, je reviens vers vous pour vous présenter les 1st échanges en I2C Software entre un pic 16f628A et le coprocesseur flottant 32 bits uM-FPU V3.1 :-D

En fait, je n'ai pas implémenté de calculatrice avec les 4 opérations comme indiqué au post #6 (cela viendra peut-être un jour), mais plutôt les 2 seules commandes élémentaires Write I2C / Read I2C (en se plaçant coté pic) qui permettent de réaliser toutes les opérations souhaitées et ce, au plus près du coprocesseur :geek:

Ci-après, quelques échanges commentés, exécutés avec un terminal série et à étudier avec les 2 documents uM-FPU V3.1 Datasheet et uM-FPU V3.1 Instruction Set en guise de livre de chevet :wink:

Code : Tout sélectionner

# Revision du programme pic 16f628A (UART <-> I2C)
U2I 1.74


Code : Tout sélectionner

# Version de l'uM-FPU
0x64-2> write 0x00F3        # Ecriture de l'opcode VERSION
0x64-3> write 0x00F2        # Ecriture de l'opcode READSTR
0x64-4> reada               # Lecture ASCII du "String Buffer" jusqu'au '\0' terminal
"uM-FPU V3.1.2"


Code : Tout sélectionner

# Acces au nombre PI et presentation (valeur decimale et flottante 32 bits)
0x64-5> write 0x005E        # Ecriture de l'opcode LOADPI (reg[0] = 3.1415927)
0x64-7> write 0x001F77      # Ecriture de l'opcode FTOA,119 (format sur 11 caracteres avec 9 decimales)
0x64-8> write 0x00F2        # Ecriture de l'opcode READSTR
0x64-9> reada               # Lecture ASCII du "String Buffer" jusqu'au '\0' terminal
"3.141592741"

0x64-33> write 0x001B       # Ecriture de l'opcode FREADA
0x64-34> readh 4            # Lecture hexadecimale des 4 octets du "String Buffer"
0x40490FDB                  # Valeur du flottant sur 32 bits a la norme IEEE 754


Code : Tout sélectionner

# Calcul de 2 * PI (regA] + reg[0] = 2 * reg[A])
0x64-35> write 0x000100     # Ecriture de l'opcode SELECTA,0 (reg[A] "vu" comme reg[0])
0x64-36> write 0x002100     # Ecriture de l'opcode FADD,0 (reg[A] = reg[A] + reg[0] = 2 * reg[0])
0x64-37> write 0x001F76     # Ecriture de l'opcode FTOA,118 (format sur 11 caracteres avec 8 decimales)
0x64-38> write 0x00F2       # Ecriture de l'opcode READSTR
0x64-39> reada              # Lecture ASCII du "String Buffer" jusqu'au '\0' terminal
" 6.28318548"               # Padding a gauche avec un caractere ' ' pour completer a 11 caracteres


Code : Tout sélectionner

# Calcul de la division flottante 355 / 113 (tres bonne approximation de PI ;-) et presentation avec 2 decimales
0x64-80> write 0x000101     # Ecriture de l'opcode SELECTA,1 (reg[A] "vu" comme reg[1] pour detacher reg[A] de reg[0])
0x64-81> write 0x005B0163   # Ecriture de l'opcode LOADWORD,355 (reg[0] = float(signed 1 * 256 + 0x63))
0x64-82> write 0x0029       # Ecriture de l'opcode FSET0 (reg[A] = reg[0])
0x64-83> write 0x005B0071   # Ecriture de l'opcode LOADWORD,113 (float(signed 0 * 256 + 0x71))
0x64-84> write 0x002E       # Ecriture de l'opcode FDIV0 (reg[A] = reg[A] / reg[0] = 355. / 113.)
0x64-85> write 0x001F2A     # Ecriture de l'opcode FTOA,42 (format sur 4 caracteres avec 2 decimales)
0x64-86> write 0x00F2       # Ecriture de l'opcode READSTR
0x64-87> reada              # Lecture ASCII du "String Buffer" jusqu'au '\0' terminal
"3.14"


Code : Tout sélectionner

# Acces au nombre E et presentation (valeur decimale et flottante 32 bits)
0x64-212> write 0x005D      # Ecriture de l'opcode LOADE (reg[0] = 2.7182818)
0x64-213> write 0x001F77    # Ecriture de l'opcode FTOA,119 (format sur 11 caracteres avec 9 decimales)
0x64-214> write 0x00F2      # Ecriture de l'opcode READSTR
0x64-215> reada             # Lecture ASCII du "String Buffer" jusqu'au '\0' terminal
"2.718281745"

0x64-216> write 0x001B      # Ecriture de l'opcode FREADA
0x64-217> readh 4           # Lecture hexadecimale des 4 octets du "String Buffer"
0x402DF854                  # Valeur du flottant sur 32 bits a la norme IEEE 754


Les valeurs des nombres flottants IEEE 754 peuvent être vérifiés au moyen du convertisseur en ligne : Float (IEEE754 Single precision 32-bit)

Le programme du pic 16f628A est disponible ici: UM-FPU-V3.1.asm avec son listing généré par gpasm / gplink

A suivre avec en autre un interpréteur nom de l'opcode vers commande à envoyer à destination du coprocesseur + écriture / lecture / exécution de la liste de ces opcodes dans une EEPROM série externe type AT24C256 que le programme pic 16f628A gère déjà ainsi que tous autres périphériques I2C pourvu que leur adresse soit sur 7 bits + R/W

Utilisation du coprocesseur flottant Micromega uM-FPU
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1126
Enregistré en : juillet 2016
Localisation : Terre

#23 Message par Temps-x » mer. 3 avr. 2019 20:14

Bonsoir Claudius, et tout le forum

Déjà un grand Merci ! pour tout ce que tu apportes, je me pose une question, si le coprocesseur fonctionne à la même vitesse qu'un microcontrôleur.

Les calculs se feront à la même vitesse qu'un microcontrôleur, dans ce cas là, pourquoi ne pas utiliser 2 microcontrôleurs.

Un qui serait chargé de faire le calcul (avec les 4 opérations) et l'autre qui ferait les tachent domestiques :sifflotte:

Cela serait moins compliqué que de passer par un coprocesseur qui demande un savoir.

Et je dirais même qu'il serait intéressant de le faire, et de le présenter sur ce forum, pour que des personnes puisse l'utiliser.


c'est juste une idée

A++
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

Utilisation du coprocesseur flottant Micromega uM-FPU
Claudius
Avatar de l’utilisateur
Amateur
Amateur
Messages : 180
Âge : 64
Enregistré en : septembre 2015
Localisation : ELANCOURT (78 - YVELINES)
Contact :

#24 Message par Claudius » mer. 3 avr. 2019 21:50

Bonsoir Temp-x et Re tout le monde,

Effectivement, avec maintenant les bêtes de course disponibles à des fréquences élevées, le coprocesseur sera moins performant
Cf. le document Floating Point Hardware Support on Microcontrollers - § 4. Testing and Results - Page 24

Maintenant, l'idée de paralléliser avec ou sans coprocesseur est très bonne pour peu que l'architecture soit bien étudiée pour répartir les tâches sur chaque µC en vérifiant qu'aucun ne se tourne les pouces en attendant alors que l'autre en a raz la casquette (grand classique du consommateur et du producteur avec risques de famine et/ou de saturation)

Après, même dans l'industrie, on préfère aller au plus vite et efficace en terme d'étude de l'architecture avec un unique µC (souvent surdimensionné) sachant que 6 mois après, sortira une nouvelle bête de course pour moins chère bien que la loi de Moore ne soit plus d'actualité...

Utilisation du coprocesseur flottant Micromega uM-FPU
satinas
Passioné
Passioné
Messages : 376
Enregistré en : novembre 2015

#25 Message par satinas » jeu. 4 avr. 2019 09:38

Bonjour à tous,

Beau travail, en plus compatible 16F, avec la gestion des banks, qui n'est pas simple.
J'aime bien l'i2c hardware, il pourra servir à ceux qui s'y intéresse. L'autobaud, là tu t'es fait plaisir :)

Je trouve effectivement ces coprocesseurs très utiles dans la programmation asm, car se taper les nombres flottants en asm, il faut avoir du courage ... Le seul inconvénient est le temps consommé par le dialogue entre les 2 processeurs.

Mais dès qu'on passe en langage évolué, les flottants sont reconnus, autant garder un seul processeur et adapter sa vitesse au besoin, comme le dit Claudius.
Les processeurs 16 et 32 bits sont simples à démarrer. Les périphériques uart, i2c, ... se programment de la même façon que sur les 8 bits.
Il y a des pic 16 et 32 bits en boitier DIP, compatibles MPLAB sans le X pour les plus anciens.
Sur les Pic32, ils en sont à 250 MHz, en format MIPS32, une instruction machine par cycle, le bus des périphériques à 100 MHz.

Je suis incapable de faire un typon, si un pro du circuit imprimé fait un typon avec un 18F, un copro, un connecteur annexe pour clavier, lcd, ... je suis partant, car on pense tout de suite à l'application calculette, mais il y en a bien d'autres.

Utilisation du coprocesseur flottant Micromega uM-FPU
Claudius
Avatar de l’utilisateur
Amateur
Amateur
Messages : 180
Âge : 64
Enregistré en : septembre 2015
Localisation : ELANCOURT (78 - YVELINES)
Contact :

#26 Message par Claudius » jeu. 4 avr. 2019 12:25

Bonjour satinas et à tous,

Merci pour les encouragements et effectivement je me suis fais plaisir avec l'autobaud (encore que c'est plus dans un soucis de test sans reprogrammation du PIC et ce, avec différentes vitesses UART - de 1200 bauds min à 19200 bauds max avec un PIC cadencé à 4 MHz - qui peuvent mettre en évidence des problèmes de gestion d'IT et paradoxalement d'overflow/underflow dudit PIC au niveau de la FIFO de réception/transmission des caractères notamment)

L'autobaud avec son principe et implémentation (en assembleur ;-) pourrait faire l'objet d'un fil de discussion à part entière à initier dès qu'une demande se présente ...

Après l'I2C Software, je compte tout naturellement passer en I2C Hardware + support de plusieurs maîtres (c'est pour le fun ;-) dès que j'aurai choisi un pic16 de la famille Enhanced Mid-Range dont j'ai détaillé leurs instructions supplémentaires ;-)

@ Le seul inconvénient est le temps consommé par le dialogue entre les 2 processeurs.
C'est vrai, mais si vraiment rédhibitoire dans un projet, passer au SPI Hardware à la vitesse max supportée par le µC et le coprocesseur qui est de 5 Mhz max en continu et 15 MHz max ponctuellement sur l'horloge de l'uM-FPU en respectant les 15 µS min du Read Setup Delay

@ Les périphériques uart, i2c, ... se programment de la même façon que sur les 8 bits.
Très bonne remarque et tellement vrai :-D ... principe qui évite de dépendre d'une librairie dont on ne connait pas le contenu hormis les méthodes d'entrées et malheureusement trop souvent non optimisée avec une taille non négligeable ... c'est là qu'il faut passer du C (ou autre langage ;-) à l'assembleur avec comme toujours la datasheet en guise de livre de chevet

@ Calculette
Comme la HP-35 de 1972 ... avec la légendaire notation polonaise inverse :-D
ScreenClip-HP-35-1972.jpg
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.

Utilisation du coprocesseur flottant Micromega uM-FPU
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 732
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#27 Message par F6FCO » jeu. 4 avr. 2019 23:03

Bonsoir tout le monde,
Merci Claudius de nous livrer ton travail, je suis allé voir ton programme sur le 16F628 mais je suis dépassé :? J'ai encore du travail pour être au niveau.
Mais je vais retourner mettre le nez dedans c'est formateur.

@Satinas, c'est avec plaisir que je t'aurai gravé ce circuit mais pour l'instant j'en suis malheureusement incapable, n'ayant toujours pas d'atelier disponible, mes machines sont stockées par terre, dans une grange, complètement inertes :cry:
Une porte nand prend 2 bits en entrée... la cochonne !!! 8-)

Utilisation du coprocesseur flottant Micromega uM-FPU
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1126
Enregistré en : juillet 2016
Localisation : Terre

#28 Message par Temps-x » ven. 5 avr. 2019 15:26

Bonsoir Claudius, F6FCO, satinas et tout le forum,

satinas a écrit :Source du message Je suis incapable de faire un typon, si un pro du circuit imprimé fait un typon avec un 18F, un copro, un connecteur annexe pour clavier, lcd, ... je suis partant, car on pense tout de suite à l'application calculette, mais il y en a bien d'autres.


As tu fais le typhon schématique (avec logiciel) ?

Pour que je puisse voir si c'est faisable.

==> A+
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

Utilisation du coprocesseur flottant Micromega uM-FPU
satinas
Passioné
Passioné
Messages : 376
Enregistré en : novembre 2015

#29 Message par satinas » ven. 5 avr. 2019 16:09

Bonjour,
Temps-x a écrit :Source du message As tu fais le typhon schématique (avec logiciel) ?

Ca fait longtemps que j'ai pas fait de carte, j'expérimente beaucoup et les schémas se font au crayon HB :). Les cartes Arduino et autres permettent de s'en dispenser. Quand je vois la vitesse à laquelle vous sortez des cartes.
J'avais fait des essais sur Eagle assez laborieux, j'en rajoute toujours trop, et cela me renvoie vers le soft, qui lui n'a pas de fin.
Là je pensais à une carte universelle 16F/18F avec copro, qui permettrait à chacun de bidouiller ses propres applis.
C'était juste une idée , il n'y a pas d'urgence.

Utilisation du coprocesseur flottant Micromega uM-FPU
Claudius
Avatar de l’utilisateur
Amateur
Amateur
Messages : 180
Âge : 64
Enregistré en : septembre 2015
Localisation : ELANCOURT (78 - YVELINES)
Contact :

#30 Message par Claudius » jeu. 18 avr. 2019 17:06

Bonjour à tous,
Claudius à écrit:
...
A suivre avec en autre un interpréteur nom de l'opcode vers commande à envoyer à destination du coprocesseur...

Voilà c'est fait et je vous propose donc le résultat réel exécuté par le programme uM-FPU-V3.1.16f628a.lst sur la platine personnelle ScreenClip-Kidcad-U2I-1.0.0.jpg et tiré de l'exemple de l'uM-FPU V3 IDE User Manual - page 48/75; à savoir le calcul du diamètre, du périmètre et de la surface d'un cercle de rayon donné:

Code : Tout sélectionner

# Treatments from [./U2I-Serial/FileCommands-Circle.txt]...
# Set termio parameters...
# Send '?' character for 'autobaud'...
U2I 1.78
0x800000 0
0x64-0>   write 0x0000         NOP

# Calcul du Diametre, Circonference et Aire
# d'un cercle de rayon 'RadiusValue' / 1000

#define   RadiusValue   2575

#define Radius           10   # Radius dans reg[10]
#define Diameter         11   # Diameter dans reg[11]
#define Circumference    12   # Circumference dans reg[12]
#define Area             13   # Aera dans reg[13]

#define FORMAT           63   # Formatage sur 6 digits et 3 decimales

# Get Synchro character -----
0x64-1>   write 0x00f0         SYNC                     # Synchronization
0x64-2>   readh 1                                       # Lecture 'string buffer' sur 1 byte
0x5C
0x64-3>   write 0x0000         NOP

# Version de l'uM-FPU -------
0x64-4>   write 0x00f3         VERSION                  # Get version
0x64-5>   write 0x00f2         READSTR
0x64-6>   reada                                         # Lecture 'string buffer' en ASCII jusqu'au '\0'
"uM-FPU V3.1.2"
0x64-7>   write 0x0000         NOP

# Debut du programme --------
0x64-8>   write 0x00010a       SELECTA,Radius           # reg[A] vu comme reg[] contenant le rayon
0x64-9>   write 0x005b0a0f     LOADWORD,RadiusValue     # reg[0] initialise a la valeur du rayon
0x64-10>  write 0x0029         FSET0                    # reg[A] = reg[0]
0x64-11>  write 0x005b03e8     LOADWORD,1000            # reg[0] initialise a la valeur 1000
0x64-12>  write 0x002e         FDIV0                    # reg[A] = reg[A] / reg[0]
0x64-13>  write 0x001f3f       FTOA,FORMAT              # Conversion de reg[A] en ASCII suivant 'FORMAT'
0x64-14>  write 0x00f2         READSTR                  # Lecture du 'string buffer' (chaine ASCII sans le '\0')
0x64-15>  reada                                         # Lecture 'string buffer' en ASCII jusqu'au '\0'
" 2.575"
0x64-16>  write 0x00010b       SELECTA,Diameter         # reg[A] vu comme reg[] contenant le diametre
0x64-17>  write 0x00200a       FSET,Radius              # reg[A] = reg[] contenant le rayon
0x64-18>  write 0x003602       FMULI,2                  # reg[A] = reg[A] * 2 (diametre = 2 * rayon)
0x64-19>  write 0x001f3f       FTOA,FORMAT              # Conversion de reg[A] en ASCII suivant 'FORMAT'
0x64-20>  write 0x00f2         READSTR                  # Lecture du 'string buffer' (chaine ASCII sans le '\0')
0x64-21>  reada                                         # Lecture 'string buffer' en ASCII jusqu'au '\0'
" 5.150"
0x64-22>  write 0x00010c       SELECTA,Circumference    # reg[A] vu comme reg[] contenant la circonference
0x64-23>  write 0x005e         LOADPI                   # reg[0] = 3.1415927 (PI)
0x64-24>  write 0x0029         FSET0                    # reg[A] = reg[0] = PI
0x64-25>  write 0x00240b       FMUL,Diameter            # reg[A] = reg[A] * reg[] contenant le diametre (circonference = PI * diametre)
0x64-26>  write 0x001f3f       FTOA,FORMAT              # Conversion de reg[A] en ASCII suivant 'FORMAT'
0x64-27>  write 0x00f2         READSTR                  # Lecture du 'string buffer' (chaine ASCII sans le '\0')
0x64-28>  reada                                         # Lecture 'string buffer' en ASCII jusqu'au '\0'
"16.179"
0x64-29>  write 0x00010d       SELECTA,Area             # reg[A] vu comme reg[] contenant l'aire
0x64-30>  write 0x005e         LOADPI                   # reg[0] = 3.1415927 (PI)
0x64-31>  write 0x0029         FSET0                    # reg[A] = reg[0] = PI
0x64-32>  write 0x00240a       FMUL,Radius              # reg[A] = reg[A] * reg[] contenant le rayon
0x64-33>  write 0x00240a       FMUL,Radius              # reg[A] = reg[A] * reg[] contenant le rayon (aire = PI * rayon * rayon)
0x64-34>  write 0x001f3f       FTOA,FORMAT              # Conversion de reg[A] en ASCII suivant 'FORMAT'
0x64-35>  write 0x00f2         READSTR                  # Lecture du 'string buffer' (chaine ASCII sans le '\0')
0x64-36>  reada                                         # Lecture 'string buffer' en ASCII jusqu'au '\0'
"20.831"
# Fin du programme ----------

Pour le fun, le même programme a exécuté la liste de commandes suivante permettant de résoudre l'équation du second degré a * x^2 + b * x + c = 0 pour peu que a et c soient dans la plage [-128, ..., +127] (8 bits signés) et b dans la plage [-32768, ..., +32767] (16 bits signés):

Code : Tout sélectionner

# Treatments from [./U2I-Serial/FileCommands-Trinome.txt]...
# Set termio parameters...
# Send '?' character for 'autobaud'...
U2I 1.78
0x800000 0
0x64-0>   write 0x0000         NOP

# Calcul des 2 racines reelles du trinome
# a.x^2 + b.x + c = 0 avec des coefficients entiers et dans la limite de:
# 1. a et c dans la plage [-128, ..., +127] (cf. FDIVI, FMULI)
# 2. b dans la plage [-32768, ..., 32767] (cf. LOADWORD)

# Note: Pas de test si le discrinant est negatif (NaN calcule ;-)

# Definitions ---------------
#define   a                1
#define   b               -1
#define   c               -1

#define Discriminant   10   # Discriminant dans reg[10]
#define Racine_1       11   # 1er racine reelle dans reg[11]
#define Racine_2       12   # 2nd racine reelle dans reg[12]

#define Temp_1         13   # Registre temporaire dans reg[13]
#define Temp_2         14   # Registre temporaire dans reg[14]

#define FORMAT_0_0      0    # Formatage au mieux
#define FORMAT_6_3     63    # Formatage sur 6 digits et 3 decimales
#define FORMAT_11_8   118    # Formatage sur 11 digits et 8 decimales

#define FORMAT   FORMAT_0_0   # Multiple define supporte ;-)
# Fin des definitions -------

# Debut du programme --------
# Calcul du discrimimant: D = (b^2 - 4ac)
0x64-1>   write 0x00010d       SELECTA,Temp_1           # reg[A] vu comme Temp_1
0x64-2>   write 0x005bffff     LOADWORD,b               # reg[0] = valeur de b
0x64-3>   write 0x0029         FSET0                    # reg[A] = reg[0]
0x64-4>   write 0x00240d       FMUL,Temp_1              # reg[A] = reg[A] * Temp_1 = b^2
0x64-5>   write 0x00010e       SELECTA,Temp_2           # reg[A] vu comme Temp_2
0x64-6>   write 0x005b0004     LOADWORD,4               # reg[0] = 4
0x64-7>   write 0x0029         FSET0                    # reg[A] = reg[0]
0x64-8>   write 0x003601       FMULI,a                  # reg[A] = 4a
0x64-9>   write 0x0036ff       FMULI,c                  # reg[A] = 4ac
0x64-10>  write 0x00010d       SELECTA,Temp_1           # reg[A] vu comme Temp_1 = b^2
0x64-11>  write 0x00220e       FSUB,Temp_2              # reg[A] = (b^2 - 4ac)
0x64-12>  write 0x0041         SQRT                     # reg[A] = sqrt(b^2 - 4ac) = D
0x64-13>  write 0x001f00       FTOA,FORMAT              # Formatage
0x64-14>  write 0x00f2         READSTR                  # Affichage
0x64-15>  reada                                         # Lecture 'string buffer' en ASCII jusqu'au '\0'
"2.236068"
0x64-16>  write 0x00080a       COPYA,Discriminant       # Save discriminant = (b^2 - 4ac)

# Calcul de la 1st racine reelle: x1 = (-b - sqrt(b^2 - 4ac)) / 2a
0x64-17>  write 0x005bffff     LOADWORD,b               # reg[0] = valeur de b
0x64-18>  write 0x0029         FSET0                    # reg[A] = reg[0]
0x64-19>  write 0x00210a       FADD,Discriminant        # reg[A] = (b + D)
0x64-20>  write 0x003702       FDIVI,2                  # reg[A] = reg[A] / 2
0x64-21>  write 0x003701       FDIVI,a                  # reg[A] = reg[A] / a
0x64-22>  write 0x003e         FNEG                     # reg[A] = -reg[A] = (-b - sqrt(b^2 - 4ac)) / 2a
0x64-23>  write 0x001f00       FTOA,FORMAT              # Formatage
0x64-24>  write 0x00f2         READSTR                  # Affichage
0x64-25>  reada                                         # Lecture 'string buffer' en ASCII jusqu'au '\0'
"-0.61803398"
0x64-26>  write 0x00080b       COPYA,Racine_1           # Save 'Racine_1'

# Calcul de la 2nd racine reelle: x2 = (-b + sqrt(b^2 - 4ac)) / 2a
0x64-27>  write 0x005bffff     LOADWORD,b               # reg[0] = valeur de b
0x64-28>  write 0x0029         FSET0                    # reg[A] = reg[0]
0x64-29>  write 0x00220a       FSUB,Discriminant        # reg[A] = (b - D)
0x64-30>  write 0x003702       FDIVI,2                  # reg[A] = reg[A] / 2
0x64-31>  write 0x003701       FDIVI,a                  # reg[A] = reg[A] / a
0x64-32>  write 0x003e         FNEG                     # reg[A] = -reg[A] = (-b + sqrt(b^2 - 4ac)) / 2a
0x64-33>  write 0x001f00       FTOA,FORMAT              # Formatage
0x64-34>  write 0x00f2         READSTR                  # Affichage
0x64-35>  reada                                         # Lecture 'string buffer' en ASCII jusqu'au '\0'
"1.6180339"
0x64-36>  write 0x00080c       COPYA,Racine_2           # Save 'Racine_2'
# Fin du programme ----------

Les tests non exhaustifs normaux et aux limites réalisés sont:

Code : Tout sélectionner

# Solutions du trinôme a * x^2 + b * x + c = 0 avec
# 1. a et c dans la plage [-128, ..., +127] (8 bits signés)
# 2. b dans la plage [-32768, ..., +32767] (16 bits signés)
# ---------------------------------------------------------

# Exemples valides:
#    a       b       c  Discriminant     Racine_1       Racine_2    Commentaire
# ----  ------    ----  ------------   ----------   ------------    -----------
#    1      -1      -1      2.236068  -0.61803398      1.6180339    Nombre d'or
#    4     -12       9           0.0          1.5            1.5    Racine double
# -128   32767       1     32767.007    255.99221  -3.0517578E-5    Min/Max coeficients #1
#  127  -32768    -128     32768.992  -0.00390625      258.01965    Min/Max coeficients #2
#    6       5       1           1.0         -0.5    -0.33333334    2 racines negatives
#    1       0      -1     2.8284271   -1.4142135      1.4142135    Racines de (x^2 - 2) = 0 => +/-sqrt(2)
#   -1       0       4           4.0          2.0           -2.0    Racines de (-x^2 + 4) = 0 => +/-2
#    1   32767       1       32767.0     -32767.0            0.0    b >> a => ~(32767 x b + 1)
#    1       1    -128     22.649503   -11.824751      10.824751    x1 + x2 = -1 et x1 * x2 = -127.999985212

# Exemples non valides:
#    a       b     c    Discriminant     Racine_1       Racine_2    Commentaire
# ----  ------  ----    ------------  -----------  -------------    -----------
#    0       1     1             1.0    -Infinity            NaN    Division par 0 a cause de a = 0
#    0      -1     1             1.0          NaN       Infinity    Division par 0 a cause de a = 0
#    1       1     1             NaN          NaN            NaN    Discriminant negatif (pas de solutions reelles)

Je continue d'explorer les autres capacités de l'uM-FPU avec notamment le calcul trigonométrique et matriciel (je n'irai pas jusqu'à la transformation de Fourrier ... encore que ;-), ainsi que le traitement des chaînes de caractères (moins intéressant en soit mais toujours instructif ;-) et pourquoi pas une connexion avec un convertisseur DAC pour générer par exemple des formes d'ondes, voire des courbes de Lissajous permettant de qualifier visuellement la génération des fonctions cos() et sin()...

La grande prochaine étape est de télécharger un programme dans l'eeprom série de la platine afin d’évacuer un maximum d'échanges UART avec le PIC qui sont traduits en I2C vers l'uM-FPU V3.1 et après exécuter le même programme dans la mémoire flash de l'uM-FPU V3.1
Il n'y aura alors pratiquement plus d'échanges UART ni I2C hormis ceux pour l'entrée des paramètres de calcul et ceux en retour pour la présentation des résultats...

C'est là que l'uM-FPU fournira le maximum de performance que je ne manquerai pas de mesurer et la boucle sera bouclée du moins pour l'uM-FPU V3.1 car je suis toujours à la recherche d'un uM-FPU64 qui semble à jamais indisponible :eek:

À suivre...


Retourner vers « Généralités sur les PICs »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 0 invité