Minha paixão pela comu­nidade open-source é recente. Foi de alguns anos para cá que come­cei a entrar e enten­der este uni­verso, cheio de gente com­pe­tente, cria­tiva e dis­posta a con­tribuir. Estas pes­soas não bus­cam rec­om­pen­sas finan­ceiras, mas sim con­hec­i­mento e troca de exper­iên­cias. É muito mais fácil con­struir um castelo quando cada um esta dis­posto a aju­dar com um tijolo. E esta é a filosofia que sigo quando penso em con­tribuir com meu pequeno tijolo aqui no blog.

E se você pensa em entrar para a área de sis­temas embar­ca­dos, ou se apro­fun­dar nela, não pre­cisa gas­tar 1 cen­tavo. A comu­nidade open-source está aí para te aju­dar. Você quer apren­der ou se apro­fun­dar em micro­con­tro­ladores PIC? Basta um PC, e você terá com­pi­ladores e ambi­entes de desen­volvi­mento com­ple­tos, debug­gers e sim­u­ladores, todos open-source. De des­culpa pra apren­der aqui, só sobra a preguiça. 

Quem quiser con­hecer mais sobre a filosofia open-source pode começar lendo o artigo da Wikipedia aqui.

Vamos ver então algu­mas fer­ra­men­tas open-source para desen­volvi­mento de sofware em C para micro­con­tro­ladores PIC. Vou ape­nas apre­sen­tar as fer­ra­men­tas, o processo de insta­lação e con­fig­u­ração vocês podem ver­i­ficar dire­ta­mente no link da página da fer­ra­menta.

Com­pi­lador C

Para o com­pi­lador C, usare­mos o SDCC. O SDCC é um com­pi­lador ANSI-C otimizado para micro­con­tro­ladores de pequeno porte, como 8051, Z80 e 68HC08. Segundo a página do pro­jeto, o suporte a PIC está em anda­mento (“Work in progress”), mas todas as vezes que usei fun­cio­nou per­feita­mente. Ele está disponivel sob a licensa GPL para Win­dows, Linux e Mac.

Ele é ape­nas um com­pi­lador C, e vai ape­nas trans­for­mar seus arquivos “.c” em arquivos “.asm”. Então ele pre­cisa do assem­bler e do linker para gerar o binário da sua apli­cação.

Assem­bler e Linker

Para o assem­bler e o linker usare­mos a fer­ra­menta GPUTILS. Esta fer­ra­menta é voltada exclu­si­va­mente para micro­con­tro­ladores PIC, e além do assem­bler (gpasm) e do linker (gplink), tam­bém fornece uma fer­ra­menta para criar bib­liote­cas (gplib).

Esta fer­ra­menta tam­bém está disponivel através da licensa GPL para Linux, Win­dows e Mac.

IDE — Ambi­ente de Desen­volvi­mento

Para alguns, escol­her um ambi­ente inte­grado de desen­volvi­mento (IDE) é quase a mesma coisa que escol­her uma religião, e o defen­dem como tal. Para mim, é ape­nas uma forma de ser mais pro­du­tivo no seu ambi­ente de tra­balho. Por­tanto, escolha uma fer­ra­menta que se adapte mel­hor à você. Exis­tem muitas fer­ra­men­tas disponíveis, alguma especí­fi­cas para PIC, den­tre elas:

• PiKdev, com­pa­tivel com assem­bly para todos os PICs e lin­guagem C ape­nas para a série PIC18.
• Pik­lab, é mais com­pleto, bem pare­cido com o MPLAB, e total­mente inte­grado com SDCC e GPUTILS.
• Eclipse, ambi­ente mais genérico, mas pode ser exten­dido através de plu­g­ins. Par­tic­u­lar­mente acho ainda um pouco lento e com­plexo para con­fig­u­rar e tra­bal­har com pro­je­tos. Mas uma vez con­fig­u­rado pode se tornar um ambi­ente de desen­volvi­mento alta­mente produtivo.
• Kde­velop, ambi­ente com visual bem limpo e fácil de usar. É mais gener­ico, mas para desen­volver em C está ótimo. É o que estou usando atual­mente.
  

Gravadores

Se você tem um gravador PIC, exis­tem algu­mas fer­ra­men­tas open-source como o PICProg, com­pa­tivel com os micro­con­tro­ladores da série PIC12/16/18.

Sim­u­ladores

Um ótimo sim­u­lador open-source para PIC é o GPSIM. Tam­bém disponi­bi­lizado sob a licensa GPL, pos­sui tudo o que um decente sim­u­lador pre­cisa ter (break­points, exe­cução passo-a-passo, dis­as­sem­bler, etc; e suporta até in-circuit emu­la­tor). Tem ver­sões para Win­dows e Linux.

Inte­grando tudo

Vamos desen­volver aqui um pro­jeto bem sim­ples para exem­pli­ficar o uso de todas estas fer­ra­men­tas.

Primeiro, nosso codigo-fonte em C, cujo único obje­tivo é acen­der um led lig­ado ao port B do PIC:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include "pic16/pic18f452.h"
 
/* configuration bits */
code char at __CONFIG1H _conf0 = _OSC_HS_1H;
code char at __CONFIG2L _conf1 = _PUT_OFF_2L & _BODEN_OFF_2L;
code char at __CONFIG2H _conf2 = _WDT_OFF_2H;
code char at __CONFIG3H _conf3 = _CCP2MUX_RC1_3H;
code char at __CONFIG4L _conf4 = _LVP_OFF_4L & _STVR_OFF_4L;
code char at __CONFIG5L _conf5 = _CP_0_OFF_5L & _CP_1_OFF_5L & _CP_2_OFF_5L & _CP_3_OFF_5L;
code char at __CONFIG5H _conf6 = _CPD_OFF_5H & _CPB_OFF_5H;
code char at __CONFIG6L _conf7 = _WRT_0_OFF_6L & _WRT_1_OFF_6L & _WRT_2_OFF_6L & _WRT_3_OFF_6L;
code char at __CONFIG6H _conf8 = _WRTD_OFF_6H & _WRTB_OFF_6H & _WRTC_OFF_6H;
code char at __CONFIG7L _conf9 = _EBTR_0_OFF_7L & _EBTR_1_OFF_7L & _EBTR_2_OFF_7L & _EBTR_3_OFF_7L;
code char at __CONFIG7H _conf10 = _EBTRB_OFF_7H;
 
void main( )
{
    TRISB = 0;
    PORTB = 0x01;
 
    while(1);
}

Vamos pre­cisar de um arquivo Make­file para com­pi­lar, inte­grando o uso das fer­ra­men­tas SDCC e GPUTILS:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

teste.hex: teste.o
	gplink \
        -c \
        -s /usr/share/gputils/lkr/18f452.lkr \
        -o $@ \
        -m \
        $^ \
        -I /usr/share/sdcc/lib/pic16 \
        libdev18f452.lib
 
teste.o: teste.asm
	gpasm -c $<
 
crt018.o: crt018.asm
	gpasm -c $<
 
teste.asm: teste.c
	sdcc -S -mpic16 -p18f452 $<

Veja no Make­file que usamos a fer­ra­menta “sdcc” para com­pi­lar o “.c” e gerar o “.asm”, depois usamos o “gpasm” para con­verter o “.asm” em “.o”, para então linkar usando o “gplink” e criar o arquivo binário “.hex”.

Agora, se você tiver um gravador pode gravar usando o PICProg com o comando abaixo:

picprog –erase –burn –input teste.hex –pic /dev/ttyS0

Ou então você pode usar o GPSIM para sim­u­lar sua apli­cação, com o comando abaixo:

gpsim –pp18f452 –L. teste.hex

Exem­plo de uma tela do GPSIM:

Muito bem, agora é com você! Aprenda, troque exper­iên­cias e aproveite o que a comu­nidade open-source têm para lhe ofer­e­cer. E depois, a mel­hor forma de agrade­cer é deixar tam­bém sua con­tribuição para a comu­nidade!

Um abraço,

Ser­gio Prado

Sem posts relacionados.