Projeto com a FRDM-K64F e KDS

Nos artigos do Denis Shimizu, foi explicado como instalar e fazer um projeto para o microcontrolador da família K64F utilizando a IDE + Compilador (KDS), com suporte às bibliotecas de abstração de hardware (KSDK) e inicialização dos periféricos com a ferramenta Processor Expert (PE).

Nesta sequência de artigos, apresentarei algumas maneiras de criar o código, usando a FRDM-K64F e KDS, para que você leitor possa decidir o que acha mais vantajoso:

1. Codificação sem suporte ao KSDK e ao Processor Expert;
2. Codificação com suporte ao KSDK e sem suporte ao Processor Expert;
3. Codificação com suporte ao KSDK e ao Processor Expert.

Preparação do ambiente

Sugiro que acesse o post do Denis Shimizu aqui, onde é descrito o procedimento de preparação do ambiente.

Preparação da placa

A placa FRDM-K64F já vem com um firmware que permite a gravação do microcontrolador. Para estes post, farei uso do firmware da empresa Pemicro, pois funcionou muito bem nos meus testes. Siga os seguintes passos:

1) Acessar o site da Pemicro: www.pemicro.com;

2) Clicar na aba de “Support”;

3) Cliclar no link “Documentation & Downloads”;

4) Na coluna “Popular Downloads”, procure por “OpenSDA Firmware Applications”;

5) É necessário um cadastro, ou o fornecimento de uma conta de email para conseguir baixar os arquivos;

6) Você receberá um email da Pemicro contendo o link para download;

7) O formato do arquivo será este:

Pemicro_OpenSDA_Debug_MSD_Update_Apps_AAAA_MM_DD.zip

Onde:

• AAAA = ano
• MM = mês
• DD = dia

8) Descompacte-o e procure pelo seguinte arquivo:

DEBUG-FRDM-K64F_Pemicro_v108a_for_OpenSDA_v2.0.bin

9) Este deve ser copiado para a placa;

10) Com a placa desconectada, pressione e mantenha pressionado o botão de RESET;

11) Conecte o cabo USB na porta “SDAUSB”;

12) Aparecerá uma janela com a indicação de “BOOTLOADER”. Copiar o arquivo para esta pasta;

13) A janela se fechará sozinha e o LED D2 começará a piscar rapidamente;

14) Desconecte e conecte o cabo USB, mas desta vez não precisa pressionar o botão de RESET;

15) Verifique se o driver já foi instalado corretamente, acessando o gerenciador de dispositivos na categoria “Portas (COM e LPT)”.

Documentos necessários

• Datasheet da família de microncotroladores K64F: K64P144M120SF5.pdf
• Reference Manual da família de microcontroladores K64F: K64P144M120SF5RM.pdf
• Esquema eletrônico da placa Freedom FRDM-K64F: FRDM-K64F_SCH.pdf

Projeto base para comparação dos métodos:

O projeto base piscará as três partes do led RGB. Olhando o esquemático (FRDM-K64F_SCH.pdf) na página 2, podemos identificar em que pinos do microcontrolador estão ligados cada pino do led RGB.

• LED Vermelho: PTB22
• LED Verde: PTE26
• LED Azul: PTB21
• Para acender um led, é necessário aplicar nível lógico “0”
• Para apagar um led, é necessário aplicar nível lógico “1”

Procedimento de criação do projeto

Com o KDS aberto, siga o caminho: “File -> New -> Kinetis Project”.

No campo “Project Name”, digite o nome de projeto “PiscaLedSemSuportes”.

Clicar em “Next”. Selecione “Processors -> Kinetis k -> MK60 -> MK64F (120MHz) -> MK64FN1M0xxx12”.

Clicar em “Next”. No combo box do “Kinetis SDK”, selecione “None”. Deixe o checkbox do “Processor Expert” desabilitado.

Clicar em “Finish”. Um novo projeto aparecerá no campo Project Explorer.

Este projeto tem o mínimo de código necessário para o desenvolvimento do software para o microcontrolador selecionado:

• Arquivo “main.c” com a função “int main(void)”;
• Arquivo “MK64F12.h” onde tem as estruturas e endereçamento para acessar os registradores do microcontrolador em questão.

O firmware terá as seguintes tarefas:

1. Habilitar o fornecimento de clock para os ports;
2. Configurar os pinos para operar como GPIO;
3. Configurar a direção dos pinos;
4. Operar no acionamento dos pinos.

1 – Habilitar o fornecimento de clock para os ports

No arquivo “K64P144M120SF5RM.pdf” (Reference Manual), capítulo 12, é explicado o Módulo de Integração de Sistema (SIM – System Integration Module). Na página 314, tem o descritivo do registrador SCGC5. Os bits 9, 10, 11, 12 e 13 são responsáveis por habilitar o clock dos ports.

Neste projeto serão utilizados dois ports, B e E, então, é necessário habilitar os clocks destes ports:

• Bit 13 -> PORTE
• Bit 10 -> PORTB

Trecho de código:

SIM->SCGC5 |= 1<<10 | 1<<13;

2 – Configurar os pinos para operar como GPIO

No Reference Manual, capítulo 11, é explicado o registrador que configura as funções dos pinos, PCR (Pin Control Register). Cada pino tem o seu registrador.

Na página 282, seção 11.5.1, tem o descritivo do registrador PORTx_PCRn.

Os bits importantes para este projeto são:

• Bits 10-8 -> MUX: configura a função do pino, 001 – GPIO
• Bit 6 -> DSE: Drive Strenght Enable, 1 – High Drive
• Bit 5 -> ODE: Circuito de Open Drain, 0 – desabilitado
• Bit 4 -> PFE: Circuito de filtro de entrada, 0 – desabilitado
• Bit 2 -> SRE: Configuração de Slew Rate, 1 – Slow
• Bit 1 -> PE: Circuito de Pull, 0 – desabilitado
• Bit 0 -> PS: Circuito de Pull down ou Pull up, 0 – pulldown

Trecho de código:

PORTB->PCR[22] |= 1<<8 | 1<<6 | 1<<2;
PORTB->PCR[22] &= ~(1<<5) & ~(1<<4) & ~(1<<1) &  ~(1<<0);

PORTE->PCR[26] |= 1<<8 | 1<<6 | 1<<2;
PORTE->PCR[26] &= ~(1<<5) & ~(1<<4) & ~(1<<1) &  ~(1<<0);

PORTB->PCR[21] |= 1<<8 | 1<<6 | 1<<2;
PORTB->PCR[21] &= ~(1<<5) & ~(1<<4) & ~(1<<1) &  ~(1<<0);

3 – Configurar direção dos pinos

No Reference Manual, capítulo 55, é explicado o bloco de GPIO. Os registradores importantes são:

• GPIOx_PDDR: Direção
• GPIOx_PSOR: Seta bit
• GPIOx_PCOR: Clear bit
• GPIOx_PTOR: Toggle bit

Nesses registradores, cada bit se refere a um pino do microcontrolador. No registrador de direção (GPIOx_PDDR), se escrever “1” o pino é configurado como saída, se escrever “0” o pino é configurado como entrada.

Registrador de “Seta bit” (GPIOx_PSOR), escrevendo 1 no bit, a saída vai para nível lógico 1. Registrador de “Toggle bit” (GPIOx_PTOR), escrevendo 1 no bit, a saída alterna o nível lógico.

Trecho de código:

//Configura direção dos pinos
GPIOB_PDDR |= 1<<22 | 1<<21;
GPIOE_PDDR |= 1<<26;
 
//Condição inicial dos pinos para apagar os leds
GPIOB_PSOR |= 1<<22 | 1<<21;
GPIOE_PSOR |= 1<<26;

A funcionalidade de delay será feita com o decremento de uma variável com um grande valor.

Trecho de código:

uint32_t var_delay = 5000000;

//Loop infinito
while(1)
{
    //Toggle dos leds
    GPIOB_PTOR = 1<<22 | 1<<21;
    GPIOE_PTOR = 1<<26;

    //Decremento de variável para controlar do delay
    while(--var_delay > 0);
        var_delay = 5000000;
}

Este programa não teve nenhuma abstração de hardware, ou seja, os registradores do microcontrolador foram acessados diretamente. Não tem módulos para tratamento dos GPIOs.

Para saber o tamanho do código gerado, é necessário habilitar a funcionalidade. Clique com o botão direito sobre o nome do projeto. Selecione a opção “Properties”.

Siga o seguinte caminho: “C/C++ Build -> Settings -> Toolchains”. Marcar o checkbox “Print size”.

Clicar no botão “Apply” e depois em “OK”. Compilar o projeto clicando no botão “Build”.

No console aparecerá o tamanho do binário gerado.

Para gravar e depurar o código, conectar a placa ao PC através do cabo USB. Sendo que deve usar a conexão USB nomeado como “SDA”. Cliclar na seta ao lado do botão de debug.

Selecionar a opção “Debug Configurations” > “GDB PEMicro Interface Debugging” > “PiscaLedSemSuportes_Debug_PNE”. Selecionar a aba “Debugger”.

No campo “Interface”, selecionar a oção “OpenSDA Embedded Debug – USB Port”. Verifique se no campo “Port”, o dispositivo foi identificado, no meu caso apareceu “USB1 – OpenSDA (60DC2E62)”. Clicar no botão “Debug”. O KDS iniciará o processo de gravação do microcontrolador e preparação da IDE para permitir a execução e depuração do programa.

Clicar no botão “Play” para executar o programa e ver os três leds piscarem juntos (o efeito é de um led branco).

Este é o código completo:

int main (void)
{
    uint32_t var_delay = 5000000;

    //Habilitando o clock para os Ports B e E
    SIM->SCGC5 |= (1<<10) | (1<<13);

    //Configuração do registrador Pin Control
    //Pino que controla o Led Vermelho
    PORTB->PCR[22] |= 1<<8 | 1<<6 | 1<<2;
    PORTB->PCR[22] &= ~(1<<5) & ~(1<<4) & ~(1<<1) &  ~(1<<0);

    //Pino que controla o Led Verde
    PORTE->PCR[26] |= 1<<8 | 1<<6 | 1<<2;
    PORTE->PCR[26] &= ~(1<<5) & ~(1<<4) & ~(1<<1) &  ~(1<<0);

    //Pino que controla o Led Azul
    PORTB->PCR[21] |= 1<<8 | 1<<6 | 1<<2;
    PORTB->PCR[21] &= ~(1<<5) & ~(1<<4) & ~(1<<1) &  ~(1<<0);

    //Loop infinto para controlar o toggle dos leds
    while(1)
    {
        //Toggle dos leds
        GPIOB_PTOR = 1<<22 | 1<<21;
        GPIOE_PTOR = 1<<26;

        //Decremento de variável para controlar do delay
        while(--var_delay > 0);

        var_delay = 5000000;
    }
}

Conclusão

Foi necessário procurar todos os nomes de registradores, para que todos os blocos do microcontrolador fossem habilitados para operar. Sendo que a velocidade do clock foi mantida a padrão, se não, teriam mais registradores para serem acessados.

Nos próximos posts as configurações ficarão mais fáceis. E o tamanho do binário… Bem, espere o próximo post para mais detalhes.

O que achou, difícil, fácil, já fez isso com outros microcontroladores, com núcleos diferentes?