Discussion :

[keokaz]

Bonsoir, je dispose de mon pico2 , de la documentation du rp2530 à cette adresse:

https://datasheets.raspberrypi.com/p...-datasheet.pdf


mon but est d' arriver à "juste" changer le registre qui me permet de mettre un état bas ou haut de
l'un des port gpio du pico2 en assambleur ?
Après plusieurs test avec visual studio pour programmer facilement avec la "tool chain" je souhaite activé une sortie en assembleur et pas en C ou python.

j'ai donc récupérer le code assembleur et editer le fichier en .S

Code :

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

1
2
3
4
5
6
7
8
9
10
11
.global main      # Provide program starting address to linker
main:   jal   stdio_init_all
        mv    s0, x0
loop:   la    a0, helloworld # load address of helloworld
        addi  s0, s0, 1
        mv    a1, s0        # counter        
        jal   printf
        j     loop
.data
helloworld:      .asciz "Hello RISC-V World %d\n"

et j'ai pu compiler et uploader dans le pico et cela fonctionne.

je me dis que j'ai peut être un bon début mais insuffisant pour arriver à ecrire dans un registre de sortie.
pour l'exemple c'est du risc V mais je vais le faire avec la puce rp2350.
je recherche donc les éléments qui me permettront d'arriver à charger les registres et instructions.

en page 17 de la doc rp2350 j'ai un tableau comme ceci:


comment faut t'il lire ?
le GPIO c'est le numéro du registre ? les F0 à F11 sont la correspondance du poids du registe (soit 12 bits)?



à la page 593 c'est ceci comme bout de code

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
179 typedef struct {
180
io_bank0_status_ctrl_hw_t io[48];
181
182
uint32_t _pad0[32];
183
184
// (Description copied from array index 0 register IO_BANK0_IRQSUMMARY_PROC0_SECURE0
applies similarly to other array indexes)
185_REG_(IO_BANK0_IRQSUMMARY_PROC0_SECURE0_OFFSET) // IO_BANK0_IRQSUMMARY_PROC0_SECURE0
186// 0x80000000 [31]
GPIO31
(0)
187// 0x40000000 [30]
GPIO30
(0)
188// 0x20000000 [29]
GPIO29
(0)
189// 0x10000000 [28]
GPIO28
(0)
190// 0x08000000 [27]
GPIO27
(0)
191// 0x04000000 [26]
GPIO26
(0)
192// 0x02000000 [25]
GPIO25
(0)
193// 0x01000000 [24]
GPIO24
(0)
194// 0x00800000 [23]
GPIO23
(0)
195// 0x00400000 [22]
GPIO22
(0)
196// 0x00200000 [21]
GPIO21
(0)
197// 0x00100000 [20]
GPIO20
(0)
198// 0x00080000 [19]
GPIO19
(0)
199// 0x00040000 [18]
GPIO18
(0)
200// 0x00020000 [17]
GPIO17
(0)
201// 0x00010000 [16]
GPIO16
(0)
202// 0x00008000 [15]
GPIO15
(0)
203// 0x00004000 [14]
GPIO14
(0)
204// 0x00002000 [13]
GPIO13
(0)
205// 0x00001000 [12]
GPIO12
(0)
206// 0x00000800 [11]
GPIO11
(0)
207// 0x00000400 [10]
GPIO10
(0)
208// 0x00000200 [9]
GPIO9
(0)
209// 0x00000100 [8]
GPIO8
(0)
210// 0x00000080 [7]
GPIO7
(0)
211// 0x00000040 [6]
GPIO6
(0)
212// 0x00000020 [5]
GPIO5
(0)
213// 0x00000010 [4]
GPIO4
(0)
214// 0x00000008 [3]
GPIO3
(0)
215// 0x00000004 [2]
GPIO2
(0)
216// 0x00000002 [1]
GPIO1
(0)
217// 0x00000001 [0]
GPIO0
(0)
218io_ro_32 irqsummary_proc0_secure[2];

pour manipuler le GPIO09 par exemple je vais avoir besoin de l'adresse:

Code :

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

1
2
3
4
// 0x00000200 [9]
GPIO9
(0)

pour les instructions j'ai vu dans la doc ce tableau(à la page 887:


donc ici j'ai tout les instructions pour y insérer mon code ?
après qu'est ce que je dois chercher ?

sinon j'ai vu ce bout de code :

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
int main() {
    stdio_init_all();

    // We'll use WATCHDOG_SCRATCH0 as a convenient 32 bit read/write register
    // that we can assign arbitrary values to
    io_rw_32 *scratch32 = &watchdog_hw->scratch[0];
    // Alias the scratch register as two halfwords at offsets +0x0 and +0x2
    volatile uint16_t *scratch16 = (volatile uint16_t *) scratch32;
    // Alias the scratch register as four bytes at offsets +0x0, +0x1, +0x2, +0x3:
    volatile uint8_t *scratch8 = (volatile uint8_t *) scratch32;

    // Show that we can read/write the scratch register as normal:
    printf("Writing 32 bit value\n");
    *scratch32 = 0xdeadbeef;
    printf("Should be 0xdeadbeef: 0x%08x\n", *scratch32);

    // We can do narrow reads just fine -- IO registers treat this as a 32 bit
    // read, and the processor/DMA will pick out the correct byte lanes based
    // on transfer size and address LSBs
    printf("\nReading back 1 byte at a time\n");
    // Little-endian!
    printf("Should be ef be ad de: %02x ", scratch8[0]);
    printf("%02x ", scratch8[1]);
    printf("%02x ", scratch8[2]);
    printf("%02x\n", scratch8[3]);

    // Byte writes are replicated four times across the 32-bit bus, and IO
    // registers usually sample the entire write bus.
    printf("\nWriting 8 bit value 0xa5 at offset 0\n");
    scratch8[0] = 0xa5;
    // Read back the whole scratch register in one go
    printf("Should be 0xa5a5a5a5: 0x%08x\n", *scratch32);

    // The IO register ignores the address LSBs [1:0] as well as the transfer
    // size, so it doesn't matter what byte offset we use
    printf("\nWriting 8 bit value at offset 1\n");
    scratch8[1] = 0x3c;
    printf("Should be 0x3c3c3c3c: 0x%08x\n", *scratch32);

    // Halfword writes are also replicated across the write data bus
    printf("\nWriting 16 bit value at offset 0\n");
    scratch16[0] = 0xf00d;
    printf("Should be 0xf00df00d: 0x%08x\n", *scratch32);
}

il est ecrit en C mais en m'inspirant je pourrais par exemple déjà d'écrire une valeur 32 bit en scratch0 valeur au pif en espérant que cela ne perturbe pas le pico2? et ensuite le lire puis l'afficher à l'aide de

Code :

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

1
2
        jal   printf

[f-leb]

Bonsoir,

Bon, personnellement, l'assembleur ça fait bien longtemps que ça ne m'amuse plus...

en page 17 de la doc rp2350 j'ai un tableau comme ceci:


comment faut t'il lire ?
le GPIO c'est le numéro du registre ? les F0 à F11 sont la correspondance du poids du registe (soit 12 bits)?

ça dit juste que les broches sont multifonctions et qu'elles peuvent être dirigées vers différents périphériques internes... Que la broche GPIO0 peut être dirigée vers SPI0 RX (Function 1) ou UART0 TX (Function 2) ou I2C0 SDA (Function 3), etc

pour les instructions j'ai vu dans la doc ce tableau(à la page 887:


donc ici j'ai tout les instructions pour y insérer mon code ?
après qu'est ce que je dois chercher ?

Tu es dans le chapitre sur les PIO, un périphérique programmable avec un jeu d'instructions réduits (9 uniquement) en pseudo-assembleur (pioasm). Cela n'a rien à voir avec l'assembleur pour programmer le RP2350.

[keokaz]

merci de ta réponse:

Code :

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

1
2
Bon, personnellement, l'assembleur ça fait bien longtemps que ça ne m'amuse plus...

je sais que c'est ennyeux mais je souhaite au maxium gagnier de temps, juste utiliser la puce pour lire une valeur analogique et la retranscrire dans un autre pico qui la sera codé en C voir python.
je vais essayer de faire une alimentation à découpage donc il faut que s'iil y a des problèmes qu''on doit avoir un minium de temps de lattence, et ca permet aussi de mieux maîtriser le rp2350.

si je comprend bien le code ci-dessous c'est aussi de pseudo assembleur ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
.global main      # Provide program starting address to linker
main:   jal   stdio_init_all
        mv    s0, x0
loop:   la    a0, helloworld # load address of helloworld
        addi  s0, s0, 1
        mv    a1, s0        # counter        
        jal   printf
        j     loop
.data
helloworld:      .asciz "Hello RISC-V World %d\n"

j'aurais voulus prendre exemple et arriver à afficher le registre x0 qui est fait que de "0" ?

Code :

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

1
2
3
4
5
6
7
8
9
.global main      # Provide program starting address to linker
main:   jal   stdio_init_all
        mv    s0, x0
        la    a0, leregistre # charger le registre x0 qui a que des zero
        jal   printf

.data
leregistre:        x0

[keokaz]

après avoir cherche sur le forum de raspberry pi je pense enfin trouver un exemple qui je pense ressemble plus à l'assembleur et qui fonctionne:

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
/* Programme assembleur RISCV Raspberry pico */
/*  first programm in assembly riscv*/
/* compilation and test OK */
/* blink led  OK */

/*********************************************/
/*           CONSTANTES                      */
/********************************************/
.equ LED_PIN, 25
.equ GPIO_OUT_COM, 1
.equ GPIO_IN_COM,  0

.equ IOPORT,          0xD0000000

.equ SIOBASE_CPUID  , 0x000 # Processor core identifier
.equ GPIO_IN        , 0x004 # Input value for GPIO pins
.equ GPIO_HI_IN     , 0x008 # Input value for QSPI pins
.equ GPIO_OUT       , 0x010 # GPIO output value
.equ GPIO_OUT_SET   , 0x014 # GPIO output value set
.equ GPIO_OUT_CLR   , 0x018 # GPIO output value clear
.equ GPIO_OUT_XOR   , 0x01c # GPIO output value XOR
.equ GPIO_OE        , 0x020 # GPIO output enable
.equ GPIO_OE_SET    , 0x024 # GPIO output enable set
.equ GPIO_OE_CLR    , 0x028 # GPIO output enable clear
.equ GPIO_OE_XOR    , 0x02c # GPIO output enable XOR
.equ GPIO_HI_OUT    , 0x030 # QSPI output value
.equ GPIO_HI_OUT_SET, 0x034 # QSPI output value set
.equ GPIO_HI_OUT_CLR, 0x038 # QSPI output value clear
.equ GPIO_HI_OUT_XOR, 0x03c # QSPI output value XOR
.equ GPIO_HI_OE     , 0x040 # QSPI output enable
.equ GPIO_HI_OE_SET , 0x044 # QSPI output enable set
.equ GPIO_HI_OE_CLR , 0x048 # QSPI output enable clear
.equ GPIO_HI_OE_XOR , 0x04c # QSPI output enable XOR


/*******************************************/
/* DONNEES INITIALISEES                    */
/*******************************************/ 
.data

/*******************************************/
/* DONNEES NON INITIALISEES                    */
/*******************************************/ 
.bss

/**********************************************/
/* SECTION CODE                              */
/**********************************************/
.text
.global main
main:                           #  
    li a0,LED_PIN
    call gpio_init              # init led 25
    
    li a0,LED_PIN
    li a1,GPIO_OUT
    call seldirGpio             # set direction to out
 
1:    
    li a0,LED_PIN               # pin 25
    li a1,0                     # turn off led 
    call putGpio
    li a0, 250                  # waiting time
    call sleep_ms 
    li a0,LED_PIN               # pin 25
    li a1,1                     # turn on led 
    call putGpio
    li a0, 150                  # waiting time
    call sleep_ms 
    j 1b                        # and loop
    

/************************************/
/*       select direction pin gpio   */
/***********************************/
/* a0 pin   */
/* a1 value */
seldirGpio:
    li t1,1                             # set bit
    sll t1,t1,a0                        # shift bit in pin position
    bne a1,x0,1f                        # in or out direction ?
    li t2,IOPORT                        # load sio address
    sw t1,GPIO_HI_OUT_SET(t2)           # store pin 25 on register gpio set 
    j 2f                                # jump end
1:
    li t2,IOPORT
    sw t1,GPIO_HI_OUT_CLR(t2)           # store  pin 25 in gpio clear register
2:
    ret
/************************************/
/*       Put pin gpio               */
/***********************************/
/* a0 pin   */
/* a1 value */
putGpio:
    li t1,1                            # set bit
    sll t1,t1,a0                       # shift bit in pin position
    beq a1,x0,1f                       # turn on or turn off 
    li t2,IOPORT                       # load sio address
    sw t1,GPIO_OE(t2)                  # store pin 25 on register gpio
    j 2f                               # jump end
1:
    li t2,IOPORT                       # load sio address
    sw t1,GPIO_OUT_CLR(t2)             # store pin 25 on register gpio
2:
    ret
/************************************/

ce code permet de faire clignoter la led 25 du pi pico2, donc j'ai créer avec le module pico sous vscode en cochant bien sur sur risc
ensuite je me suis mis en mode sellboot . Pour en être sur j'ai modifier le clignotement en mettant 150 ms au lieu des 250.
j'avais essayer de flasher avec la ma sonde en pico1 mais cela n'a pas fonctionner du coup j'ai rajouter la fameuse ligne pour éviter de réappuyer sur le boot sel , je vais pour le moment me passer du debugger:

Code :

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

1
2
3
//fichier cmakerlist
pico_enable_stdio_usb(assembleurproj 1)

je vais maintenant essayer de faire cignoter un port gpio1 par exemple ... mais il faut que déchiffre déjà ces lignes .

j'ai modifier cette ligne pour changer de led:

Code :

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

1
2
3
4
5
/*********************************************/
/*           CONSTANTES                      */
/********************************************/
.equ LED_PIN, 1

la led 1 clignote bien , j'ai aussi modifier un autre le nombre .
par contre je pensais que c'était plus difficile à trouver, et qu'il faut trouver le bon mot binaire ??
on dirait que c'est pré programmer ?

dans la doc je vois ceci:

Code :

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

1
2
3
4
5
6
7
8
0x004 GPIO_INInput value for GPIO0…31.
In the Non-secure SIO, Secure-only GPIOs (as per ACCESSCTRL)
appear as zero.

0x008 GPIO_HI_IN
Input value on GPIO32…47, QSPI IOs and USB pins
In the Non-secure SI

si j'essaye de comprendre, à cette adresse se trouve un registre "0x004",
si je mette un nombre de 32 bit par exemple 000F dans cette adresse 0x004 je vais pouvoir accès à la led numéro 16 en sortie
si je fais la même chose mais 0027 on jouera sur la sortie 27 dans le registre "0x008"
par contre le registre 0x004 est déclarer mais n'est pas utilier par la suite du code ?
comment fait t'il pour comprendre que je souhaite faire clignoter la led 16 par exemple en remplaçant 1 à 16 ??

Code :

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

1
2
3
.equ LED_PIN, 1
.equ LED_PIN, 16