Gogo Board: Firmware USB – II

Encontramos neste outro artigo, uma forma de utilizar a comunicação USB, porém numa forma um pouco mais aprimorada, ou seja, além do envio e recebimento de informações, teremos um nível de interação de acordo com as teclas pressionadas no teclado do computador:

#include "bootloader.h"
#case
#include
#use i2c(MASTER,sda=PIN_B0,scl=PIN_B1,force_hw,slow)

void main(){
int msg;
BYTE i;
usb_init_cs();

do
{
usb_task();

if (usb_enumerated())
{
if (msg==0){
msg=1;
}
if (usb_cdc_kbhit())
{
i = toupper(usb_cdc_getc());

if (i == 'R')
{
printf(usb_cdc_putc, "Sending a R Back");
}

if (i == 'W')
{
printf(usb_cdc_putc, "Sending a W Back");
}
}
}
else {
if (msg==1){
msg=0;
}
}
} while (TRUE);
}

Assim como anteriormente, deveremos utilizar o HyperTerminal ou programa similar para verificar o resultado.

Anúncios

Gogo Board: Firmware USB

Com base neste artigo, poderemos criar um firmware simples, apenas para envio de dados pela porta USB:

#include "bootloader.h"
#case
#include
#use i2c(MASTER,sda=PIN_B0,scl=PIN_B1,force_hw,slow)

void main()
{
usb_cdc_init(); // Start cdc
usb_init(); // Start USB

for(;;) //Forever
{
usb_task(); // Test usb

if (usb_enumerated())
{
printf(usb_cdc_putc,"Testando Conexao USB->Serial!\n\r");
delay_ms (100);
}
}
}

Depois de gravado na placa, bastará utilizarmos o HyperTerminal ou programa similar e poderemos visualizar o resultado.

Gogo Board como Scratch Board – IX

Nesta segunda função, formataremos os dados referentes ao número do sensor, bem como seu valor e enviaremos através da conexão USB ao Scratch:

void sendScratchPacket(int NoCanal, long ValorSensor) {

output_high(RUN_LED);

printf(usb_cdc_putc,"%c", (0b10000000 | ((NoCanal & 0b1111) << 3) |
(((ValorSensor & 0b1111111111) >> 7) & 0b111)));
delay_us(400);
printf(usb_cdc_putc,"%c", ((ValorSensor & 0b1111111111) & 0x7F));

output_low(RUN_LED);

delay_us(400);
}

Gogo Board como Scratch Board – X

Ao observamos o firmware da Gogo Board, poderemos identificar a função:

switch (CMD_STATE) {}

Ela é responsável por identificar os dados enviados do computador à placa.

Sendo assim, logo em seguida à:

case CRICKET_CHECK:
  CMD_STATE = CRICKET_NAME;
  break;

Deveremos inserir nossa função:

case CMD_SCRATCH_DATA_REQUEST:
  int s;
  for(s=0;s<8;s++) makeScratchPacket(s);
  break;

Uma vez compilado o programa e gravando na placa, estaremos prontos para utilizá-la no Scratch, simulando a Picoboard.

Gogo Board como Scratch Board – VIII

Para acrescentarmos a nova funcionalidade ao firmware da Gogo Board, precisaremos declarar as funções utilizadas:

void makeScratchPacket(int NoCanal);
void sendScratchPacket(int NoCanal, long ValorSensor);

Dentro da primeira função, obteremos o valor analógico do sensor desejado e enviaremos à próxima função em conjunto com o número do sensor:

void makeScratchPacket(int NoCanal) {

set_adc_channel(NoCanal);
delay_us(channelSwitchDelay);
long ValorSensor;
ValorSensor=read_adc();
sendScratchPacket(NoCanal, ValorSensor);

}

GoGo Real: Firmware em HI-TECH

Abaixo temos um exemplo de firmware baseado no compilador HI-TEC C, em sua versão para a família pic18:


#include <htc.h>

void main()
{

TRISB = 0b00000011;
TRISA = 0b00101111;
TRISC = 0b00000000;
TRISD = 0b00000010;
TRISE = 0b00000111;

while (0){
RC2 = 1;
_delay(1000);
RC2 = 0;
_delay(1000);
}

}

Depois de compilado e gravado na placa, ela emitirá o sinal sonoro de beep.

GoGo Board: Firmware SDCC – VII

Neste exemplo de While, acenderemos todos os leds presentes na placa, bem como acionaremos o bip.

while(1) {
PORTAbits.RA4 = 1; //run
PORTDbits.RD0 = 1; //user
PORTCbits.RC0 = 1; //u2
PORTCbits.RC1 = 1; //u3
PORTCbits.RC2 = 1; //pz
}
}

Ate o momento a função Delay presente na biblioteca não tem funcionado corretamente, sendo assim, não incluimos uma etapa de desligamento dos leds e bip.

GoGo Board: Firmware SDCC – VI

No Main, conforme abaixo, definiremos os pinos utilizados e seu modo de operação, ou seja, entrada ou saída:

void main(void) {
TRISA = 0x2F; // 0b00101111
TRISB = 0x03; // 0b00000011
TRISC = 0x00; // 0b00000000
TRISD = 0x02; // 0b00000010
TRISE = 0x07; // 0b00000111

Será preciso atenção neste ponto, uma vez que o SDCC aceita apenas notação hexadecimal nos pinos.

GoGo Board: Firmware SDCC – V

Deveremos iniciar nosso código para ser compilado no SDCC, deste modo:

#define NO_BIT_DEFINES 1
#include "pic18f4550.h"
#include "pic18fregs.h"
#include <delay.h>

#define CLOCK_SPEED 48000000

Aonde definiremos qual PIC será utilizado, além de incluir algumas bibliotecas necessárias para a programação e compilação.

Feito isso, iremos para a escrita do Main e While em nosso programa.

GoGo Board: Firmware SDCC – IV

Para o Linux, deveremos utilizar:

sdcc --ivt-loc=0x1840 --use-non-free -mpic16 -p18f4550 main.c

O gplink será executado automaticamente e nosso programa será compilado.

Tudo aparenta estar correto, porém notamos algumas incompatibilidades no gplink para a compilação de cógicos.

Sendo assim, com base em tutoriais do Pinguino, o mais adequado foi utilizar apenas o SDCC, deste modo:

sdcc --ivt-loc=0x1840 -mpic16 -p18f4550 -c main.c
sdcc -mpic16 -p18f4550 --ivt-loc=0x1840 --no-crt main.o libc18f.lib libm18f.lib libio18f4550.lib -m -o main.hex

Finalmente nosso código poderá ser gravado na placa.

GoGo Board: Firmware SDCC – III

No Windows, após escrevermos nosso código em C utilizando o bloco de notas ou outro editor de texto, deveremos, através da linha de comando, utilizar:

sdcc --ivt-loc=0x1840 -mpic16 -p18f4550 -c main.c

A seguir:

gpasm -c main.asm

Por fim:

gplink -m -c main.o -o main.hex

Feito isso, já teremos um firmware pronto para ser gravado na placa, neste caso, uma GoGo Real.

GoGo Board: Firmware SDCC – II

Como já falamos anteriormente, para que um firmware seja compatível com o bootloader existente nas placas, devemos gravá-lo em uma posição expecífica de memória do PIC.

Na BR-GoGo, até o momento, este endereço é o 0x1560, para a GoGo Real, até o momento, é o 0x1840.

Para o SDCC, como já visto, deveremos alterar algumas bibliotecas, além de usar diretivas na compilação para que o código seja compilado de maneira correta, ou seja, iniciando a partir da posição de memória que desejamos.

GoGo Board: Firmware SDCC

Assim como fizemos utilizando outros compiladores, poderemos escrever nosso firmware e compilá-lo através do SDCC, tanto no Windows como no Linux.

Para Windows, devemos baixar o compilador através deste endereço, além disso, também precisaremos do GPutils, disponível aqui.

No Linux, mais expecíficamente no Raspbian, da Raspberry Pi, bastará utilizarmos “apt-get install sdcc” na linha de comando. O SDCC, bem como suas dependências: “gputils gputils-common gputils-doc sdcc-doc sdcc-libraries sdcc-ucsim”, serão instaladas.

BOOTLOADER EN SDCC – PIC18F4550

Para começar o primeiro artigo neste blog, vamos discutir o compilador de linguagem C para microcontroladores e como alterar o reset SDCC VETOR para uso com um bootloader para o PIC 18F4550.

A primeira coisa a fazer é mudar os vetores no. LKR de gputils, arquivo 18f4550.lkr.

No meu caso o bootloader armazenados no 0x00 endereço e 0xFFF, portanto, o vetor de reset será a 0x1000 posição e 0x1008 é interrupções.

Fonte e mais detalhes aqui.

pic18F4550 with Debian GNU/Linux and SDCC

Ontem, estava trabalhando com dispositivos pic 18F4550, gravados com bootloader da Microchip (PICDE). Descobri que no Linux há pouca documentação sobre programação para família pic 18f. Bem, eu finalmente programei meu pic sem um programador pic (usando o bootloader), todo o processo a partir de Debian GNU / Linux (usando sid).

Os programas que eu precisava (e as versões usadas por mim) são:

piklab (0.15.4-1)
gputils (0.13.7-1) e gputils-common (0.13.7-1)
sdcc (2.9.0-3)
e os picdemfs microchip bootloader (baixe aqui, hex para restaurar o pic para o estágio inicial)

Fonte e mais detalhes aqui.