IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Raspberry Pi Discussion :

[pico 2] Comment s'y prendre pour juste charger le registre de la sortie de l'un des port gpio en assembleur ?


Sujet :

Raspberry Pi

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éprouvé

    Profil pro
    Inscrit en
    Août 2008
    Messages
    1 222
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2008
    Messages : 1 222
    Par défaut [pico 2] Comment s'y prendre pour juste charger le registre de la sortie de l'un des port gpio en assembleur ?
    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)?

    Nom : tableau.png
Affichages : 195
Taille : 33,9 Ko

    à 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:

    Nom : instruction.png
Affichages : 201
Taille : 47,8 Ko
    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

  2. #2
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    13 268
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 13 268
    Billets dans le blog
    48
    Par défaut
    Bonsoir,

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

    Citation Envoyé par keokaz Voir le message
    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

    Citation Envoyé par keokaz Voir le message
    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.

  3. #3
    Membre éprouvé

    Profil pro
    Inscrit en
    Août 2008
    Messages
    1 222
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2008
    Messages : 1 222
    Par défaut
    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

  4. #4
    Membre éprouvé

    Profil pro
    Inscrit en
    Août 2008
    Messages
    1 222
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2008
    Messages : 1 222
    Par défaut
    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

Discussions similaires

  1. [UBUNTU] Comment s'y prendre pour installer Octave
    Par MBAYE BABACAR GUEYE dans le forum Ubuntu
    Réponses: 2
    Dernier message: 24/04/2007, 11h48
  2. [Conception] Comment s'y prendre pour créer le désign d'un site ?
    Par Diezo dans le forum Webdesign & Ergonomie
    Réponses: 13
    Dernier message: 04/07/2006, 15h06
  3. [LDAP] comment s'y prendre pour faire une recherche complexe
    Par dervish dans le forum Bibliothèques et frameworks
    Réponses: 2
    Dernier message: 10/03/2006, 14h56
  4. [MySQL] Comment s'y prendre pour une expiration après deux jours ?
    Par isa150183 dans le forum PHP & Base de données
    Réponses: 5
    Dernier message: 21/01/2006, 20h36

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo