Raspberry Pi 101 – GPIO Buttons

Welcome back folks!

Vamos continuar a desbravar as capacidades de nosso Raspbery Pi. Hoje, vamos mostrar a você como realizar a interface de um botão com seu Raspy. Utilizaremos a informação fornecida por uma porta de nosso GPIO para alterar o curso do nosso programa, tornando nossas aplicações mais interessantes e divertidas.

Os materiais que você vai precisar são:

– 01 Raspberry Pi modelo A ou B (estou usando o B);

– 01 LED de qualquer cor;

– 01 Resistor de 470 Ohms;

– 02 Push Buttons

– Alguns jumpers e uma protoboard.

Deu para perceber que iremos precisar do hardware que usamos em nosso primeiro tutorial, o LED e o Resistor. Optei por manter as conexões para aproveitarmos o trabalho já realizado e um pouco do código que já testamos anteriormente. Nosso hardware será conectado da seguinte forma:

00_GPIO_Button

INSERIR ESQUEMÁTICO

O botão conectado ao pino 22 será responsável por parar a execução de nosso programa. O botão conectado ao pino 8 será o responsável por alterar o comportamento de nossa saída, fazendo com que o LED pisque. Repare que não estou utilizando resistores de Pull-Up junto aos botões, isso porque  o Raspy tem resistores de Pull-Up (e Pull-Down) disponíveis internamente e passíveis de serem configurados via software, através da biblioteca RPi.GPIO.

ATENÇÃO: certifique-se de que não rodou nenhum software utilizando as GPIOs antes de montar o hardware. Se não tem certeza se deixou alguma das portas com sinais digitais ativos, abra o IDLE (IDE Python) e execute os dois comandos abaixo. Isso assegura que não ocorra nenhum curto-circuito durante a montagem do hardware. 😉

import RPi.GPIO as GPIO
GPIO.cleanup()

Muito bem, tudo conectado it’s time to code!

Mais uma vez recomendo que utilize o Spyder, como IDE para desenvolver suas aplicações. Crie um novo arquivo e nomeie helloGPIO102.py (não se esqueça da extensão .py).  Na primeira sessão do seu código fonte deve constar a documentação do seu projeto:

"""
0. Documentation Section
helloGPIO102.py
Toggle LED using button interface
Authors: Bruno Godoi Eilliar
Date: March 31, 2015.
"""

Na sessão 1 importamos as bibliotecas que iremos utilizar

# 1. Pre-Processor Directives Section
import RPi.GPIO as GPIO
import time

Na sessão 2 realizamos as declarações das variáveis que vamos utilizar e configuramos as GPIOs correspondentes ao LED e aos dois botões de nosso projeto (sw e sw_stop).

# 2. Declarations Section
sw = 8
sw_stop = 22
led = 18
GPIO.setmode(GPIO.BCM)    # Set GPIO numeration label
GPIO.setup(led, GPIO.OUT)    # set pin led as digital output
GPIO.setup(sw, GPIO.IN, pull_up_down = GPIO.PUD_UP)    # set pin sw as digital input and turn on pull-up internal resistor
GPIO.setup(sw_stop, GPIO.IN, pull_up_down = GPIO.PUD_UP)    # set pin sw_stop as digital input and turn on pull-up internal resistor

Em seguida vamos definir as funções principal e auxiliar que serão utilizadas em nossa aplicação. Primeiro definimos a função ToggleLED() responsável por fazer com que o LED pisque uma vez com um intervalo definido entre os estados. Assim, podemos utilizar o código do post anterior como base e fazer algumas modificações:

def ToggleLED(delay, pin):<br />
    """
    Function to blink LED once, connected at pin
    """
    GPIO.output(pin, True)    # Turn ON the LED
    time.sleep(delay)    # Delay for a few seconds
    GPIO.output(pin, False)    # Turn OFF the LED
    time.sleep(delay)    # Delay for a few seconds

Por fim, precisamos definir o comportamento da rotina principal do programa. Queremos o seguinte comportamento:

– Se o sw_stop for pressionado, o programa termina e limpa as GPIOs utilizadas.

– Se o sw for pressionado, o LED irá piscar uma vez, com intervalo de 0.5 segundos entre cada estado. Caso contrário, o LED ficará apagado.

O que temos acima é uma descrição do comportamento que desejamos para nosso sistema. Em algumas literaturas você pode encontrar com o nome de pseudo-code e é tido como fundamental no design de sua aplicação para evitar erros durante a fase de desenvolvimento do projeto. Recomendo que sempre estruture seus projetos em pseudo-code antes de começar a programar, isso evita muito retrabalho durante o desenvolvimento do código. 😉

Agora vamos traduzir isso para código em Python:

"""
Main subroutine
"""
print ("Running program...")
print ("To finish the program press the stop button on the breadboard.")
while True:
    stop_flag = GPIO.input(sw_stop)    # Read input
    if stop_flag == False:    # Button Pressed
        break    # Jump off while loop
    input_state = GPIO.input(sw)    # Read input
    if input_state == False:    # Button pressed
        print ("Button Pressed")
        ToggleLED(.5, led)
        time.sleep(.2)
print ("Stopping execution...")
GPIO.cleanup()

 

 Voilà! Eis sua primeira aplicação utilizando Digital Inputs em seu Raspberry Pi! Para rodar basta apertar F5 e observar as mensagens na sua tela.

Ficou alguma dúvida ou desenvolveu algo interessante com seu Raspy? Comente e vamos fazer o possível para ajudar.

Não se esqueçam de espalhar a palavra! Vejo vocês no próximo post, onde vamos fazer a interface do sensor de distância HC-SR04 e falar sobre como plotar gráficos em Python!

😉

Anúncios

Curso – Introduction to Programming with MATLAB

Hello Folks!

Notícia animadora para aqueles que estão começando o curso de Engenharia ou Tecnologia. O Coursera é uma plataforma de e-learning que reúne diversos cursos de inúmeras Universidades mundialmente conceituadas. E o melhor, tudo de graça!

Recentemente uma nova gama de cursos foi registrada e trago um em especial que acho válido para nós (Engenheiros e afins). Trata-se de um curso de introdução à Programação em Matlab.

Como o próprio nome diz, trata-se de uma introdução e por isso é recomendado para aqueles que não conhecem bem essa poderosa ferramenta ou que não a utilizam há muito tempo. O curso é completamente em inglês e está organizado em 8 semanas. Os tópicos abordados são (1) Matrizes e Operadores; (2) Funções; (3) Programmer’s Toolbox; (4) Seleção; (5) Loops; (6) Tipos de Dados e (7) File Input/Output. Tudo que você precisa saber para começar restringe-se à matemática do Ensino Médio (além de boa vontade e tempo XD).

Eu mesmo já fiz diversos cursos no Coursera (foi onde aprendi Python) e recomendo a plataforma. Para mais informações sobre o curso e para se registrar clique na imagem abaixo.

matlab

Enjoy! 😉

 

DARPA e alguns dos seus projetos

Olá a todos!

Recentemente chamei o meu amigo Bruno, para ajudar nas postagens do blog, desde que eu não estava dando conta de manter um ritmo bom, especialmente para o desenvolvimento de tutoriais. ele já postou muito no blog, já falou sobre a Tiva e o Raspberry Pi (finalmente algo mais prático está sendo desenvolvido!).

Nas voltas pela internet, achei alguns projetos bem interessantes desenvolvidos pela DARPA, que é uma agência que faz pesquisas específicas para uso militar.

DARPA é uma agência do departamento de defesa dos Estados Unidos, cuja sigla significa “Defense Advanced Research Projects Agency” (Agência Avançada de Pesquisa de Projetos de Defesa). O que a divisão faz é desenvolver projetos de alta tecnologia que podem (ou não) serem empregados militarmente, tendo como um dos seus maiores focos o desenvolvimento de robôs

Continuar lendo

TI Precision Labs

Hello Folks!

Se você trabalha ou pretende iniciar carreira em Eletrônica Analógica e Processamento Analógico de Sinais; ou mesmo tem aquele projeto de TCC se aproximando e envolve um desses temas, esse post é pra você.

A Texas Instruments acaba de lançar um curso “on-demand” sobre Eletrônica Analógica voltado principalmente para o Design e teste de circuitos com Amplificadores Operacionais. Eles prometem um currículo que combina teoria e prática, incluindo 30 treinamentos tipo hands-on e lab videos. E o mais interessante é que a própria TI desenvolveu e disponibiliza gratuitamente um simulador para você testar os circuitos durante o curso, chamado TINA-TI. Muito do que será apresentado no curso toma como literatura base o Pocket Book de Eletrônica Analógica da TI, escrito por especialistas em design de circuitos com amplificadores operacionais. Vale a pena conferir!

Para saber mais sobre a proposta da TI, clique na imagem abaixo e veja o vídeo de introdução do curso.

Raspberry Pi 101 – GPIO

Welcome back Folks! Vamos começar com uma série de aplicações interessantes para o seu Raspberry Pi! Vamos assumir que você já saiba do que se trata e qual a proposta do Raspberry Pi; e mais importante, que você já tenha um. Se não for esse o caso, mas você está interessado em descobrir e começar a explorar essa ferramenta, dê uma olhada no site oficial: http://www.raspberrypi.org/.

Vamos ao que interessa, para esse post os materiais que você vai precisar são:

– 01 Raspberry Pi model A ou B (estou usando o B);

– 01 LED de qualquer cor;

– 01 Resistor 330Ω ou 470Ω;

Vamos nos certificar de que nosso Raspy tem tudo o que precisamos para começar nosso primeiro programa. Iremos usar Python para fazer nossas aplicações. Trata-se de uma linguagem de programação interpretada (como o Matlab) e de sintaxe altamente elegante e “limpa” (o código fonte é visualmente enxuto e fácil de ler). Claro que não é uma linguagem voltada para alta performance, como as linguagens compiladas (C e Fortran, por exemplo), mas atende às nossas necessidades de forma satisfatória. Os Sistemas Operacionais para o Raspy, geralmente, já vêm com Python instalado, para certificar-se de que seu Raspy tem Python, no shell (“prompt de comando” do Linux) digite:

which python

Se tiver instalado, o shell retornará o diretório de instalação do Python.

O Python é uma linguagem de programação Orientada à Objeto, que quer dizer que podemos aproveitar código de outras pessoas na forma de “módulos” (equivalente à bibliotecas em C/C++). Para realizar a interface de nosso Raspy com o mundo externo através das General Purpose Inputs Outputs (GPIOs), vamos precisar do módulo (ou biblioteca, como preferir) RPI.GPIO para Python. Mais uma vez, normalmente, o OS do Raspy já vem com esse módulo instalado e só precisamos atualizá-lo. No shell digite:

sudo python
import RPi.GPIO as GPIO
GPIO.VERSION

 

Você então verá a versão do módulo GPIO que está instalado. A versão atual (até a data de concepção desse post) é a 0.5.11 (saiba mais em: https://pypi.python.org/pypi/RPi.GPIO). Se tiver que atualizar sua versão, abra um novo shell e digite:

sudo apt-get update
sudo apt-get upgrade

Quase lá! Agora vamos escolher uma IDE (Integrated Development Environment) para programarmos nossas aplicações. Como um Engenheiro de Controle e Automação sempre somos expostos ao poderoso Matlab e, querendo ou não, nos acostumamos à sua interface e suas praticidades, além de sua sintaxe. Então, se você também está nessa situação, eu sugiro usar a IDE Spyder. Ela possui uma interface gráfica bem parecida com o Matlab e pode facilitar a vida daqueles que se sentem desconfortáveis programando diretamente no shell do Linux. Para instalá-la, use o shell e digite:

sudo apt-get install spyder

Após instalação, para iniciar o Spyder digite:

sudo spyder &

“Um pouco de Linux:

– O sudo no início de cada comando executa a sua solicitação com permissões de Super Usuário, o equivalente ao Administrador no Windows;

– O & no final do comando, inicia a aplicação mas libera o shell que você está usando para receber novos comandos, assim não precisa abrir um shell a cada programa que for utilizar.”

Descrição do Hardware

Nossa primeira aplicação será fazer com que um LED, conectado à um dos pinos GPIO, pisque por um determinado número de vezes, a ser especificado pelo usuário através do teclado. Os pinos de I/O do Raspy respeitam a seguinte configuração (Modelos A e B):

30_GPIO01

Vamos conectar o LED da seguinte forma:

30_GPIO02

De forma técnica, o Anodo(+) do LED conecta-se à GIPO18 e seu Catodo(-) conecta-se ao resistor e esse a um dos pinos terra da placa (GND), fechando o circuito.

Time to Code!

Agora que temos o hardware pronto, vamos programar. Inicie o Spyder, crie um novo arquivo e salve. ATENÇÃO: não se esqueça de adicionar a extensão .py ao nome do arquivo, para que a IDE saiba que se trata de um código em Python (em Linux algumas coisas não são tão automáticas como no Windows).

Se você já tem alguma experiência em programação, em C/C++ ou Matlab, aprender Python não será difícil e você vai entender facilmente o que vamos fazer aqui. Se não sabe nada de programação eu sugiro que dê uma passada no CodeAcademy, pois lá eles têm um excelente programa para você aprender Python (e muito mais) do zero.

Vamos adotar as mesmas boas práticas de programador que usamos para programar nossa Tiva C LaunchPad. Dividimos o código fonte em 4 sessões: 0 – Documentação; 1 – Diretivas de Pré-processamento; 2 – Declarações; 3 -Subrotinas.

"""
0. Documentation Section
helloGPIO101.py
Blink LED, connected to pin "led"

Authors: Bruno Godoi Eilliar
Date: March 21, 2015
"""

#1. Pre-Processor Directives Section

import RPi.GPIO as GPIO
import time

#2. Declarations Section

led = 18    # LED will be connected at pin 18

GPIO.setmode(GPIO.BCM)    # set GPIO numeration label
GPIO.setup(led, GPIO.OUT)    # set pin "led" as digital output

#3. Subroutines Section

def Blink(numTimes, speed):
"""
Function to blink LED, connected at pin "led", for numTimes
"""
    for i in range(0, numTimes):
        print "Iteration " + str(i+1)    # Print status
        GPIO.output(led, True)    # Turn ON the LED
        time.sleep(speed)    # Delay for a few seconds
        GPIO.output(led, False)    # Turn OFF the LED
        time.sleep(speed)    # Delay for a few seconds
     print "Done blinking!"    # Print status
     GPIO.cleanup()    # Clean up all GPIO pins

"""
Main Subroutine
"""
iterations = raw_input("Enter total number of times to blink: ")
speed = raw_input("Enter lenght of each blink (seconds): ")

Blink(int(iterations), float(speed))

Vamos analisar nosso programa. Na Main Subroutine solicitamos que o usuário insira valores para o número de vezes que o LED irá piscar e o delay entre as transições dos estados aceso e apagado. Então esses valores são passados à função Blink() que definimos anteriormente. Essa função é a responsável por executar nossa rotina de acender e apagar o LED um número numTimes de vezes. Ao final da função, por meio do comando GPIO.cleanup() nos certificamos de “limpar” todas as GPIOs que usamos (neste caso apenas uma) para que nenhuma fique ligada desnecessariamente. Aqui está o vídeo de como minha aplicação funcionou:

Sucesso! Agora você pode explorar a conexão de sua Raspy com o mundo externo através das GPIOs. Se tiver alguma sugestão ou dúvida, deixe nos comentários ou envie-nos um e-mail. Se tiver alguma ideia de projeto usando a sua Raspy, conte-nos e compartilhe com a comunidade!

Se gostou do post não esqueça de espalhar a palavra e deixar seu comentário abaixo. Fique ligado para o próximo episódio onde iremos realizar a interface de um botão com nossa Raspy para alterar o estado de nosso programa. Até a próxima!

 

😉

Tiva C – Hello World!

Welcome back Folks! Vamos continuar com nossa série de posts sobre o Tiva C Series, a placa de desenvolvimento da TI baseada em um microcontrolador com arquitetura Cortex-M4.  No nosso último post apresentamos as características dessa placa que promete uma excelente relação custo-benefício.

Antes de começarmos, você precisa primeiro instalar os drivers para sua Tiva. Basta  clicar em download no link: http://www.ti.com/tool/stellaris_icdi_drivers.

Em seguida você precisa baixar e instalar o Keil µVision. Após a instalação estar completa inicie o programa e conecte sua Tiva. Você deve estar vendo algo parecido com isso:

20_Keil01

Na barra superior vá em PROJECT -> NEW µVision PROJECT. Selecione o diretório onde deseja salvar o projeto, dê um nome e clique em salvar. Em seguida você deverá selecionar o microcontrolador com o qual vai trabalhar, encontre (ou digite) TM4C123GH6PM. E aperte OK.

20_Keil02

Irá aparecer uma janela perguntando se você quer fazer uma cópia do arquivo de startup_TM4C123.s (fornecido pela Keil) para seu diretório. Clique em Não, pois iremos utilizar o arquivo que você baixou aqui no blog.

20_Keil03

Muito bem, você criou seu projeto! Agora vamos adicionar um arquivo main.c que conterá o código fonte de nossa primeira aplicação. No canto esquerdo, na janela de Project, vá em Source Group 1 e clique com o botão direito do mouse. Selecione a opção Add New Item…

20_Keil04

Selecione C File(.c) e dê o nome de main.c, depois clique em Add.

20_Keil05

Agora você tem um arquivo onde poderá escrever o código fonte, que será compilado e convertido em código de máquina para sua Tiva. Para que o Debug Mode funcione e consigamos testar nossos códigos, precisaremos adicionar o arquivo starup.s que você baixou aqui no blog. Novamente, clique com o botão direito do mouse em Source Group 1 e em seguida em Add Existing Files to… Localize o arquivo startup.s e adicione ao projeto.  Seu diretório, na aba Project, deve ser algo parecido com isso agora:

20_Keil06

Antes de começarmos a programar, vamos fazer alguns ajustes nas configurações de nosso projeto. No menu superior, vá em PROJECT -> Options for Target ‘Target 1′. Em seguida, certifique-se que as configurações estejam como na imagem abaixo (atente para não usar Floating Point Hardware e Cross-Module Optimization):

20_Keil07

Nessa mesma tela selecione a aba Debug. Usaremos nossa placa para debugar o nosso código e vamos precisar dos drivers da TI que baixamos anteriormente. Certifique-se que sua tela de configuração esteja como a imagem abaixo:

20_Keil08

Por fim, vá a aba Utilities e certifique-se que está usando o mesmo driver que o Debuger:

20_Keil09

Pronto, aperte OK e vamos programar! Um bom programador estrutura seu código de forma que seja possível que outros colaboradores possam entendê-lo durante a fase de projeto de um sistema. Vou mostrar a forma como estruturo meus programas (aprendi com o pessoal da Universidade de Texas Austin).

O arquivo principal (main.c) é estruturado em 4 sessões: 0 – Documentação; 1 – Diretivas de Pré-processamento; 2 – Declarações; 3 – Subrotinas.  Vamos começar com a sessão 0. Abra seu arquivo main.c e descreva como seu sistema irá funcionar, bem como o autor e data de concepção do projeto:

// 0.Documentation Section
// main.c
// HelloWorld, Input from PF4, output to PF3,PF2,PF1 (LED)
// Authors: Bruno Godoi Eilliar
// Date: March 15, 2015

// LaunchPad built-in hardware
// SW1 left switch is negative logic PF4 on the Launchpad
// SW2 right switch is negative logic PF0 on the Launchpad
// red LED connected to PF1 on the Launchpad
// blue LED connected to PF2 on the Launchpad
// green LED connected to PF3 on the Launchpad

Em seguida, vamos para a sessão 1, onde iremos declarar os endereços dos registradores que iremos usar. Não se preocupe se não entender, vamos abordar com mais detalhes os registradores em posts futuros, no momento queremos dar vida à nossa Tiva e certificarmos de que nossa IDE está funcionando perfeitamente.

// 1. Pre-processor Directives Section
// Constant declarations to access port registers using
// symbolic names instead of addresses

#define GPIO_PORTF_DATA_R (*((volatile unsigned long *)0x400253FC))
#define GPIO_PORTF_DIR_R (*((volatile unsigned long *)0x40025400))
#define GPIO_PORTF_AFSEL_R (*((volatile unsigned long *)0x40025420))
#define GPIO_PORTF_PUR_R (*((volatile unsigned long *)0x40025510))
#define GPIO_PORTF_DEN_R (*((volatile unsigned long *)0x4002551C))
#define GPIO_PORTF_LOCK_R (*((volatile unsigned long *)0x40025520))
#define GPIO_PORTF_CR_R (*((volatile unsigned long *)0x40025524))
#define GPIO_PORTF_AMSEL_R (*((volatile unsigned long *)0x40025528))
#define GPIO_PORTF_PCTL_R (*((volatile unsigned long *)0x4002552C))
#define SYSCTL_RCGC2_R (*((volatile unsigned long *)0x400FE108))

Na sessão 2, declaramos as variáveis que iremos utilizar e os protótipos das funções que também serão necessárias para nosso programa.

// 2. Declarations Section
// Global Variables
unsigned long In; // input from PF4
unsigned long Out; // outputs to PF3,PF2,PF1 (multicolor LED)

// Function Prototypes
void PortF_Init(void);
void Delay(void);
void EnableInterrupts(void);

Por fim, chegamos onde o interessante acontece. Na sessão 3 descrevemos o comportamento do nosso sistema, declarando a função principal (main) e as funções auxiliares, cujos protótipos foram declarados anteriormente. Nosso sistema funcionará da seguinte forma:

  • Se o switch 1 (SW1) não estiver pressionado, o LED irá alternar entre Azul e Vermelho;
  • Se o switch 2 (SW1) estiver pressionado, o LED irá alternar entre Azul e Verde.

Assim, para realizar esse comportamento podemos usar a seguinte lógica:

// 3. Subroutines Section
// MAIN: Mandatory for a C Program to be executable
int main(void){

PortF_Init(); // Call initialization of port PF4 PF2

while(1){
In = GPIO_PORTF_DATA_R&0x10; // read PF4 into In
if(In == 0x00){ // zero means SW1 is pressed
GPIO_PORTF_DATA_R = 0x08; // LED is green
}
else{ // 0x10 means SW1 is not pressed
GPIO_PORTF_DATA_R = 0x02; // LED is red
}
Delay(); // wait 0.1 sec
GPIO_PORTF_DATA_R = 0x04; // LED is blue
Delay(); // wait 0.1 sec
}
}

// Subroutine to initialize port F pins for input and output
void PortF_Init(void){
volatile unsigned long delay;

SYSCTL_RCGC2_R |= 0x00000020; // 1) F clock
delay = SYSCTL_RCGC2_R; // delay
GPIO_PORTF_LOCK_R = 0x4C4F434B; // 2) unlock PortF PF0
GPIO_PORTF_CR_R = 0x1F; // allow changes to PF4-0
GPIO_PORTF_AMSEL_R = 0x00; // 3) disable analog function
GPIO_PORTF_PCTL_R = 0x00000000; // 4) GPIO clear bit PCTL
GPIO_PORTF_DIR_R = 0x0E; // 5) PF4,PF0 input, PF3,PF2,PF1 output
GPIO_PORTF_AFSEL_R = 0x00; // 6) no alternate function
GPIO_PORTF_PUR_R = 0x11; // enable pullup resistors on PF4,PF0
GPIO_PORTF_DEN_R = 0x1F; // 7) enable digital pins PF4-PF0
}

// Subroutine to wait about 0.1 sec
void Delay(void){
unsigned long volatile time;
 time = 727240*200/91; // 0.1sec
 while(time){
 time--;
 }
}

A função PortF_Init() é responsável por inicializar a Porta F de nossa Tiva, de forma que os pinos PF1, PF2 e PF3 sejam configurados como saídas digitais; e que PF4 seja configurado como uma entrada digital (SW1). A função Delay(), faz com que seja gerado um delay de aproximadamente 0.1 segundo. Essa não é a melhor forma para gerar um delay, mas para nossa aplicação inicial será suficiente. Futuramente iremos aprender a utilizar o SysTick Timer para gerar delays de forma mais precisa.

Pronto! Você acaba de escrever seu primeiro programa. Agora precisamos convertê-lo em código de máquina (compilar) e testá-lo em nossa Tiva. No menu superior, vá em PROJECT -> Build Target; ou simplesmente aperte F7. Se não houve problemas, você verá no terminal inferior a seguinte mensagem:

20_Keil10

Vamos fazer o download de nossa aplicação para a placa. Conecte sua Tiva ao seu computador, vá ao menu superior em FLASH -> Download.

Tudo Ok, vamos ao Debug Mode. Na aba superior você encontrará o seguinte ícone: 20_Keil11. Clique nele, ou aperte CTRL+F5 para iniciar o modo Debug.

Após entrar no modo Debug, sua tela deve ser algo parecido com isso:

20_Keil12

Por enquanto você está com o software iniciado em sua placa esperando suas ordens para execução: note que estamos parados na instrução que “invoca” a função PortF_Init(). Para rodar o software continuamente e testarmos nosso sistema, clique no ícone RUN, localizado abaixo do botão de Save, ou aperte F5.

Parabéns! Você acaba de completar seu primeiro programa em sua Tiva LaunchPad. Note que sua placa já está piscando Azul-Vermelho. Se pressionar o SW1 ela muda para Azul-Verde.

Acompanhe o nosso blog e não perca as próximas aplicações que vamos desenvolver para a nossa Tiva. Se gostou, não deixe de espalhar a palavra e se tem alguma dúvida ou sugestão, deixe seu comentário!

Até o próximo post!

Introdução ao Tiva C LaunchPad

Olá leitores do Control-Aut! Eu sou o Bruno Eilliar e tive a honra de ser convidado pelo Henrique para fazer uma parceria e trazer à vocês o pouco que sei sobre temas relacionados à Robótica, Controle de Sistemas, Sistemas Embarcados e tudo mais que vocês considerarem importante ser discutido. Espero que seja uma parceria duradoura e que eu possa contribuir de forma positiva no aprendizado de vocês.

Um pouco sobre mim: sou formado em Engenharia de Controle e Automação pelo IFSP e atualmente curso o  Mestrado em Controle e Automação de Processos, também no IFSP. Tive a oportunidade de fazer intercâmbio acadêmico em Portugal, pelo Ciência sem Fronteiras, onde cursei um ano do Mestrado em Robótica e Sistemas Não Lineares. Acima de tudo sou um aficionado por ciência e tecnologia, e tenho como objetivo de vida continuar a aprender sempre, afinal, a vida é um constante aprendizado. Vivo sob a máxima de Sócrates: “Sei que nada sei…”. Agora que já nos conhecemos um pouco vamos ao que interessa.

Hoje vamos fazer uma introdução  para você que quer começar a programar microtontroladores da família ARM®, um arquitetura que vem constantemente crescendo e que domina o mercado mobile. Especificamente vou apresentar a Tiva C Series LaunchPad, da Texas Instruments. Trata-se de uma placa de desenvolvimento de baixo custo que contém um microcontrolador ARM® Cortex™-M4F em seu core, já vem com um LED RGB e dois botões de interface (input) para testar as suas primeiras aplicações.

00_TivaC

Trata-se de uma evolução da Stellaris, também da Texas Instruments, com alguns features melhorados e você pode encontrá-la pelo preço de 12,99 dólares (mais frete) no próprio site da TI. Vamos à alguns detalhes técnicos para entendermos porque é uma excelente opção à outras placas como Arduino e MSP430 – no quesito performance/custo.

Sua LaucnhPad vem com as seguintes features:

  • Microcontrolador TM4C123GH6PMI;
  • Controle por modulção PWM;
  • Conexão USB micro-A e micro-B habilitada para conectividade USB Device, Host e On-The-Go (OTG);
  • LED RGB e dois Switches;
  • On-board In-Circuit Debug Interface (ICDI);
  • Switch para seleção de fonte de energia: ICDI ou USB device;

O diagrama de blocos abaixo, esquematiza como os componentes estão interligados na placa.

10_TivaDiagramaBloco

Sobre o Microcontrolador

O TM4C123GH6PM é um microcontrolador baseado na arquitetura ARM Cortex-M4 de 32 bit, com 256 KB de memória Flash, 32 KB de SRAM e 2 KB de EEPROM, operando a uma frequência de até 80 MHz (lembrando que o MSP430G e Arduino operam ao máximo de 16 MHz). Como interfaces de comunicação, o Tiva apresenta:

  • 8 UARTs (Universal Asynchronous Receivers/Transmitters;
  • 4 módulos SSI (Synchronouns Serial Interface);
  • 4 módulos I2C (Inter-Integrated Circuit) com 4 velocidades de transmissão, incluindo de alta velocidade;
  • 2 controladores CAN 2.0 A/B (Controller Area Network) e
  • USB 2.0 OTG/Host/Device.

Como foi dito, sua placa possui um LED RGB e dois Switches para testar algumas aplicações imediatamente. Estas interfaces estão conectadas à Porta F do microcontrolador, obedecendo à seguinte ordem:

GPIO PIN Pin Function USB Device
PF4 GPIO SW1
PF0 GPIO SW2
PF1 GPIO RGB LED (Red)
PF2 GPIO RGB LED (Blue)
PF3 GPIO RGB LED (Green)

 

Programando sua TIVA

Bom, basicamente existem duas formas, ou duas IDEs (Integrated Development Environment), que podem ser utilizadas para programar sua Tiva. A primeira delas, mais indicada para hobbystas – pois dispensa o conhecimento de arquitetura, registradores, etc – é a Energia que basicamente é uma IDE com cara de Arduino! Com ela você pode programar a maioria das LaunchPads da TI da mesma forma que você iria programar o seu Arduino. O próprio site da Energia contém informações de como realizar a instalação, mapeamento de portas e etc.

A segunda forma, que vamos utilizar em nossos futuros exemplos, é voltada para quem já tem algum conhecimento em eletrônica digital e arquitetura de microcontroladores, pois vai demandar conhecimento de Registradores, Memória, Stack Pointer, etc. Aqui você tem duas opções: Code Composer Studio   e Keil µVision . Particularmente, prefiro o Keil µVision, pois ao meu ver é uma IDE que roda de forma mais fluida e tenho a opção de instalar só a versão para ARM, enquanto o CCS vem com suporte para todos os microcontroladores da TI.

Nossos futuros exemplos foram concebidos e serão apresentados usando a IDE Keil. Para isso é preciso usar o seguinte arquivo para inicialização do microcontrolador (startup.s) e utilizar todas as funções do Debugger.

Bom Sras. e Srs., por hoje vamos ficar por aqui. No próximo post sobre a Tiva, vamos mostrar como criar um projeto e desenvolver nosso primeiro sistema, nossa versão de Hello World! para sistemas embarcados. Se gostou, não deixe de espalhar a palavra e se tem alguma dúvida ou sugestão, deixe seu comentário!

Até o próximo post!