Arquivo da categoria: Menu

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!

Anúncios

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!

Eletrônica Digital: Lógica combinacional e sequencial

Olá caros leitores!

Peço desculpas pela ausência de posts novos no blog nos últimos meses. Não tive muito tempo recentemente para escrever e nem para preparar tutoriais novos. Pretendo trazer muita coisa nova em breve.

Recentemente precisei de uma revisão rápida de alguns conceitos específicos de eletrônica digital, e encontrei essa apresentação no slideshare, que me ajudou muito. Gostaria de compartilhá-la com todos vocês.

Essa apresentação aborda principalmente lógica sequencial, buscando fixar conceitos como portas lógicas, tabelas-verdade, álgebra de Boole, Mapa de Karnaugh, e a partir daí alguns conceitos de lógica sequencial como contadores e os mais diversos tipos de flip-flop.

Créditos: Professor Douglas Bressan Riffel / Universidade Federal de Sergipe

Chronos: ‘relógio’ de desenvolvimento wireless

ti_msp430_chronos_1Fala pessoal! Eu não poderia encerrar esse ano sem um post novo para o blog. Comecei com uma brincadeira no começo de Janeiro, e estou terminando Dezembro com cerca de 40.000 visualizações. Foi muito gratificante para mim perceber como isso cresceu, eu espero que continue crescendo muito em 2014, pois eu vou me dedicar muito à isso aqui.

Vamos ao que interessa. Alguns meses atrás tivemos a Semana de Tecnologia do IFSP. Que é um evento muito interessante e aberto ao público externo que ocorre geralmente no fim de Outubro. Muitas empresas vão interessadas em apresentar seus produtos aos estudantes da área de tecnologia, que em um futuro próximo, podem se tornar clientes potenciais. Um dos produtos que eu conheci na Semana de Tecnologia desse ano foi o Chronos, da Texas Instruments (mesma empresa que produz o MSP-430). Tal como foi falado no título do post, a utilização do Chronos se dá basicamente para o desenvolvimento de aplicações wireless utilizando um relógio. Pelo que vi, ele funciona muito bem em conjunto com o MSP-430. Ainda não adquiri o meu, mas pretendo adquiri-lo em breve. O preço que é um pouco salgado: comprando diretamente no site da Texas Instruments, o relógio sai por aproximadamente US$ 58,00.

Continuar lendo

Fã do Homem de Ferro cria réplica do capacete impressa em 3D

Fala pessoal,

iron_man_mask_adulto__11971_zoomEncontrei essa matéria no tecmundo, e achei essa reportagem interessantíssima, já que sou um grande fã do Iron Man. O cara simplesmente criou o capacete do Tony Stark em uma impressora 3D, e ainda abre e tem todas as luzes. Tudo isso usando o nosso bom e velho Arduino.

Em 2011, Ryan Brooks criou uma armadura do Homem de Ferro que cabia em uma maleta, exatamente como o personagem faz no segundo filme da franquia nos cinemas. Desta vez, o fã número um do herói da Marvel, que até se autoentitula “The Real Tony Stark”, resolveu construir um capacete da Mark III impresso em 3D e cheio de tecnologias de movimento.

Continuar lendo

Watch Oscilloscope – um relógio com função de osciloscópio

Olá, caros leitores!

a2aee16c4ff87d6570093b006a087b9a_largeEu vi ontem essa matéria no Lab de Garagem e decidi compartilhá-la com vocês. Lembram do post sobre os Primeiros Passos com o Osciloscópio? Então, os osciloscópios se caracterizam por serem instrumentos de portabilidade difícil, por serem pesados e desajeitados. Mas essa iniciativa, promete mudar essa história, confira.

Continuar lendo

Estudantes Desenvolvendo Peixe-Robô

Olá a todos!

Essa reportagem saiu no jornal que circula nos campi da minha faculdade,e se trata de um projeto que estou desenvolvendo à cerca de 1 ano com alguns amigos lá do Instituto Federal de São Paulo. Vejam a reportagem na íntegra:

nadandoHá cerca de um ano, o professor Alexandre Brincalepe lançou um desafio aos seus alunos do curso de Engenharia de Automação e Controle, do Campus São Paulo: criar um peixe-robô. No início, vários estudantes se voluntariaram para executar a tarefa, para a qual não havia incentivos como pontos adicionais na nota ou bolsa de estudo. O objetivo era simplesmente científico. Passado um ano, quatro estudantes ainda trabalham no projeto. Armando Choquetarqui Aro, Henrique Vitkauskas Doria, Jimmy Setsuo Hirata e Natália Mendes Ceoldo se dedicam, de forma voluntária, à construção do um robô biomimético – uma máquina capaz de mimetizar o comportamento de animais. A ideia surgiu após o professor verificar, no site do Instituto de Eletrotécnica e Energia (IEE), que havia muitos artigos recentes sobre peixes-robô e suas aplicações.

Continuar lendo