Les broches individuelles de différents ports d'un microcontrôleur peuvent-elles être mappées sur un registre et leurs valeurs peuvent-elles être modifiées lors du changement de la valeur du registre?

Q: Les broches individuelles de différents ports d'un microcontrôleur peuvent-elles être mappées à un registre et leurs valeurs peuvent-elles être modifiées lors du changement de la valeur du registre?

Scénario: j'ai utilisé des broches de chaque port (8 bits) du micro-contrôleur. Maintenant, je veux interfacer un périphérique qui a besoin d'un bus 8 bits (supposons D0 à D7 EN SÉQUENCE), c'est-à-dire que j'ai besoin de 8 broches du contrôleur pour pouvoir les connecter de manière un à un

portx0  -> D0 // x is the name of port followed by bit location on that port
portx1  -> D1
...
portx7  -> D7

mais je n'ai pas un port entier de 8 broches que je peux connecter avec cet appareil, j'ai plutôt quelques broches de portx, certaines de porty et quelques broches de portz. Le nouveau scénario de connexion est comme (connexion du micro-contrôleur à l'appareil respectivement)

portx0  -> D0
portx1  -> D1
portx2  -> D2
porty4  -> D3
porty5  -> D4
porty6  -> D5
porty7  -> D6
portz1  -> D7

Dans cet état, si je veux envoyer une valeur, dites

unsigned char dataReg = 0xFA;

à mon appareil depuis le contrôleur, je dois effectuer des opérations au niveau du bit sur la valeur à envoyer et définir chaque broche en fonction de la valeur dans le registre individuellement. Par exemple

portx0 = ((dataReg & 0x01) >> 0 );  // Masking and shifting as bit position
portx1 = ((dataReg & 0x02) >> 1 );
portx2 = ((dataReg & 0x04) >> 2 );
porty4 = ((dataReg & 0x08) >> 3 );
porty5 = ((dataReg & 0x10) >> 4 );
porty6 = ((dataReg & 0x20) >> 5 );
porty7 = ((dataReg & 0x40) >> 6 );
portz1 = ((dataReg & 0x80) >> 7 );

Maintenant, pour en venir à la question principale, afin d'éviter ces calculs individuels sur chaque bit sur différents ports, les broches individuelles de différents ports d'un microcontrôleur peuvent-elles être mappées sur un registre et leurs valeurs peuvent-elles être modifiées lors du changement de la valeur du registre?

Il semble que votre question se résume à avoir une valeur de 8 bits dans le micrologiciel et à vouloir lire et écrire cela depuis et vers une collection arbitraire de broches de port.

Il n'y a aucun moyen matériel direct de le faire. Vous devez écrire deux routines, une pour lire la valeur 8 bits et une pour l'écrire. D'autres ont mentionné le recours aux syndicats, mais c'est une mauvaise idée. Avec les unions, vous devez traiter chaque bit séparément et le code dépend de l'ordre des bits du micro. Cela pourrait être la voie à suivre de toute façon si tous les 8 bits sont dispersés de manière complètement indépendante. Si c'est le cas, vous ne pouvez pas faire grand-chose sauf pour créer du code spécial pour chaque bit.

La meilleure façon de le faire, surtout si vous pouvez regrouper les bits en quelques morceaux contigus sur les ports physiques, est d'utiliser le masquage, le décalage et l'OR. Par exemple, si les trois bits de poids faible de l'octet interne se trouvent sur les bits <6-4> d'un port, décalez vers la droite cette valeur de port de 4 et ET avec 7 pour obtenir ces bits dans leur position finale. Décaler et masquer (ou masquer et décaler) les bits des autres ports en place et assembler l'octet final de 8 bits en OU les résultats.

Ce type de twiddling de bits de bas niveau est plus facile à faire dans l'assembleur que C. Je mettrais probablement les routines de lecture et d'écriture d'octets dans un seul module assembleur et rendrais l'interface appelable à partir de C.

En général, ce n'est pas possible. Pour autant que je sache, ce n'est pas possible avec les PIC.

Je ne connais qu'un seul microcontrôleur qui peut le faire, le Cypress PSoC . C'est un système sur puce hautement configurable. Parmi les nombreuses choses qu'il vous permet de faire, vous devez définir littéralement votre propre registre (1-8 bits) et le connecter à toutes les broches que vous aimez, ou même à des circuits internes.

Par exemple, ici, j'ai créé un registre de contrôle 6 bits. 5 des bits vont directement aux broches, tandis que le 6ème bit que j'utilise pour XOR avec l'entrée d'une 7ème broche.

Sur la puce, je peux choisir d'affecter ces broches à l'une des broches GPIO disponibles. (Ce sont les gris sur l'image)

Vous pouvez essayer ce qui suit. Écrivez votre propre structure qui correspond aux broches respectives des 2 ports (qui doivent être utilisés). Maintenant, la mise à jour de la valeur dans ce registre doit définir / réinitialiser les broches de ces 2 ports. Essayez et faites-nous savoir si cela a fonctionné !!

Je suis convaincu que cela devrait fonctionner.

Si j'ai bien compris la question, c'est assez simple en C:

Déclaration de type générique, peut être réutilisée pour n'importe quel registre:

typedef union    // Generic 8-bit register Type
{
  uint8 reg; // Whole register
  struct
  {
    unsigned  bit7     : 1;  // Bit 7 
    unsigned  bit6     : 1;  // Bit 6 
    unsigned  bit5     : 1;  // Bit 5 
    unsigned  bit4     : 1;  // Bit 4 
    unsigned  bit3     : 1;  // Bit 3 
    unsigned  bit2     : 1;  // Bit 2 
    unsigned  bit1     : 1;  // Bit 1 
    unsigned  bit0     : 1;  // Bit 0 
  } bit;
} typ_GENERIC_REG8;

Donc, pour définir un port que nous voulons aborder:

#define MCU_GPO_PORTx   (*(volatile typ_GENERIC_REG8 *)(0x12345678)) // Number is address

Et pour tordre directement une broche sur ce port:

#define MCU_PORTx_PINn  (MCU_GPO_PORTx.bit.bit0)

Dans du code:

MCU_PORTx_PINn = 1; // Set pin high

Registre complet:

MCU_GPO_PORTx.reg = 0xF; // All pins high

Il vaut la peine de lire sur les structures, les unions, les typedefs et les énumérations - tous ces éléments rendent la vie tellement plus agréable dans les systèmes intégrés et en général!