Microcontroladores

Dois IDEs que gosto e dois que odeio

No princípio você descobre o Dev-C++ começa a programar e os bugs te atormentam. Não lembro quais são eles mas me fez procurar alternativas e encontrei o caso de amor:

Code::Blocks – O profissional

Feito para ser uma alternativa ao Dev-C++ já deixou de ser alternativa e se tornou regra. Evoluiu muito e tem cada vez mais agregado funcionalidades úteis.

Captura de tela de 2016-07-01 19-47-20 - 1.png

Como se pode ver na figura os Templates são variados e nos ultimos releases há uma busca pelo desenvolvimento embarcado se aproveitando das diversas plataformas suportadas pelo GCC e o SDCC.

O Code::Blocks suporta desde o começo muitos compiladores. No Windows o download já vem embutido o Mingw ou TDM-GCC.

Eu uso ele profissionalmente para desenvolvimento C/C++ para as plataformas ARM (STM32 ou Kinetis) e AVR bem como x86. Deu um pouco de trabalho a configuração inicial dele para STM32 mas foi gratificante e muito instrutivo.

Captura de tela de 2016-07-01 19-59-01.png

O que mais gosto nele é facilidade de configuração e início médio. Eu odeio programas lentos como se verá nos que odeio. Mas ainda há uma opção veloz …

Geany – O pequeno poderoso

Eu adoro o Geany. É o IDE perfeito para testes rápidos e desenvolvimentos descompromissados. Diferente do Code:Blocks ele suporta diversas linguagens e tenho usado muito ultimante para Python.

Apesar de ter a opção de criar projetos o que me atrai nele é justamente você poder criar um arquivo, digitar o código e botar para rodar diretamente sem maiores burocracias. Por isso é perfeito para testes.E ao fechá-lo e abri-lo posteriormente as abas estarão lá abertas novamente.  Na verdade um projeto é nada mais que organizar seus arquivos em pastas que são navegáveis no painel “Aquivos” ao lado. Se o projeto cresceu então junte tudo em uma pasta e trabalhe com ela.

Captura de tela de 2016-07-01 20-03-43.png

E o inicio é rapido!

Como eu gosto disto! Clicou abriu! E o terminal embaixo? Quebra um galhão. Com um suporte a debug  ele pode até substituir o Code::Blocks.

linux_dark_1-24_weblinux_dark_1-24

As caras são muitas ao Geany para todos os gostos. Acho bonito programar em escuro mas não consigo me acostumar.

Os que odeio

Eclipse – Lerdeza

Pelo amor de Deus … como demora esta coisa para iniciar. Fiquei injuriado quando a Freescale mudou sua IDE para variantes Eclipse. Clicava em debug e aquela coisa ficava pensando … pensando … indexando. Que horror. Por isso fiz um esforço e aprendi a configurar o Code::Blocks para ARMs.

Essa tendência de se fazer IDEs baseadas no Eclipse para mim foi um desastre. A Texas fez isso, a Freescale e a ST esta indo no caminho. Sim, sim sei que o Eclipse é muito versátil mas convenhamos muito lento.  Certeira foi a Atmel que partiu para uma solução Visual Studio.

plc2-2015-your-own-ide-4-638

E aquela burocracia para se criar um projeto???? O sujeito que programa para sistemas embarcados em Eclipse se aprender diretamente nele se torna dependente do mesmo; porque não terá a menor noção de como se programa para uma plataforma: que comandos, que bibliotecas, que caminhos, como usar os comandos de debug. Tudo isso fica escondido em trezentos cliques que da medo e preguiça de mexer.

Se você usa o Eclipse e não tem a menor idéia de como as coisas funcionam por favor veja neste post como se programa “na mão”  um STM32.

Descobri neste site http://www.ihateeclipse.com  que não sou o único!

Vim/VI – O Geek

Fui atrás de um screenshot deles no Google e o que acho? Curiosamente mais destas imagens que do próprio em questão. Isto já diz tudo:

vi-vim-cheat-sheet

Ai vem aquele moleque que quer ser diferente e se acha o maior por usar um desses.

A primeira instalação que fazia em algum Linux novo  – antigamente pois depois do ArchLinux nunca mais fiz instalação nova – era o MCEdit para evitar ter que editar arquivos de configurações nesta !@#$!. Aliás como se sai mesmo dele?  Era algo como ESC-Q!.

Eu não odeio o Terminal. Eu adoro o modo texto! Uso demais o Guake (terminal suspenso), mas perder meu tempo aprendendo esses atalhos se posso usar um IDE mais robusto não é comigo.

Fazer um esforço para aprender estes comandos para mim é uma perda de tempo se posso aprender muitas outras coisas mais úteis. De fato no momento estou fazendo um esforço para escrever robôs investidores em Forex e Bolsa e estou adorando o tema em torno de processos estocásticos. O Geany e o Metatrader estão sendo perfeitos para isso.

main-qimg-cf12b776c0e69ec6d30a47b0d90792d9

Geração dodói

Se você programa nestas coisas parabéns te admiro, mas não me pertube.

 

 

 

Seleção de utilidades para o hobby eletrônico no AliExpress

Sabe aqueles vídeos ou fotos de pessoas que realizam diversas montagens nos protoboards com aqueles fios bonitinhos, usando aqueles módulos pequenos e úteis ou placas padrão? Então. Lembro-me que achava que nunca conseguiria ter tudo aquilo. Porém depois de descobrir o AliExpress lá atrás devagar fui comprando pequenas utilidades sem gastar mais que R$ 50,00 por entrega (já que algumas levam algumas semanas para chegar). Se eu tivesse comprado no Brasil estaria perdido, falido esta hora.

Então segue um lista que acho útil e talvez você não conseguiu achar por não saber os nomes.

 

male-to-male-color-breadboard-cable-jump-wire-font-b-jumper-b-font-for-font-b_220x220 free-shipping-straight-curve-font-b-tweezers-b-font-eyelash-extension-tool-eyelash-makeup-beauty-stainless_220x220 usb-font-b-logic-b-font-font-b-analyzer-b-font-100m-max-sample-rate-16channels_220x220

Três ferramentas de extrema utilidade. 40 Fios com terminais por U$ 2,40. Pinças de boa qualidade. E um analisador lógico indispensável para depurar saidas de MCUs. Checar 6 canais de PWM sem um destes é loucura…

2015-new-mb102-power-supply-module-3-3v-5v-breadboard-board-830-point-65pcs-font-b_220x220

Os pacotes se bem achados são muito econômicos. E esse é o grande diferencial do AliExpress. Isto tudo ai sai por somente U$ 5,60. O módulo de fonte pode ser alimentado por USB ou a fonte de 9V do Arduino. Tem LED, 3.3v/5v e chave liga-desliga. O módulo foi feito para se encaixar perfeitamente no protoboard.

with-the-bootloader-font-b-nano-b-font-3-0-controller-compatible-for-font-b-arduino_220x220

Por menos de U$ 3,00 você leva esse Arduino Nano e pode transformá-lo em gravador ISP e conectar direto na protoboard. Tem a mesma capacidade dos Arduinos normais porém menor e prático.

20pcs-5x7-4x6-3x7-2x8-cm-double-side-copper-prototype-font-b-pcb-b-font-font_220x2201 qfn-tqfp-font-b-lqfp-b-font-qfp-16-80-pin-0-5mm-pitch-to-dip_220x220

Uma hora um projeto tem que ficar definitivo. E estas placas ajudam muito. Feitas em fibras são ótimas. Também as adaptadoras de CIs SMDs são extremamente úteis.

1pcs-usb-to-font-b-ttl-b-font-uart-module-ch340g-ch340-3-3v-5v-font_220x220

Úteis para qualquer desenvolvedor para MCUs. Estes módulos de comunicação serial também servem para alimentação 3.3.V/5V baixa corrente. Ligue o terra o positivo e RX com TX e pronto você tem uma forma de debugar seus programas. Compre uns 5 desses porque qualquer besteira sua e adeus módulo.

ac-100v-240v-converter-adapter-dc-9v-1a-font-b-power-b-font-font-b-supply_220x220 new-high-quality-5v-2a-v8-us-micro-usb-charger-charging-adapter-font-b-power-b_220x220

Seleção de fontes. A primeira de 9V para o Arduino e a ultima para o Raspberry Pi com 5V/2A.

free-shippin-5pcs-lot-font-b-atmega328p-b-font-pu-font-b-atmega328p-b-font-dip_220x220 the-original-5pcs-font-b-attiny85-b-font-20pu-font-b-attiny85-b-font-20pu-font_220x220 1pcs-stm32f103c8t6-arm-font-b-stm32-b-font-minimum-system-development-board-module-for-arduino_220x220

Quanto é um ATMEGA328P no Brasil? Que tal pelo mesmo preço comprar 5? E o Attiny85? E por ultimo os STM32 são uma boa pedida para começar a programar para ARM e arquiteturas 32 bits. Todos sem dúvida irão precisar de um gravador.  No caso dos Atmel o Arduino Nano já mostrado acima serve. Para o STM32 o STLINK pelo mesmo preço grava STM8 e STM32.

 

Bom espero que tenha sido útil. Montar uma bancada aos poucos com diversos CIs equipamentos vai lhe trazer um diferencial no desenvolvimento, aprendizado rico e economizar muita grana se tiver paciência e comprar na China. Agora o AliExpress aceita pagamentos por Boleto facilitando para os jovens sem conta em banco.

O meu carrinho vive cheio de coisas no site. É uma perdição.

 

Ponteiros em 7 arquiteturas – de z80 a ARM

Eu admito que somente entendi ponteiros quando fiz a ponte entre código em C e Assembly. Ponteiros são complicados mesmo. É um disfarce de alto nível para o baixo nível da máquina. Ponteiros devem ser usados com cuidado em muitos aspectos; como no problema de alocação dinâmica e liberação da memória alocada, múltiplas instâncias do mesmo endereço, problemas de endianess, acessos não autorizados ou em áreas indesejadas …

Por curiosidade gerei o código assembly  do código em C abaixo para 7 processadores ou microcontroladores sendo eles: HCS08, STM8, Z80, X86-64,  ARM, ColdFire e AVR.

 int *a,*b;
 char *c;
 int i = 10;

void main(void)
 {

a = &i;
 b = a;
 *b = *b + 5;
 c = (char *) &i;
 *c = *c + 5;
 c = c + 5;

while (1);

}

E vamos aos códigos. É bom lembrar que diferenças irão ocorrer não somente pela arquitetura mas pelos compiladores usados. Um exemplo é o SDCC que para somar 5 não utilizou instrução de soma mas cinco incrementos para o Z80, provavelmente pela contagem de ciclos.

ColdFire – O mais limpo dos códigos

_main:
; main:
lea _i(a5),a0
move.l a0,_a(a5)
;
; 13: b = a;
;
move.l _a(a5),d0
move.l d0,_b(a5)
;
; 14: *b = *b + 5;
;
movea.l d0,a0
addq.l #5,(a0)
;
; 15: c = (char *) &i;
;
lea _i(a5),a0
move.l a0,_c(a5)
;
; 16: *c = *c + 5;
;
movea.l _c(a5),a0
mvs.b (a0),d0
addq.l #5,d0
move.b d0,(a0)
;
; 17: c = c + 5;
; 18:
; 19: while (1);
;
addq.l #5,_c(a5)
;
; 19: 1);
;
bra.l *+0</pre>

Z80 – Se aproveita de seus registradores de 16 Bits e acesso indireto

_main::
 61 ;ponteiros.c:9: a = &i;
ld de,#_i+0
ld (_a),de
 64 ;ponteiros.c:10: b = a;
ld hl,(_a)
ld (_b),hl
 67 ;ponteiros.c:11: *b = *b + 5;
ld hl,(_b)
push hl
ld c,(hl)
inc hl
ld b,(hl)
pop hl
inc bc
inc bc
inc bc
inc bc
inc bc
ld (hl),c
inc hl
ld (hl),b
 82 ;ponteiros.c:12: c = (char *) &i;
ld (_c),de
 84 ;ponteiros.c:13: *c = *c + 5;
ld hl,(_c)
ld a,(hl)
add a, #0x05
ld (hl),a
 89 ;ponteiros.c:14: c = c + 5;
ld hl,#_c
ld a,(hl)
add a, #0x05
ld (hl),a
inc hl
ld a,(hl)
adc a, #0x00
ld (hl),a
 98 ;ponteiros.c:16: while (1);
00102$:
jr 00102$

STM8 – O registrador x de 16 bits e as instruções de carga 16 bits ajudam muito


1 ; C Compiler for STM8 (COSMIC Software)
 2 ; Parser V4.10.2 - 02 Nov 2011
 3 ; Generator (Limited) V4.3.7 - 29 Nov 2011
 15 bsct
 16 0000 _i:
 17 0000 000a dc.w 10
 50 ; 7 main()
 50 ; 8 {
 52 switch .text
 53 0000 _main:
 57 ; 10 a = &i;
 59 ldw x,#_i
 60 ldw _a,x
 61 ; 11 b = a;
 63 ldw x,#_i
 64 ldw _b,x
 65 ; 12 *b = *b + 5;
 67 ldw x,_i
 68 addw x,#5
 69 ldw _i,x
 70 ; 13 c = (char *) &i;
 72 ldw x,#_i
 73 ldw _c,x
 74 ; 14 *c = *c + 5;
 76 ld a,_i
 77 add a,#5
 78 ld _i,a
 79 ; 15 c = c + 5;
 81 ldw x,#_i+5
 82 ldw _c,x
 83 L12:
 84 ; 17 while (1);
 86 jra L12
 140 xdef _main
 141 xdef _i
 142 switch .ubsct
 143 0000 _c:
 144 0000 0000 ds.b 2
 145 xdef _c
 146 0002 _b:
 147 0002 0000 ds.b 2
 148 xdef _b
 149 0004 _a:
 150 0004 0000 ds.b 2
 151 xdef _a
 171 end

HCS08 – Surpreso? Esse processador só tem um registrador index e um acumulador!


11: 
 12: a = &i;
 LDHX @i
 STHX a
 13: b = a;
 STHX b
 14: *b = *b + 5;
 LDHX ,X
 AIX #5
 TXA 
 PSHH 
 LDHX @i
 STA 1,X
 PULA 
 STA ,X
 15: c = (char *) &i;
 16: *c = *c + 5;
 ADD #5
 STA ,X
 17: c = c + 5;
 AIX #5
 STHX c
 L1E:
 19: while (1);
 BRA L1E
 21: }

X86-64 –

{
 push %rbp
 mov %rsp,%rbp

 a = &i;
 movq $0x0,0x0(%rip)  
 b = a;
 mov 0x0(%rip),%rax 
 mov %rax,0x0(%rip) 
 *b = *b + 5;
 mov 0x0(%rip),%rax 
  mov 0x0(%rip),%rdx 
 mov (%rdx),%edx
 add $0x5,%edx
 mov %edx,(%rax)
 c = (char *) &i;
 movq $0x0,0x0(%rip) 

 *c = *c + 5;
 mov 0x0(%rip),%rax 
 mov 0x0(%rip),%rdx 
 movzbl (%rdx),%edx
 add $0x5,%edx
 mov %dl,(%rax)
 c = c + 5;
 mov 0x0(%rip),%rax 
 add $0x5,%rax
 mov %rax,0x0(%rip) 

 while (1);
 jmp 65

ARM – É um RISC …


push {fp} ; (str fp, [sp, #-4]!)
add fp, sp, #0 
//a = &i;
ldr r3, [pc, #116] 
ldr r2, [pc, #116] 
str r2, [r3]
//b = a;
ldr r3, [pc, #104] 
ldr r3, [r3]
ldr r2, [pc, #104] 
str r3, [r2]
//*b = *b + 5;
ldr r3, [pc, #96] 
ldr r3, [r3]
ldr r2, [pc, #88] 
ldr r2, [r2]
ldr r2, [r2]
add r2, r2, #5
str r2, [r3]
//c = (char *) &i;
ldr r3, [pc, #72] 
ldr r2, [pc, #60] 
str r2, [r3]
//*c = *c + 5;
ldr r3, [pc, #60] 
ldr r3, [r3]
ldr r2, [pc, #52] 
ldr r2, [r2]
ldrb r2, [r2]
add r2, r2, #5
and r2, r2, #255 
strb r2, [r3]
//c = c + 5;
ldr r3, [pc, #28] 
ldr r3, [r3]
add r3, r3, #5
ldr r2, [pc, #16] 
str r3, [r2] 
//while (1);
b 80 

AVR – Infelizmente o processamento ficou todo em registradores


push r28
push r29
in r28, 0x3d ; 61
in r29, 0x3e ; 62 
// a = &i;
ldi r24, 0x00 ; 0
ldi r25, 0x00 ; 0
sts 0x0000, r25
sts 0x0000, r24
// b = a;
lds r24, 0x0000
lds r25, 0x0000
sts 0x0000, r25
sts 0x0000, r24
// *b = *b + 5;
lds r24, 0x0000
lds r25, 0x0000
lds r18, 0x0000
lds r19, 0x0000
mov r30, r18
mov r31, r19
ld r18, Z
ldd r19, Z+1 ; 0x01
subi r18, 0xFB ; 251
sbci r19, 0xFF ; 255
mov r30, r24
mov r31, r25
std Z+1, r19 ; 0x01
st Z, r18
// c = (char *) &i;
ldi r24, 0x00 ; 0
ldi r25, 0x00 ; 0
sts 0x0000, r25
sts 0x0000, r24
// *c = *c + 5;
lds r24, 0x0000
lds r25, 0x0000
lds r18, 0x0000
lds r19, 0x0000
mov r30, r18
mov r31, r19
ld r18, Z
subi r18, 0xFB ; 251
mov r30, r24
mov r31, r25
st Z, r18
// c = c + 5;
lds r24, 0x0000
lds r25, 0x0000
adiw r24, 0x05 ; 5
sts 0x0000, r25
sts 0x0000, r24

// while (1);
rjmp .+0

Afinal o que é um ponteiro? É simplesmente uma posição de memória que guarda um endereço que contém algum dado.

São dois endereços: Um é a variável que contém o dado, o outro contém o endereço desta variável.

Assim b = &i diz ao processador para guardar no endereço b o endereço de i. Logo b e i estão apontando para o mesmo dado. Mas b não é igual a i. A variável i é um endereço que contém um dado e o ponteiro b é um endereço que contém um endereço que contém um dado.

Veja em HCS08

// a = &i
LDHX @i
STHX a
Carrega o endereço de i em HX e posteriormente guarda o valor de HX em a

Veja que em STM8

// *b = *b + 5
67 ldw x,_i
68 addw x,#5
69 ldw _i,x

O compilador decidiu por não usar o ponteiro b para acessar i pois ele percebeu que b ainda contém o endereço de i e usou diretamente o endereço de i. Normalmente o correto seria carregar o valor de b em x e então indiretamente ‘(x)’ carregar o valor endereçado por x no acumulador e finalmente efetuar a soma.

Foi exatamente o que o Z80 iria fazer

ld hl,(_b)
push hl
ld c,(hl)
inc hl
ld b,(hl)
pop hl
inc bc
inc bc
inc bc
inc bc
inc bc
ld (hl),c
inc hl
ld (hl),b

Espero ter ajudado a compreender o que de fato é um ponteiro. Entretanto este post foi útil e agradável ao demonstrar as diferentes formas de acesso a memória em diferentes arquiteturas e principalmente as otimizações que compiladores diferentes fazem.

 

ARM – SysTick fácil.

SysTick é um timer decrescente presente na maioria dos processadores ARM Cortex ligado diretamente ao Core Clock com registrador de 24 Bits.

O SysTick gera interrupção a cada estouro do contador, ou seja, quando chega em 0. Para configurar usando os registradores diretamente segue exemplo:

SysTick->CTRL = 0; // Desliga o SysTick
SysTick->LOAD = 1000; // Conta de 1000 até 0
SysTick->VAL = 0; // Valor inicial, e também valor da contagem atual
SysTick->CTRL = 0x7; // Liga o SysTick

Ou para quem tiver disponível os arquivos CMSIS (muito provavelmente) este pode ser inicializado diretamente:

Neste caso estabelecemos um estouro a cada 1ms

SysTick_Config(SystemCoreClock / 1000) ;

Neste o loop while trava se um valor impossível for inicializado.

while (SysTick_Config(48000000 / 2) != 0);  // 48Mhz / 2 = 24Mhz

Ótima opção para iniciar no mundo ARM.

Lembre-se que o tamanho máximo do contador é de 24 bits o que representa um valor decimal de 16777216. Assim dividir o 48Mhz por 2 retorna uma valor maior que o máximo possível. Deu para perceber que conseguir 1 Segundo de estouro só é possível em clocks mais baixo.

Para que as interrupções ocorram não esqueça de definir uma função (Handler) que deve estar adicionada na Vector Table:

void (* const g_pfnVectors[])(void) = {
&_estack,
Reset_Handler,
NMI_Handler,
FaultHandler,
0,
0,
0,
0,
0,
0,
0,
SVC_Handler,
0,
0,
PendSV_Handler,
SysTickIsr, //Função SysTickIsr que será chamada a cada estouro
};

Launchpads da TI

A TI tem disponível três kits para desenvolvimento e experimentação com suas principais categorias de microcontroladores. Chamados de Launchpads, são pequenos e robustos e o melhor o preço é muito baixo para algo que a pouco tempo era um luxo. Além dos preços serem pequenos são todos Free Shipping (sem frete) com os impostos pagos entregues pela Fedex! Cadastre-se logo no PayPal com um cartão de crédito internacional e vá ao site da TI comprar o seu. Algumas fontes de cartão de crédito internacionais gratuitos, sem anuidade e comprovantes de pagamentos são o Cartão da Saraiva (BB), Petrobrás (BB), Diccico (BB) e o Santander Free (Santandeer). Uma breve pesquisa do google te levará aos sites para preenchimento e aquisição dos cartões.

Os Launchpads disponíveis são:

  • Launchpad EK-LM4F120XL com sua linha ARM Cortex M4F Stellaris
  • Launchpad LAUNCHXL-F28027 utilizando a linha C2000 Piccolo de 32 Bits
  • Launchpad MSP-EXP430G2 que é o mais barato (foram apenas U$ 9,99) que vem com dois microcontoladores MSP430 de 16 Bits.

Para programar todos estes kits deve-se fazer download do IDE CCSv5 gratuito que utiliza o Eclipse disponível no site da TI. Esta disponível para Linux quanto Windows. E seu download é bem grande (algo em torno de 2G). Entretanto o Stellaris pode ser programado com ferramentas GNU por se tratar de um ARM. O MSP  também tem ferramentas GNU disponíveis. Já o Piccolo não.

Dentre todos o Piccolo me chamou atenção pelo preço final de um uC de 32 bits e o que vem embutido nele. É importante lembrar que a Texas com seu legado em DSPs TMS320 tem grande suporte nesta área com documentação, software e hardware. O Piccolo e o Stellaris vem com suporte em forma de hardware embutido para cálculos de sinais.