Sintaxis de programación de C para NXP LPC1768

todo está controlado por los archivos de encabezado utilizados. el primer enfoque usó una estructura (puntero) a la dirección base de gpio para tratar todos los registros relacionados con ese puerto. el segundo enfoque utilizó un puntero a la misma dirección.

al final del día, es lo mismo, un embalaje diferente.

editar: aquí está la esencia de esto.

typedef struct {
    uint32_t PIN;           //data register
    uint32_t SET;
    uint32_t DIR;
    uint32_t CLR;
} GPIO_TypeDef;             //gpio structure

#define GPIO                ((GPIO_TypeDef *)&IOPIN)

int main(void) {
    while (1) {
        GPIO->DIR ^=0xffff; //flip the lowest 16 bits
        IODIR     ^=0xffff; //doing the same
    }
}

Este chip en particular tiene cuatro registros asociados con su GPIO, IOPIN, IOSET, IODIR e IOCLR; Una forma de solucionarlo, en este caso, IODIR, es usar la macro definida en el archivo de encabezado, como se muestra en el bucle principal.

alternativamente, puede definir una estructura, GPIO_TypeDef que incluye los cuatro registros en el orden correcto (según el compilador). luego "arregla" el GPIO como un puntero a esa estructura pero anclado a la misma dirección que comienza con IOPIN.

Por lo tanto, los dos enfoques de voltear los 16 bits más bajos en los registros de IODIR lograrán el mismo objetivo.

Este enfoque requiere algunas cosas: 1. La estructura del puerto es la misma de un puerto a otro, de un chip a otro; 2. La endianidad es conocida.

la mayoría de los chips más nuevos (con la excepción de msp430 y pic) siguen eso. así será el enfoque de estructura utilizado ampliamente hoy en día.

Esta es una programación de C elemental que no tiene nada que ver con tu microcontrolador.

Puedes tener una variable:

unsigned int jim;

y puedes tener estructuras

typedef struct
{
    unsigned int bob;
    unsigned int ted;
    unsigned int carol;
    unsigned int alice;
}  MYSTRUCT;
MYSTRUCT one;
MYSTRUCT *two;

En el caso de uno, le pedimos al compilador que asigne la memoria para esa estructura, que está compilada básicamente en una cosa no malloc. Para los dos casos que dicen que solo hemos asignado un puntero, la dirección a la estructura, pero la memoria para la estructura aún no está asignada. en el caso de lo que está viendo, usan el último caso, luego usan trucos C para forzar que la dirección de dos sea una dirección específica, luego podemos saber / asumir que a partir de ese punto, ted, ... son compensaciones conocidas, así que si tiene un banco de registros de uart, y hay 10 de ellos y tienen 32 bits de ancho, en teoría podría definir una estructura de 10 elementos de 32 bits. Dígale al compilador que desea que la estructura apunte al principio de ese registro. Banco y luego accediendo a elementos dentro de la estructura a la que accedes a esos registros. O simplemente puede hacer variables individuales como la variable jim anterior e igualmente apuntar eso a algún lugar (durante la declaración para que en el momento de la compilación la dirección sea forzada). Hay más sintaxis de C que no estoy mostrando para forzar la dirección, pero usar la variable definida arriba de la sintaxis para esas variaciones es la siguiente:

jim=5;
one.bob=5;
two->bob=5;

con una variable, solo usas el nombre si es una variable dentro de una estructura, entonces depende de si el nombre base de la estructura es un puntero o no, si no es un puntero, usas un punto entre el nombre de la base de la estructura y la variable dentro de one.bob, y si es un puntero, entonces usa una flecha two- > bob. asuma que uno y dos no están apuntando a la misma dirección, de modo que esas son realmente dos variables de bob separadas.

Lo que está viendo es dos formas diferentes de abordar el problema de crear variables que se pueden usar en la dirección de un registro de hardware, y al usar diferentes técnicas de declaración, obtiene los dos estilos que señaló en su pregunta.