The CCSC2SDCC Migration Guide

This chapter summarises and explains how to migrate code written for the CCS compiler to code for the SDCC. (16bit targets)

Contents

Comparison of the two compilers
Feature matrix
Language differences
Tools for your convenience
Resources
convert.pl
ren_ident
enum-o-matic
convert.sh
How to use
Required manual work
Compatibility files
compat.h
compat_defs.h
stdint.h
delay.c
disptab.c
initprio.c
compat_i2c.c, software_i2c.c, software_i2c.h
Example
General hints
Links

Fonte e mais detalhes aqui.

Voltmeter Using RTOS and PIC18F4550

As the name suggest, this project is a simple Voltmeter which can measure Voltage from Range 0-5V and this can be increased, but to make things simple we are going only for a smaller range i.e 0 to 5V.

The specialty of this project is that it used the RTOS for exact timing operations.

Here is the Circuit Diagram

Fonte e mais detalhes aqui.

GoGo Board: I2C Slave – V

Como vimos anteriormente, a leitura de dados I2C, utilizando o compilador CCS, desverá ser desta forma:

long data;
data = i2c_read();
data = i2c_read();
data = i2c_read();
data = i2c_read(0); // Do a NACK on the last byte read


O fato esta na forma como a placa principal envia os dados, dividindo-o em três partes, ou seja, o endereço da placa slave, os bits mais significativos de nossa informação e os bits menos significativos. O último comando de leitura será para informar a placa master que os dados foram recebidos com sucesso.

Se tudo estiver correto, deveremos ver o valor do sensor no display, porém, em uma escala de 0 à 254, diferentemente da escala que estamos habituados de 0 à 1023. Bastará uma pequena conversão.

GoGo Board: I2C Slave – III

Modificando um pouco o firmware original da placa, poderemos conectar um display LCD, além de permitir a recepção de dados através do protocolo I2C, como segue abaixo.

gogo40

lcd4bccs

Várias funções foram removidas, a título desta explicação, pois o foco maior será na decodificação e exibição no LCD e porta Serial, dos dados recebidos da placa principal.

GoGo Board: I2C Slave – II

Uma vez gravado o programa na placa principal, bastará conectarmos outra placa, através dos conectores I2C e prepararmos a programação e C para esta placa, neste caso, utilizando o compilador CCS.

Br-Gogo: Comunicação Serial/Bluetooth

Este é o circuito beta para comunicação serial e bluetooth na Br-Gogo.

Foi utilizado o adaptador Naxos e programação através do compilador CCS.

Um grande detalhe a ser considerado é quanto a velocidade de comunicação utilizada pelo PIC. Embora o adaptador utilize velocidade de 19200 bps, devemos configurar em nosso firmware a velocidade de 9600 bps.

Foto: http://fritzing.org/

Br-Gogo: Comunicação Serial – IV

Mantendo o circuito anterior, porém, novamente alterando os pinos utilizados para comunicação serial, poderemos utilizar os pinos 5 e 7 do PIC, sem os respectivos resistores de pull-up, de maneira que a conexão à placa fique mais fácil e prática.

Através do compilador CCS, devemos usar a sintaxe:

#use RS232 (Baud=19200, xmit = PIN_A3, rcv = PIN_A5)

Deste modo, as entradas destinadas aos sensores 4 e 5, em nosso firmware, passarão ser utilizadas na comunicação serial.

Br-Gogo: Comunicação Serial – II

Utilizando o compilador CCS e aproveitando dois pinos atualmente desabilitados na placa, mesmo com a existência de leds nos mesmos, podemos alterar os pinos padrão utilizados para a comunicação serial desta forma:

De:

#use RS232 (Baud=19200, xmit = PIN_C6, rcv = PIN_C7)

Para:

#use RS232 (Baud=19200, xmit = PIN_C0, rcv = PIN_C1)

Assim, os leds não precisarão ser retirados e agora passarão a indicar o envio e recebimento de dados pela porta serial.

BR-Gogo + Ccs: Beep – Final

A explicação do código publicado anteriormente é a seguinte:

Criamos uma rotina chamada beep, de modo que sempre posssamos chama-la quando precisarmos, ao trabalharmos com maior volume de códigos nas programação. A rotina main, é a rotina principal de nosso programa e a while é para que a placa não se “perca” na execução do nosso programa, neste caso executando o bip, apenas uma vez.

Como já vimos, o pwm é um recurso muito poderoso, para os mais diversos fins, basta conhecimento e criatividade para utiliza-lo.

Foto: http://upload.wikimedia.org/

BR-Gogo + Ccs: Beep – IV

O código final deverá ser parecido com este:

#include "bootloader.h"
#case
#include

void beep();

void beep() {
set_pwm1_duty(50);
output_high(PIEZO);
delay_ms(50);
set_pwm1_duty(0);
output_low(PIEZO);
}

void main() {

beep();

while (1) {
}
}

Ao compila-lo, bastará grava-lo na placa, utilizando o Firmware Downloader.

BR-Gogo + Ccs: Beep – III

O bip ou piezo, esta conectado ao PIC no pino C2, para aciona-lo, usamos as seguintes instruções:

set_pwm1_duty(50);
output_high(PIEZO);
delay_ms(50);
set_pwm1_duty(0);
output_low(PIEZO);

Traduzindo, configuramos o pwm com 50% da potência, ativamos o pino do bip, aguardamos 50 milisegundos, configuramos o pwm em 0 e desativamos o pino do bip.

Com isso, teremos a emissão do bip quando a placa for alimentada.

Foto: http://www.cinestec.com.br/ecommerce22/

BR-Gogo + Ccs: Beep – II

Com as linhas inseridas inicialmente em nosso firmware, configuramos todas entradas e saídas da placa, agora poderemos acionar, neste exemplo, o bip (piezo).

Observando o firmware original, vimos que existe a função beep:

void beep() {
set_pwm1_duty(50);
delay_ms(50);
set_pwm1_duty(0);
}

No entanto, assim como é feito ao acionarmos os leds, além de controlar o pwm, devemos colocar o pino em que o bip esta conectado em nível alto, para emissão do sinal sonoro e na sequência, em nível baixo, inibindo a emissão de som, o que será feito no próximo passo.

BR-Gogo + Ccs: Beep

Como o firmware original foi escrito com base no compilador Ccs, o trabalho de desenvolvimento de um novo firmware se torna um pouco mais fácil.

Para começar, no início do nosso programa, incluimos as seguintes linhas:

#include "bootloader.h"
#case
#include

Estas linhas serão responsáveis pela correta geração do código compilado, de forma a ser compatível com o bootloader presente na placa.

O próximo passo, será a escrita do firmaware propriamente dito.

Gogo Board Musical

Assim como fizemos com o Arduino, é possivel utilizar um piezo para emitir notas musicais, neste caso, utilizando o bip da própria placa e controlando-o através do PWM.

Este é um exemplo de utilização, construído com o Pic 18f4520, que podemos adaptar para à Gogo Board.

Podemos aproveitar o código disponível e apenas altera-lo para que seja compatível com o bootloader já existente na placa.

Para isso, acrescentamos ao início do código:

#include "bootloader.h"
#case


E comentamos as linhas:

//#include
//#fuses HS,NOLVP,NOWDT,NOPROTECT
//#use delay(clock=40000000)


Depois de gravar este firmware, escrito para o compilador Ccs, a placa irá emitir as notas musicais programadas.

O exemplo é simples, porém demonstra uma das funcionalidades e aplicações do PWM.

Foto: http://hades.mech.northwestern.edu/

Colaboração: Lucas Tanure

PIC18f4550: I2C + ADC

Como vimos anteriormente, somente podemos habilitar as entradas analógicas necessárias em nosso projeto.

Tomando como exemplo a Gogo Board, que utiliza oito entradas para os sensores, sendo elas de AN0 à AN7, temos que configura-las corretamente.

Para o compilador CCS usamos:

#define AN0_TO_AN7 0x07
setup_adc_ports(AN0_TO_AN7_ANALOG);


Ou ainda:

setup_adc_ports(0x07_ANALOG);

Para o compilador C18, devemos utilizar:

OpenADC(...,...,ADC_8ANA)

Verifique sempre o datasheet do microcontrolador e do respectivo compilador.