O microcontrolador ARM TM4123GH6PM tem interfaces para encoders, saídas PWM, barramento CAN, USB, I2C, etc. Estas capacidades fazem com que o microcontrolador possa ser usado em aplicações como máquinas ferramentas, controle numérico computadorizado, máquinas de corte, robôs, processos industriais, equipamentos domésticos, medicina, energia, transportes, etc. Neste artigo veremos sua arquitetura, ferramentas de desenvolvimento e sua facilidade de programação.
Microcontroladores ARM são construídos para ser usados em toda classe de aplicações e projetos. Existem microcontroladores ARM para ser usados em controle de processos e automação industrial. Este é o caso do microcontrolador TM4C123GH6PM da Série Tiva C, da Texas Instruments. Ver Figura 1. Vamos descrever suas características.
O MICROCONTROLADOR ARM TM4C123GH6PM.
O microcontrolador TM4C123GH6PM conta com as seguintes características (Ver Figura 2):
CPU ARM Coter-M4F.
Frequência 80 MHz
Memoria de Programa de até 256 KBytes
Memoria RAM de 32 KBytets.
EEPROM de 2 KBytes.
Memoria ROM carregada com TivaWare.
RTC (Real Time Clock)
Timers.
Wachdog Timer.
4 Interfaces Serial Síncronas (SSI)
8 UART
SPI
I2C.
USB.
2 Controladores CAN.
Conversor Analógico para Digital de 12 bits (ADC).
2 Comparadores Analógicos
GPIOs com capacidade de interrupção.
Módulo de hibernação.
Módulos para depuração e acompanhamento (Trace).
Baixo consumo, ideal para equipamentos a bateria.
Dentre as muitas aplicações em que se pode usar este microcontrolador temos:
Controle de movimiento.
Máquinas de corte.
Maquinas ferramenta.
Automação industrial.
Procesos industriais.
Robôs.
Paineis de acesso.
Interfaces Humanas.
Equipamentos de teste e medidas.
Módulos de comunicação.
Controle de luz inteligente.
Transportes e veículos.
Equipamentos médicos.
Sistemas de energia.
Dispositivos portáteis inteligentes.
A Figura 3 mostra o diagrama de blocos do microcontrolador TM4C123GH6PM.
Podemos notar a CPU ARM Cotex-M4F, as memorias Flash, RAM, ROM, os GPIO, ADC, Comparadores Analógicos, Timers, UARTs, SPI, I2C, etc. Os microcontroladores ARM para ter melhor desempenho usam vários barramentos para interconectar suas memórias e periféricos, mas no diagrama da figura 4, foram omitidos para facilitar o entendimento. Graças às funções e bibliotecas que a Texas Instruments desenvolveu e que entrega ao programador em uma biblioteca de software (funções ou rotinas) chamada TivaWare, estes barramentos são transparentes na hora de programar.
ENCODER
O microcontrolador TM4C123GH6PM tem 2 encoders incrementáveis de 2 canais, os quais convertem deslocamentos lineares em pulsos. Monitorando o número de pulsos e a fase relativa dos 2 sinais é possível seguir a posição, direção e rotação e velocidade de um deslocamento.
PWM
PWM ou Modulação de Largura de Pulso (Pulse Width Modulation), são módulos geradores de onda quadrada, onde uma parte da onda é controlada
(duty cycle) para codificar um sinal analógico. Normalmente, são usadas em fontes chaveadas (switching power) e controle de motores.
CAN
CAN (Controller Area Network) é um barramento serial para conectar outros dispositivos que normalmente leem sensores e controlam saídas (ECU ou Elenctronic Control Unit). Este barramento foi especialmente projetado para ambientes onde existe muito ruído eletromagnético.
NVIC
NVIC ou Controlador de Interrupções é um dispositivo que habilita os pinos de entrada do microcontrolador e nos periféricos para que tão logo ocorra um evento, a CPU do microcontrolador seja notificada e a respectiva rotina seja chamada.
USB
USB ou Universal Serial Bus, é um barramento usado para comunicação com computadores ou dispositivos portáteis que suportem este barramento. Muito útil para configurar parâmetros no equipamento ou enviar dados a computadores..
Placa de Desenvolvimento
A Texas Instruments criou um kit de desenvolvimento de fácil uso, chamado
EK-TM4C123GXL LaunchPad, com o qual podemos começar a programar o microcontrolador TM4C123GH6PM e testar seus múltiplos periféricos e capacidades. A figura 4 mostra uma imagem deste kit. Podemos observar as várias entradas analógicas, GPIOs, UART, SPI, I2C, PWM, Timers, Entradas com Captura, etc. Os pinos da placa são padronizados, compatíveis com uma série de módulos e 100% compatíveis ou se precisar fazer alguma modificação.
A figura 5 mostra os pinos do microcontrolador TM4C123GH6PM, onde podemos observar o seu rico set de periféricos.
Na figura 6 podemos observar uma aplicação prática para controlar um motor de passo bipolar (stepper motor). É usado um driver de motor DVR8833, um circuito integrado com duas pontes H ideal para controlar motores. O sentido, velocidade, partida e parada do motor podem ser controlados pelos botões que existem na placa EK-TM4C123GXL.
Ferramentas de Programação
Muitas ferramentas de desenvolvimento ou IDE (Editores e Compiladores) estão disponíveis para programar o kit, como o IDE Code Composer Studio, o IDE IAR Embedded Workbench, o IDE Keil uVision.
A Texas Instruments desenvolveu bibliotecas de funções para facilitar o uso e programação do microcontrolador. A todas estas funções ou rotinas, a Texas Instruments deu o nome de TivaWare.
Com a prática veremos seu uso fácil e utilidade, pois o programador não tem que se preocupar em criar rotinas para controlar os periféricos. Assim, o programador pode se concentrar no aplicativo e ganhar tempo para terminar o projeto.
Programa exemplo para acender e apagar um LED
Um dos programas exemplo mais utilizados para microcontroladores é acender e apagar um LED. Nas bibliotecas exemplo do microcontrolador TM4C123GH6PM, também encontramos este exemplo para acender e apagar um LED.
int main(void)
{
volatile uint32_t ui32Loop;
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOF))
{
}
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
while(1)
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x1);
for(ui32Loop = 0; ui32Loop < 200000; ui32Loop++)
{
}
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x0);
for(ui32Loop = 0; ui32Loop < 200000; ui32Loop++)
{
}
}
}
Explicando o programa, podemos dizer que a primeira função que se chama é main(). A seguinte linha de código, declara uma variável do tipo inteiro chamada ui32Loop:
volatile uint32_t ui32Loop;
A seguir, temos uma linha de código que habilita a porta F, para poder trabalhar com ela. Recordemos que nos microcontroladores ARM, todos os periféricos e portas estão desabilitados por default:
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
A próxima linha de código verifica se F está pronto para poder trabalhar com ela, ou seja, se já estabilizou sua tensão e clok.:
while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOF))
{
}
Temos então uma linha de código que configura o pino 3 da porta como saída:
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
A próxima linha de código é usada para que o programa sempre se repita, quer dizer, um loop infinito:
while(1)
Temos agora uma linha de código que é usada para colocar o estado do pino 3 da porta F no nível alto (1 lógico):
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x1);
Segue uma linha de código que usada para retardar (delay) o programa por um tempo que permita observar as piscadas do LED:
for(ui32Loop = 0; ui32Loop < 200000; ui32Loop++)
{
}
A próxima linha de código é usada para colocar o estado do pino 3 da porta F para o nível baixo (0 lógico):
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x0);
Passamos agora à linha de código usada para retardar (delay) o programa por um tempo e poder observar a piscada do LED:
for(ui32Loop = 0; ui32Loop < 200000; ui32Loop++)
{
}
As linhas de código que se encontram dentro do while(1), se repetem infinitamente e assim o LED vai acender e apagar (blinking). Para compilar e editar o exemplo anterior foi usado o IDE Keil. A Figura 7 mostra este ambiente de desenvolvimento.
Outra vantagem em se usar os microcontroladores TM4C123GH6PM, é sua compatibilidade com o modelo de programação Arduino. A Texas Instruments oferece uma IDE de desenvolvimento chamada Energía, a qual é muito parecida com a IDE de Arduino.A figura 8 mostra a IDE Energia, ambiente de desenvolvimento para a placa EK-TM4C123GXL.
É necessário instalar a placa na IDE; para fazer isso vá ao menu: ferramentas>placa>gestor de placas. A seguir temos um exemplo para acender e apagar um LED usando a IDE Energia:
#define LED RED_LED
void setup() {
pinMode(LED, OUTPUT);
}
void loop() {
digitalWrite(LED, HIGH);
delay(1000);
digitalWrite(LED, LOW);
delay(1000);
}
Podemos observar que o programa é muito simples. Inicialmente, na função
void setup(), se configura o pino da porta para ser saída:
pinMode(LED, OUTPUT);
Depois, na função de loop infinito, a saída do LED, se coloca no nível alto (HIGH), com a seguinte linha de código:
digitalWrite(LED, HIGH);
Então, retardamos e 1000 milissegundos (1 segundo), com a seguinte linha de código:
delay(1000);
Colocamos então no nível baixo (LOW) a saída do LED, com a seguinte linha de código:
digitalWrite(LED, LOW);
E depois voltamos a retardar por 1 000 milissegundos (1 segundo), com a seguinte linha de código:
delay(1000);
Este código, que se encontra dentro da função void loop(), se repete infinitamente e assim o LED vai piscar sem parar (blinking).
Programa exemplo para enviar dados pela porta serial (UART).
A seguir, um programa exemplo para enviar dados pela porta serial. Este programa envia a grafes Hello, world! pela UART. Assim, o programa começa por configurar o clock do microcontrolador, configura a porta que usa a UART, configura os pinos usados pela UART, configura o clock usado pela UART e configura a velocidade de transmissão:
int main(void)
{
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_GPIOPinConfigure(GPIO_PA0_U0RX);
ROM_GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
UARTStdioConfig(0, 115200, 16000000);
UARTprintf("Hello, world!\n");
while(1)
{
}
}
Vamos explicar o que se faz dentro da função main():
A linha de código seguinte coloca o clock para operar diretamente desde o cristal:
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
A seguir, a linha de código dada habilita a porta que usa a UART:
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
A próxima linha habilita a UART:
:
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
As linhas seguintes de código habilita,m os pinos das portas que vão ser usados p UART:
ROM_GPIOPinConfigure(GPIO_PA0_U0RX);
ROM_GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
A próxima linha de código usa o oscilador interno de 16 MHz como clock fonte para a UART:
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
Temos a seguir a linha de código que inicializa a UART:
UARTStdioConfig(0, 115200, 16000000);
A linha que se segue envía a frase: Hello, world! pela UART:
UARTprintf("Hello, world!\n");
Na próxima linha de código, o programa entra num loop infinito que não faz nada.:
while(1)
{
}
Como podemos observar, começar a programar com um microcontrolador ARM TM4C123GH6PM é muito simples, e também isso é válido para qualquer microcontrolador ARM da família Cortex-M.
O Microcontrolador ARM TM4C129x.
Este microcontrolador é um TIVA C com muito melhor desempenho que o MSP432P401. O microcontrolador TM4C129x é um ARM Cortex-M4F com Ethernet integrada, maior velocidade de processamento, 120 MHz, controlador para LCD, etc. A Figura 9 mostra o diagrama de blocos do microcontrolador TM4C129x. Para este microcontrolador a Texas Instruments projetou uma placa (kit) de desenvolvimento chamada DK- TM4C129x e a Figura 10 mostra uma fotografia deste kit.
