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
satinas
Passioné
Passioné
Messages : 381
Enregistré en : novembre 2015

#31 Message par satinas » ven. 19 avr. 2019 09:48

Bonjour à tous,

Ca avance, bravo ! J'avais pas fait gaffe, on reste dans les pics :)
D'après le brochage, le coprocesseur V3 ressemble à un dsPic 30F, le 64 à un pic 32MX, pour le V2 à 8 pattes, ce serait plutôt un ATtiny de Atmel/Microchip. Reste à savoir si ces bêtes ont été programmées en asm ou en C :)
http://www.datasheetdir.com/DSPIC30F201 ... ontrollers

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

#32 Message par Claudius » ven. 19 avr. 2019 10:46

Bonjour satinas et à tous,

Effectivement, je n'avais pas fait le rapprochement (très bonne idée de comparer le brochage pour trouver ce qui se cache derrière la bête ;-)

De plus, le mode PICMODE proposé, confirme l'origine que tu as déterminée:
If the PIC data format has been selected (using the PICMODE instruction), the IEEE 754 format floating point value is converted to PIC format before being sent

@ Reste à savoir si ces bêtes ont été programmées en asm ou en C : Il y a de grande chance que cela soit en C avec l'utilisation d'une bibliothèque flottante sans doute d'origine Microchip sur laquelle a été adjoint une interface d'accès en SPI et I2C

Merci pour le lien et tes encouragements, ce projet me tient à cœur et je ne manquerai pas de vous tenir informé de son avancement et de ses orientations pouvant naturellement évoluer en fonction de vos demandes toujours les bienvenues...

NB: :wink: satinas ... que vois-je dans le fil de discussion Keypad 4x4 ... un PIC16 ... un clavier 16 touches avec les 4 opérations '+', '-', '*' et '/' + un afficheur 16 x 2 et ... une liasion I2C :roll:

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

#33 Message par satinas » ven. 19 avr. 2019 18:23

Il faudrait un clavier avec l'hexa et les parenthèses pour rentrer des formules, histoire de corser la saisie des infos. Si c'est pas déjà fait par le coprocesseur, pour calculer, on passe par la notation polonaise inversée et ça roule.
Va-t-on reparler des lcds tactiles ?
Il y a des 18F de brochage compatible avec le 16F628, ça m'arrange.
Ceci-dit, c'est les coprocesseurs que j'ai envie de faire maintenant :)

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

#34 Message par Claudius » ven. 19 avr. 2019 19:05

@ Il faudrait un clavier avec l'hexa et les parenthèses pour rentrer des formules, histoire de corser la saisie des infos.

En effet, cette notion d'empilement de valeurs intermédiaires (très efficace en notation polonaise inversée) est accessible via les 2 instructions LEFT et RIGHT du coprocesseur :wink:

Ci-après le comportement de celles-ci:
------------------
L’instruction LEFT enregistre la sélection du registre reg[A] en cours, attribue le registre temporaire suivant, définit la valeur du registre temporaire sur le registre actuel reg[A], puis sélectionne le registre temporaire "register as register A (registre vu comme le registre reg[A]".

L'instruction RIGHT est utilisée pour restaurer les valeurs précédentes. Lorsqu'elles sont utilisées ensemble, ces instructions LEFT et RIGHT sont comme des parenthèses dans une équation et peuvent être utilisées pour attribuer les registres temporaires et modifier l’ordre du calcul.

Les parenthèses peuvent être imbriquées jusqu'à huit niveaux.
------------------

Je m'en vais mettre en œuvre et tester ces 2 instructions LEFT et RIGHT...

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

#35 Message par Claudius » mar. 23 avr. 2019 23:33

Bonsoir à tous,
Claudius a écrit:
...
Je m'en vais mettre en œuvre et tester ces 2 instructions LEFT et RIGHT...

Quelques explications par l'exemple suite à leur mise en œuvre en m'inspirant du document Application Note 32 - uM-FPU V3 Long Integer Calculations - Page 5/7 et dont l'exécution de 2 exemples donne:

Code : Tout sélectionner

# 1st exemple: N = M * N
# ----------------------

# Definitions ---------------
#define   M_Value         "142857"   #  Valeur de M
#define   N_Value              "7"   #  Valeur de N

#define M               10      # reg[10]: M
#define N               11      # reg[11]: N
#define T               12      # reg[12]: T

#define Result          20      # reg[20]: Resultat de l'operation

#define FORMAT_0_0   0   # Formatage au mieux
#define FORMAT      FORMAT_0_0
# Fin des definitions -------

# Debut du programme --------
# Initialisation
0x64-1>   write 0x009a31343238353700          ATOL,M_Value      # Valeur de M dans reg[0]
0x64-2>   write 0x00a5                        LSET0             # reg[A] = reg[0]
0x64-3>   write 0x009b00                      LTOA,FORMAT       # Formatage
0x64-4>   write 0x00f2                        READSTR           # Affichage
0x64-5>   reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"142857"
0x64-6>   write 0x00080a                      COPYA,M           # Copy dans M   

0x64-7>   write 0x009a3700                    ATOL,N_Value      # Valeur de N dans reg[0]
0x64-8>   write 0x00a5                        LSET0             # reg[A] = reg[0]
0x64-9>   write 0x009b00                      LTOA,FORMAT       # Formatage
0x64-10>  write 0x00f2                        READSTR           # Affichage
0x64-11>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"7"
0x64-12>  write 0x00080b                      COPYA,N           # Copy dans N   

# Execution de N = M * N
0x64-13>  write 0x0014                        LEFT              # Selection de temp1 vu comme reg[A] qui "pointe" sur N
0x64-14>  write 0x009c0a                      LSET,M            # temp1 = M
0x64-15>  write 0x009f0b                      LMUL,N            # temp1 = temp1 * N
0x64-16>  write 0x0015                        RIGHT             # reg[0] = temp1 et restaure N vu comme reg[A] car dernier RIGHT
# Fin: Execution de N = M * N

# Resultat dans reg[0]
0x64-17>  write 0x00a5                        LSET0             # reg[A] = reg[0]
0x64-18>  write 0x009b00                      LTOA,FORMAT       # Formatage
0x64-19>  write 0x00f2                        READSTR           # Affichage
0x64-20>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"999999"
0x64-21>  write 0x000814                      COPYA,Result

# Valeurs de N et M inchangees
0x64-22>  write 0x009c0b                      LSET,N            # reg[A] = N
0x64-23>  write 0x009b00                      LTOA,FORMAT       # Formatage
0x64-24>  write 0x00f2                        READSTR           # Affichage
0x64-25>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"7"
0x64-26>  write 0x009c0a                      LSET,M            # reg[A] = M
0x64-27>  write 0x009b00                      LTOA,FORMAT       # Formatage
0x64-28>  write 0x00f2                        READSTR           # Affichage
0x64-29>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"142857"
0x64-30>  write 0x0000                        NOP

# 2nd exemple: TF = MF / (NF + TF) en flottant
# --------------------------------------------

# Definitions ---------------
#define   MF_Value       "4567"   #  Valeur de MF
#define   NF_Value        "124"   #  Valeur de NF
#define   TF_Value        "876"   #  Valeur de TF
# Fin des definitions -------

0x64-31>  write 0x001e3435363700              ATOF,MF_Value     # Valeur de MF dans reg[0]
0x64-32>  write 0x0029                        FSET0             # reg[A] = MF
0x64-33>  write 0x001f00                      FTOA,FORMAT       # Formatage
0x64-34>  write 0x00f2                        READSTR           # Affichage
0x64-35>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"4567.0"
0x64-36>  write 0x00080a                      COPYA,M           # Copy dans M

0x64-37>  write 0x001e31323400                ATOF,NF_Value     # Valeur de NF dans reg[0]
0x64-38>  write 0x0029                        FSET0             # reg[A] = NF
0x64-39>  write 0x001f00                      FTOA,FORMAT       # Formatage
0x64-40>  write 0x00f2                        READSTR           # Affichage
0x64-41>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"124.0"
0x64-42>  write 0x00080b                      COPYA,N           # Copy dans N

0x64-43>  write 0x001e38373600                ATOF,TF_Value     # Valeur de TF dans reg[0]
0x64-44>  write 0x0029                        FSET0             # reg[A] = TF
0x64-45>  write 0x001f00                      FTOA,FORMAT       # Formatage
0x64-46>  write 0x00f2                        READSTR           # Affichage
0x64-47>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"876.0"
0x64-48>  write 0x00080c                      COPYA,T           # Copy dans T

# Execution de T = M / (N + T)
0x64-49>  write 0x0014                        LEFT              # temp1 vu comme reg[A] qui "pointe" sur T
0x64-50>  write 0x00200a                      FSET,M            # temp1 = reg[A] = M
0x64-51>  write 0x0014                        LEFT              # temp2 vu comme reg[A]
0x64-52>  write 0x00200b                      FSET,N            # temp2 = reg[A] = N
0x64-53>  write 0x00210c                      FADD,T            # temp2 = reg[A] + T = N + T
0x64-54>  write 0x0015                        RIGHT             # reg[0] = temp2 et restaure temp1 vu comme reg[A]
0x64-55>  write 0x002e                        FDIV0             # temp1 = reg[A] = temp1 / reg[0] = temp1 / temp2 = M / (N + T)
0x64-56>  write 0x0015                        RIGHT             # reg[0] = temp1 et restaure T vu comme reg[A] car dernier RIGHT
# Fin: Execution de T = M / (N + T)

# Resultat dans reg[0]
0x64-57>  write 0x0029                        FSET0
0x64-58>  write 0x001f35                      FTOA,53           # Formatage
0x64-59>  write 0x00f2                        READSTR           # Affichage
0x64-60>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"4.567"
0x64-61>  write 0x0000                        NOP

# Valeurs de N, M et T inchangees
0x64-62>  write 0x00200b                      FSET,N            # reg[A] = N
0x64-63>  write 0x001f00                      FTOA,FORMAT       # Formatage
0x64-64>  write 0x00f2                        READSTR           # Affichage
0x64-65>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"124.0"
0x64-66>  write 0x00200a                      FSET,M            # reg[A] = M
0x64-67>  write 0x001f00                      FTOA,FORMAT       # Formatage
0x64-68>  write 0x00f2                        READSTR           # Affichage
0x64-69>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"4567.0"
0x64-70>  write 0x00200c                      FSET,T            # reg[A] = T
0x64-71>  write 0x001f00                      FTOA,FORMAT       # Formatage
0x64-72>  write 0x00f2                        READSTR           # Affichage
0x64-73>  reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"876.0"
0x64-74>  write 0x0000                        NOP

# Fin du programme ----------

En résumé, ces 2 instructions LEFT et RIGHT permettent:
- d'implémenter un algorithme utilisant des variables (ici des registres de l'uM-FPU) temporaires anonymes allouées sur un pile FIFO et dont leur utilisation doit respecter un certain ordre comme dans les algorithmes récursifs avec une limite de 8 variables temporaires "imbriquées"
- d'émuler la fameuse Notation polonaise inverse chère aux calculatrices HP mais aussi à certains langages de programmation
- de faire pointer (LEFT) le registre reg[A] (accumulateur par lequel "passe" la plupart des opérations) sur le registre temporaire alloué et de restaurer sur le dernier RIGHT le reg[A] d'avant le 1st LEFT (sorte de sauvegarde / changement / restauration de contexte associé au calcul)

D'autres exemples disponibles ci-après et qui concernent le calcul de fractions continues qui se prête bien à cet exercice et qui permettent d'approximer au mieux tous nombres réels; à savoir:
- Calcul de PI
- Calcul de E
- Calcul du Nombre d'Or
- Calcul de la racine carrée de 2

À suivre ;-)

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

#36 Message par satinas » mer. 24 avr. 2019 23:00

Bonsoir,

J'essaie de m'y faire, c'est un langage assez particulier.
Au démarrage tu ne fais pas de SELECTA, c'est parce que A = 0 par défaut ?
La première instruction ATOL remplit reg[0], qui est aussi reg[A].
Alors pourquoi faire un LSET0 derrière ?

Les derniers pic 32 bits intègrent une FPU, mais j'en ai pas vu en boitier DIP.

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

#37 Message par Claudius » jeu. 25 avr. 2019 09:12

Bonjour satinas et à tous,

Ton analyse est parfaitement correcte: A est bien à 0 à l'init (reg[0] est vu comme reg[A] dans la terminologie de Micromega) ce qui est équivalent à SELECTA,0 et donc le FSET0 (reg[A] = reg[0) est inutile pour les 2 séquences d'initialisation et présentation de reg[N] et reg[M]

J'ai refait le test de l'init sans ces FSET0 et c'est Ok :bravo:

Code : Tout sélectionner

#define   M_Value         "142857"   # Valeur de M
#define   N_Value              "7"   # Valeur de N

#define   M                  10      # reg[10]: M
#define   N                  11      # reg[11]: N

# Initialisation et presentation
0x64-1>   write 0x009a31343238353700          ATOL,M_Value      # Valeur de M dans reg[0]
0x64-2>   write 0x009b00                      LTOA,0            # Formatage
0x64-3>   write 0x00f2                        READSTR           # Affichage
0x64-4>   reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"142857"
0x64-5>   write 0x00080a                      COPYA,M           # Copy dans M   

0x64-6>   write 0x009a3700                    ATOL,N_Value      # Valeur de N dans reg[0]
0x64-7>   write 0x009b00                      LTOA,0            # Formatage
0x64-8>   write 0x00f2                        READSTR           # Affichage
0x64-9>   reada                                                 # Lecture 'string buffer' en ASCII jusqu'au '\0'
"7"
0x64-10>  write 0x00080b                      COPYA,N           # Copy dans N   


@Les derniers pic 32 bits intègrent une FPU, mais j'en ai pas vu en boitier DIP
C'est parce qu'ils ont trop de broches, que le boitier DIP est, sauf erreur de ma part, mécaniquement limité à 64 broches avec dans ce cas une surface incompatible avec la demande des concepteurs d'aujourd'hui


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

Qui est en ligne

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