Configurando um Microcontrolador LPC21XX (ARM7 de 32bits)

Olá pessoal, no artigo anterior aprendemos como realizar a configuração básica da IDE uVision da Keil. Agora, neste segundo artigo, vamos aprender a como configurar corretamente os recursos de controle do core ARM7 da família de microcontroladores ARM. Para isso, iremos demonstrar de forma prática com uma abordagem na família LPC21XX e criaremos nosso primeiro programa em C. 

Para isso, vamos detalhar o funcionamento dos seguintes módulos contidos no microcontrolador LPC21xx: PLL, MAM e Divisor VPB.

PLL 

O PLL (Phase Locked Loop) trata-se de um multiplicador da frequência do cristal ligado externamente. Em geral, esse cristal externo, ligado ao microcontrolador, é da faixa de 8 MHz a 25 MHz. E com o PLL, podemos elevar essa frequência a até 60 MHz no núcleo do processador. O que pode ser valioso para rotinas de aquisições de dados. 

O PLL possui 4 registradores especiais para configuração e é com essa configuração que podemos elevar o CCLK (Clock que chega ao núcleo do Processador) a até 60 MHz. São eles: PLLCFG, PLLCON, PLLSTAT, PLLFEED. 

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

PLLCFG 

O PLL é composto por dois CONTROLES: M (que é o multiplicador do PLL) e o P (que é o divisor do PLL). Devemos ajustar valores para estas duas variáveis a fim de obtermos o valor final da frequência de trabalho (limitada em 60 MHz). 

A relação da fórmula que devemos equacionar para trabalhar os valores de M e P é a seguinte: 

1 – CCLK = M x Osc; 

Sendo: CCLK = CPU Clock; Osc = frequência do cristal ligado externamente ao Microcontrolador; 

*Ou seja, para Osc = 12MHz e M = 2, temos CCLK = 24MHz; 

2 – FCCO = CCLK x 2 x P 

Sendo: FCCO = Frequency Current-conrolled Oscillator) 

*Sendo que:          156MHz <  FCCO  < 320MHZ; 

Uma vez definidos os valores de M e P, que satisfaçam as equações acima, utilizamos estes valores para formar o Byte do Registrador PLLCFG, da seguinte forma: 

Onde MSEL representa os possíveis valores de M e PSEL representa os possíveis valores de P. Estes possíveis valores de M e P são dados de acordo com a tabela abaixo: 

Abaixo uma planilha com alguns possíveis valores para M e P. Apenas como exemplo: 

PLLCON 

Esse registrador habilita o modulo PLL.

PLLFEED 

Após a configuração de todos os registradores citados acima, devemos carregar o Registrador PLLFEED para que todas essas configurações no módulo PLL se iniciem. 

A sequência deve ser (SEMPRE!): 

1. Carregar o valor 0xAA; 
2. Em seguida carregar o valor 0x55; 

Pronto. Todas as configurações definidas para o módulo PLL são carregadas e passam a estar ativadas. 

MAM 

MAM (Memory Acceralator Module) coloca parte da memória Flash em uma área da RAM para acesso rápido já que o acesso à memória Flash é um barramento de no máximo 20 MHz e o núcleo ARM pode chegar a 60 MHz. 

Divisor VPB 

O Divisor VPB atua realizando uma divisão do sinal de Clock após o PLL. Mas não altera a frequência que chega ao núcleo do processador. Só atua sobre a frequência que chega ao barramento VPB  (VLSI Peripheral Bus). Dessa forma podemos ter um processador rodando a uma alta frequência, mas com periféricos que podem rodar a uma baixa frequência caso seja solicitado. A divisão pode ser feita por 1, 2 ou 4. 

Costumo utilizar a função abaixo para a configuração inicial de um microcontrolador ARM. 

static void systemInit(void)
{
    //--- Habilitando e ativando o  PLL (Phase Locked Loop) ---
    // a. Configurando multiplicador e divisor (M e P)
    // O Valor de M esta definido em config.h
    /*Configuraзгo do valor de P
        PSEL1           PSEL0           P
            0                   0               1
            0                   1               2
            1                   0               4
            1                   1               8       */
     
    PLL0CFG = MSEL | (0<<PSEL1) | (1<<PSEL0);
    // b. Ativando PLL
    PLL0CON = (1<<PLLE);
    // c. Sequencia de acionamento
    PLL0FEED = PLL_FEED1;
    PLL0FEED = PLL_FEED2;
    // d. aguarda o PLL estar travado via bit PLOCK (PLOCK bit is set if locked)
    while (!(PLL0STAT & (1<<PLOCK)));
    // e. Ativa (e habilita) PLL
    PLL0CON = (1<<PLLE) | (1<<PLLC);
    // f. Sequencia de acionamento
    PLL0FEED = PLL_FEED1;
    PLL0FEED = PLL_FEED2;
     
    // --- Configura e ativa a MAM (Memory Accelerator Module) ---
    // a. start change by turning of the MAM (redundant)
    MAMCR = 0;  
    // b. set MAM-Fetch cycle to 3 cclk as recommended for >40MHz
    MAMTIM = MAM_FETCH;
    // c. enable MAM 
    MAMCR = MAM_MODE;
     
    // --- set VPB speed ---
    VPBDIV = VPBDIV_VAL;
     
    // --- map INT-vector ---
    //#if defined(RAM_RUN)
    //  MEMMAP = MEMMAP_USER_RAM_MODE;
    //#elif defined(ROM_RUN)
    //  MEMMAP = MEMMAP_USER_FLASH_MODE;
    //#else
    //#error RUN_MODE not defined!
    //#endif
}

Junto com as seguintes definições: 

#define FOSC 12000000
#define Fcclk (FOSC * 5)
#define Fpclk (Fcclk / 4) * 1
#define PLL_M 5 //
#define MSEL (PLL_M-1)
#define PSEL0 5
#define PSEL1 6
 
#define PLLE 0
#define PLLC 1
 
#define PLOCK 10
 
#define PLL_FEED1 0xAA
#define PLL_FEED2 0x55
/*MAM(Memory Accelerator Module) Ц Definiчуo: MAM fully enabled = MAM-Mode 2
MAMCR Ц 00 = MAM esta desabilitado (Default)
01 = Funcionamento parcial do MAM
10 = Ativa todas as funчїes do MAM
11 =- System-Clock cclk=24MHz -> 2 CCLKs are proposed as fetch timing
MAMTIM Ц Numero de cicles para acesso a memєria flash
*/
 
#define MAM_MODE 2
#define MAM_FETCH 2
 
/*VPB (VЕ Pheriphal Bus) Ц Definiчуo: VPB serс definido para mesma frequncia do nucleo -> devider VPBDIV=1
=> pclk = cclk = 24MHz
*/
#define VPBDIV_VAL 1

Abaixo, um exemplo de código completo. O programa executa um simples pisca Led onde já podemos ver a configuração básica do microcontrolador junto com uma simples rotina de temporização:

DOWNLOAD

No próximo artigo, estaremos abordando alguns recursos extras dos periféricos e dando maiores detalhes do uso do GPIO (General Purpose Input Output). Até lá!