Projeto com a FRDM-K64F e KDS

FRDM-K64F e KDS Suporte ao KSDK e Processor Expert
Este post faz parte da série Projeto com a FRDM-K64F e KDS. Leia também os outros posts da série:

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)”.

FRDM K64F e KDS: placa
Figura 1: Detalhes da placa FRDM-K64F
FRDM K64F e KDS: driver do gravador e depurador
Figura 2: Detalhe da instalação do driver do gravador e depurador

Documentos necessários

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.

FRDM K64F e KDS: LED RGB
Figura 3: Detalhe do LED RGB no esquemático da placa FRDM-K64F
  • 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”.

FRDM K64F e KDS: novo projeto
Figura 4: Caminho para criar novo projeto

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

FRDM K64F e KDS: nome do projeto
Figura 5: Detalhe para o nome do projeto

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

FRDM K64F e KDS: microcontrolador
Figura 6: Seleção do microcontrolador

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

FRDM K64F e KDS: KSDK e Processor Expert
Figura 7: Seleção de biblioteca KSDK e uso do Processor Expert

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

FRDM K64F e KDS: área de trabalho no KDS
Figura 8: Detalhe de como fica a área de trabalho no KDS com o novo projeto

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.

FRDM K64F e KDS: registrador SIM_SCGC5
Figura 9: detalhe bit a bit do registrador SIM_SCGC5

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:

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.

FRDM K64F e KDS: registrador Pin Control
Figura 10: Detalhe bit a bit do registrador Pin Control

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:

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:

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

Trecho de código:

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”.

FRDM K64F e KDS: Propriedades do projeto
Figura 11: Chamada das Propriedades do projeto

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

FRDM K64F e KDS: tamanho do binário final
Figura 12: Habilitando funcionalidade de mostrar o tamanho do binário final

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

FRDM K64F e KDS: build
Figura 13: Botão de compilar o código

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

FRDM K64F e KDS: tamanho do binario final compilado
Figura 14: Detalhe do tamanho do binário final

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.

FRDM K64F e KDS: iniciar debug
Figura 15: Iniciar seção de debug

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

FRDM K64F e KDS: debug padrão
Figura 16: Seção criada com configuração padrão
FRDM K64F e KDS: debug detalhes
Figura 17: Detalhes de seleção do 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).

FRDM K64F e KDS: execução do programa
Figura 18: detalhe de execução do programa

Este é o código completo:

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?

Outros artigos da série

Projeto com a FRDM-K64F e KDS – Suporte ao KSDK >>
Licença Creative Commons Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Receba os melhores conteúdos sobre sistemas eletrônicos embarcados, dicas, tutoriais e promoções.

Software » Projeto com a FRDM-K64F e KDS
Comentários:
Notificações
Notificar
guest
4 Comentários
recentes
antigos mais votados
Inline Feedbacks
View all comments
André Aleixo
André Aleixo
25/07/2018 16:42

Muito interessante a série, Eduardo Scherrer. Trabalho a um tempo com kds e K64F, mas tenho dificuldades para encontrar documentações referentes a configuração I2C. Teria alguma dica ou documentações que possa ajudar?

Fernando Luiz Cola
30/11/2015 15:19

Oi Eduardo, muito bacana o post!
Tenho uma FRDM-K64F também e já brinquei um pouquinho com ela . É muito bom que ela possui LED RGB, dá pra fazer vários debugs divertidos.
Eu tenho um projeto baśico para aprendizado utilizando Makefile e o compilador GNU-GCC para a FRDM-K64F. Minha idéia não era usar o KDS e sim meu Makefile. Segue o respositório:
https://github.com/ferlzc/FRDM-K64F-baremetal-minimal
Espero seu próximo post sobre a análise do tamanho do binário.
Um grande abraços!
Fernando

Eduardo Scherrer
Eduardo C. Scherrer
Reply to  Fernando Luiz Cola
01/12/2015 21:13

Que bom que gostou Fernando.
A ideia desta sequência de posts é dar um ponto pé inicial, e colocar o pessoal pra colocar um micro tão pontente pra rodar de forma mais amigável possível.
Mostrar algumas maneiras de fazer projetos com o KDS e assim concluirem o que compensa mais para cada caso. Lembrando que este micro tem 1MB de flash.
Obrigado pela referência do seu repositório, muito bom hein.
Os próximos post serão legais, e espero que continue gostando e aproveitando.
Um abraço

Eduardo Scherrer

Talvez você goste:

Séries



Outros da Série

Menu