[PicoBlaze ] Surveiller une pin

**joffrey575** · 18/10/2016, 19h13

Bonsoir à tous,

Je tente en ce moment de debugger une carte que je programme. J'ai écrit le programme en assembleur.

Le mainprog et les subroutines sont-ils dans le bonne ordre ?

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
 
CONSTANT    CST_AD_REG_STATE_LED,18 ; command reg_timer_status, finish counting?
 
CONSTANT    CST_AD_REG_STATE_LED_1,10 ; command reg_led_r
CONSTANT    CST_AD_REG_STATE_LED_2,10 ; command reg_led_r
 
CONSTANT    CST_AD_REG_TIMER_VAL,15 ; command reg_timer_val to decount
 
;---------------------------------------------------------------------------------
;Special Register usage
NAMEREG s0,ZEROS ;use
NAMEREG s1,ONES ;use
NAMEREG s2,STATE_LED_1 ;use
NAMEREG s3,STATE_LED_2 ;use
NAMEREG s4,TIMER_VAL ; use
;NAMEREG s5,ZEROS
NAMEREG s6,REG_VAL_ENTRY
;ne pas utiliser s7 (boucles)
;ne pas utiliser s8 (interne)
;NAMEREG s9,ZEROS
;NAMEREG sA,ZEROS
;NAMEREG sB,ZEROS
;NAMEREG sC,ZEROS
;NAMEREG sD,ZEROS
;NAMEREG sE,ZEROS
; ne pas utiliser sF (macro)
 
;---------------------------------------------------------------------------------
;Initialisation
 
LOAD ZEROS,00
LOAD ONES,11
LOAD STATE_LED_1,00 ; STATE OF LEDS
LOAD STATE_LED_2,0F ; STATE OF LEDS
LOAD TIMER_VAL,FF ;
 
;-------------------------------------MAINPROG------------------------------------
;---------------------------------------------------------------------------------
 
mainprog:  ;CALL maj_timer_val
           CALL test_entry
           ;CALL stateleds ; state 1, see the difference
 
           ;CALL maj_timer_val
           CALL test_entry_2
           ;CALL stateleds_2 ; state 2, see the difference
 
return mainprog
 
 
;------------------------------------SUBROUTINE-----------------------------------
;---------------------------------------------------------------------------------
 
test_entry:  INPUT REG_VAL_ENTRY,CST_AD_REG_STATE_LED ;AD_REG_STATE_LED is PORT_ID
                                                      ;and select the INPUT_data and s0 receive the data
 
             JUMP NZ, stateleds ;if entry value s0 is not NULL, jump in stateleds
             return
 
stateleds:   OUTPUT STATE_LED_1,CST_AD_REG_STATE_LED_1 ;OUTPUT PORT, PORT ID
             return
 
test_entry_2: INPUT REG_VAL_ENTRY,CST_AD_REG_STATE_LED ;AD_REG_STATE_LED is PORT_ID
                                                      ;and select the INPUT_data and s0 receive the data
 
             JUMP NZ, stateleds_2 ;if entry value s0 is not NULL, jump in stateleds
             return
 
stateleds_2: OUTPUT STATE_LED_2,CST_AD_REG_STATE_LED_2 ;OUTPUT PORT, PORT ID
             return
 
maj_timer_val: OUTPUT TIMER_VAL,CST_AD_REG_TIMER_VAL ;OUTPUT PORT, PORT ID
               return

Merci par avance.

Bonne soirée à tous

**Kannagi** · 18/10/2016, 19h23

Envoyé par joffrey575

Le mainprog et les subroutines sont-ils dans le bonne ordre?

C'est a toi de le savoir , impossible a dire sachant que on ne sait même pas quel résultat tu veux.
Si le résultat est correct alors le code est bon

**joffrey575** · 18/10/2016, 20h04

Je souhaite obtenir un changement d'état de 8 LEDS par le biais des fonctions test_entry et test_entry_2.

J'ai une clock en entrée de mon design hardware sur FPGA qui déclenche un timer à chaque front montant.

Ainsi, une fois que le timer a finie, il envoie un front montant significatif d'un changement d'état des LEDS.

**Kannagi** · 18/10/2016, 22h14

Bah je pense que personne ici connaît l'architecture de ta machine , mais essayons d'y voir plus clair :

Jamais fait de PicoBlaze de ma vie , mais je devine que :

Code :

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

1
2
3
4
5
6
 
LOAD ZEROS,00
LOAD ONES,11
LOAD STATE_LED_1,00 ; STATE OF LEDS
LOAD STATE_LED_2,0F ; STATE OF LEDS
LOAD TIMER_VAL,FF ;

initialise les registres donc, alors c'est le plus déconcertant dans ton code (que j'ai pas compris au premier coup d'oeil) parce que en général on met des noms a des variables pas a des registres...

La Memory Map :

Code :

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

1
2
3
4
5
6
7
 
CONSTANT    CST_AD_REG_STATE_LED,18 ; command reg_timer_status, finish counting?
 
CONSTANT    CST_AD_REG_STATE_LED_1,10 ; command reg_led_r
CONSTANT    CST_AD_REG_STATE_LED_2,10 ; command reg_led_r
 
CONSTANT    CST_AD_REG_TIMER_VAL,15 ; command reg_timer_val to decount

Ok donc on sait que 15,18 c'est pour le timer et que le 10 c'est pour les LEDS avec 8 bits donc 8 LEDS, mais tu as mis reg_led_r pour moi le r signifie read donc c'est un rw non ?
Ou alors quel est le registre d'écriture ? (et je peux vraiment pas le deviner).

Autre question y'a t il une wram (ram de travaille) , parce que bon faire tout son programme avec que les registres c'est pas sérieux... (même dans les année 80 en avait un peu plus de RAM

).

Pour ta question ben ça sera test_entry_2 qui écrira sur les LEDS mais seulement si s0 n'est pas NULL et S0 chez toi il est tjs égal a zéro

Enfin d’après ton 'commentaire' parce que ça me semble du copier/coller les drapeaux dépende très rarement d'un registre particulier , le NZ c'est quand un drapeaux est dans un état particulière alors moi j'ai pas la doc sous les yeux de ton PicoBlaze alors soit tu laisse comme ça si tu sais ce que tu fais , soit tu rajoute une instruction de comparaison , ça sera plus explicite.

Moi si tu me le demande pour tes LEDS allumé je dirai d’après ton code :

Code :

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

1
2
3
 
LOAD s0,FF
OUTPUT s0,CST_AD_REG_STATE_LED_1

Mais comme je l'ai dit sur tes commentaire tout laisse supposé que CST_AD_REG_STATE_LED_1 ne se lit que en lecture pas en écriture.

J'ai une clock en entrée de mon design hardware sur FPGA qui déclenche un timer à chaque front montant.

Ainsi, une fois que le timer a finie, il envoie un front montant significatif d'un changement d'état des LEDS.

Alors :
-quel registre I/O pour le front montant
-Comment fonctionne ton TIMER ?
Parce que le TIMER ça peut fonctionner très différent sur les différentes machines , pour ma part je suis tombé dessus que sur des processeurs sonore et en général en mettait la valeur en MiliSeconde , et puis en lisait le registre jusqu'a il était égal à 0, mais la doc expliquait très bien tout ça.
Et dans ton cas ?

**joffrey575** · 19/10/2016, 10h04

Ici, voici la doc du picoblaze.
http://www.xilinx.com/support/docume...tion/ug129.pdf

Page 102/122, tu as ce qu’il se passe pour l’instruction INPUT ! Un MUX permet de sélectionner l’entrée voulue puisque sur le picoblaze tu n’as qu’une seule entrée à 1 bit.

Ok donc on sait que 15,18 c'est pour le timer et que le 10 c'est pour les LEDS avec 8 bits donc 8 LEDS, mais tu as mis reg_led_r pour moi le r signifie read donc c'est un rw non ?

En fait ‘r’ c’est pour « red », les LEDS rouges. Il y a huit LEDS tricolore avec led_r, led_g et led_b (red, green, blue).

Autre question y'a t il une wram (ram de travaille) , parce que bon faire tout son programme avec que les registres c'est pas sérieux... (même dans les année 80 en avait un peu plus de RAM.

En fait, tu as le picoblaze d’une part et son micro-programme d’autre part. Le micro-programme je le programme en .psm qui sera compilé en code VHDL comme micro-programme. Le tout est mis sur FPGA.
Je suppose que la RAM de travaille c’est le micro-programme ?

En fait, OUTPUT s0,CST permet de sortir la valeur contenue dans s0 sur le bon registre de sortie en VHDL c’est un signal.

INPUT s1,CST permet de sélectionner le bon signal à partir du MUX d’entrée et de mettre la valeur dans s1.

C’est particulier mais regarde la page Page 102/122 de la doc tu comprendra.

Alors :
-quel registre I/O pour le front montant
-Comment fonctionne ton TIMER ?
Parce que le TIMER ça peut fonctionner très différent sur les différentes machines , pour ma part je suis tombé dessus que sur des processeurs sonore et en général en mettait la valeur en MiliSeconde , et puis en lisait le registre jusqu'a il était égal à 0, mais la doc expliquait très bien tout ça.
Et dans ton cas ?

Le front montant serait détecté par l’instruction INPUT qui surveille la bonne entrée grâce à la constante. Le fait d’acquérir les 8 bits du PORT surveillé agit sur le FLAG ZERO à priori d’après ce qu’on m’a dit.

Le timer est codé en VHDL par moi-même donc on s’en occupe pas ici.

**joffrey575** · 19/10/2016, 10h47

Pardons pour s0, c’est s6 en commentaire

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
CONSTANT    CST_AD_REG_STATE_LED,18 ; command reg_timer_status, finish counting?
 
CONSTANT    CST_AD_REG_STATE_LED_1,10 ; command reg_led_r
CONSTANT    CST_AD_REG_STATE_LED_2,10 ; command reg_led_r
 
CONSTANT    CST_AD_REG_TIMER_VAL,15 ; command reg_timer_val to decount
 
;---------------------------------------------------------------------------------
;Special Register usage
NAMEREG s0,ZEROS ;use
NAMEREG s1,ONES ;use
NAMEREG s2,STATE_LED_1 ;use
NAMEREG s3,STATE_LED_2 ;use
NAMEREG s4,TIMER_VAL ; use
;NAMEREG s5,ZEROS
NAMEREG s6,REG_VAL_ENTRY
;ne pas utiliser s7 (boucles)
;ne pas utiliser s8 (interne)
;NAMEREG s9,ZEROS
;NAMEREG sA,ZEROS
;NAMEREG sB,ZEROS
;NAMEREG sC,ZEROS
;NAMEREG sD,ZEROS
;NAMEREG sE,ZEROS
; ne pas utiliser sF (macro)
 
;---------------------------------------------------------------------------------
;Initialisation
 
LOAD ZEROS,00
LOAD ONES,11
LOAD STATE_LED_1,00 ; STATE OF LEDS
LOAD STATE_LED_2,0F ; STATE OF LEDS
LOAD TIMER_VAL,FF ;
 
;-------------------------------------MAINPROG------------------------------------
;---------------------------------------------------------------------------------
 
mainprog:  ;CALL maj_timer_val
           CALL test_entry
           ;CALL stateleds ; state 1, see the difference
 
           ;CALL maj_timer_val
           CALL test_entry_2
           ;CALL stateleds_2 ; state 2, see the difference
 
return mainprog
 
 
;------------------------------------SUBROUTINE-----------------------------------
;---------------------------------------------------------------------------------
 
test_entry:  INPUT REG_VAL_ENTRY,CST_AD_REG_STATE_LED ;AD_REG_STATE_LED is PORT_ID
                                                      ;and select the INPUT_data and s0 receive the data
 
             JUMP NZ, stateleds ;if entry value s6 is not NULL, jump in stateleds
             return
 
stateleds:   OUTPUT STATE_LED_1,CST_AD_REG_STATE_LED_1 ;OUTPUT PORT, PORT ID
             return
 
test_entry_2: INPUT REG_VAL_ENTRY,CST_AD_REG_STATE_LED ;AD_REG_STATE_LED is PORT_ID
                                                      ;and select the INPUT_data and s0 receive the data
 
             JUMP NZ, stateleds_2 ;if entry value s6 is not NULL, jump in stateleds
             return
 
stateleds_2: OUTPUT STATE_LED_2,CST_AD_REG_STATE_LED_2 ;OUTPUT PORT, PORT ID
             return
 
maj_timer_val: OUTPUT TIMER_VAL,CST_AD_REG_TIMER_VAL ;OUTPUT PORT, PORT ID
               return

Pour moi, la séquence d’instruction est la suivante :
1-Mainprog :

2-Appel de la fonction « test_entry »
3-Acquisition de la valeur présente à l’entrée avec INPUT, …
4-Test si la donnée est NON NULL

4-1-1-Si non nul c’est qu’on a eu une fin de TIMER (TIMER déclanché par CLK externe)
4-1-2-Fonction « stateleds » Changement d’état des LEDS
Ou
4-2-1 Si nul -> alors on retourne au mainprog et on va lancer la fonction test_entry_2.

Pour le 4-2-1, il vaut peut être mieux faire un return test_entry comme ça on reste dans la boucle tant qu’on a rien détecté. Ce n’est pas requit de faire une boucle infinie. !!

**Kannagi** · 19/10/2016, 14h37

Ok donc j'ai lu la doc et pour OUTPUT/INPUT aucun ne modifie le flag donc tu peux mettre tes fonctions en boucle les flag ne changeront jamais.
Donc on revient a je que j'ai dit plus tôt , peut être utilisé l'instruction COMPARE qui elle modifiera bel et bien les flag (et donc ton saut conditionnel pourra fonctionner).

En fait, tu as le picoblaze d’une part et son micro-programme d’autre part. Le micro-programme je le programme en .psm qui sera compilé en code VHDL comme micro-programme. Le tout est mis sur FPGA.
Je suppose que la RAM de travaille c’est le micro-programme ?

Sur ce coup je m'excuse , parce que au final peut être que tu dois juste debug un FPGA et donc pas d'utilisation forcément de RAM , par contre est ce que le microprograme peut servir de RAM , ben oui et non , ça dépend j'imagine des branchements d'un point de vue électronique mais aussi du support.
Mais dans les faits oui ça peut arriver que la RAM/DATA/programme se partage la même 'ROM' (je met entre guillemet vue qu'une ROM est en lecture seul par définition) ça peut être une SRAM par exemple.

Pour moi, la séquence d’instruction est la suivante :
1-Mainprog :

2-Appel de la fonction « test_entry »
3-Acquisition de la valeur présente à l’entrée avec INPUT, …
4-Test si la donnée est NON NULL

4-1-1-Si non nul c’est qu’on a eu une fin de TIMER (TIMER déclanché par CLK externe)
4-1-2-Fonction « stateleds » Changement d’état des LEDS
Ou
4-2-1 Si nul -> alors on retourne au mainprog et on va lancer la fonction test_entry_2.

Pour le 4-2-1, il vaut peut être mieux faire un return test_entry comme ça on reste dans la boucle tant qu’on a rien détecté. Ce n’est pas requit de faire une boucle infinie. !!

Quel est le but au final d'allumer les LEDS quand le TIMER est fini ?
C'est bien que tu m'explique les problèmes d'ordre technique , mais j'aimerais aussi connaître le but du programme et donc aussi pouvoir vérifier l'algorithme que tu me décris /donne

**joffrey575** · 27/10/2016, 14h08

Excuse moi pour le retard et un grand merci pour m'avoir répondu, ça m'a motive à continuer mes efforts.

En fait, je me trompais au niveau du JUMP. Le JUMP n'est pas comme un CALL. Il sert juste à retourner sur une adresse précédente d'un label.

Pour surveiller l'état d'une PIN avec ce type de processeur soft-core, il suffit d'envoyer une commande avant de surveiller la PIN.
Cette commande fait tomber le signal arrivant sur la PIN à 0.

Ainsi, comme j'ai fait un décompteur, la sortie ne repasse à 1 seulement lorsque le décompteur a finit de décompter.

D'autant plus que le décompteur ne se lance qu'avec les deux signaux de "synchro".

C'est un peu flou désolé.

Bonne après-midi et merci.

J'ai regardé pour INPUT, effectivement aucun effet sur le Flag ZERO !!

[PicoBlaze ] Surveiller une pin

Autres architectures Assembleur

Discussions similaires

Partager

Partager