- 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 ---
Modérateur : Jérémy
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.
pour le retour
A++
- Claudius
Passioné- Messages : 260
- Âge : 69
- Enregistré en : septembre 2015
- Localisation : ELANCOURT (78 - YVELINES)
- Contact :
Temps-x a écrit:
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
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
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
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
Déjà un grand 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
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++
- Claudius
Passioné- Messages : 260
- Âge : 69
- Enregistré en : septembre 2015
- Localisation : ELANCOURT (78 - YVELINES)
- Contact :
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é...
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.
- Claudius
Passioné- Messages : 260
- Âge : 69
- Enregistré en : septembre 2015
- Localisation : ELANCOURT (78 - YVELINES)
- Contact :
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 ... 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
- F6FCO
Expert- Messages : 1413
- Âge : 70
- Enregistré en : décembre 2017
- Localisation : Furtif je suis.
- Contact :
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
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+
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.
- Claudius
Passioné- Messages : 260
- Âge : 69
- Enregistré en : septembre 2015
- Localisation : ELANCOURT (78 - YVELINES)
- Contact :
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
À suivre...
Retourner vers « Généralités sur les PICs »
Qui est en ligne
Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 42 invités