Ao olharmos novamente a documentação sobre o protocolo serial, não poderemos nos esquecer sobre a utilização do sensor 15, que se trata do envio da versão de firmware utilizada pela Scratch Board (Picoboard), atualmente 4.
Na prática, antes de enviar os valores relativos aos 8 sensores, deveremos utilizar:
void sendScratchPacket(15, 4);
Enviando os outros valores normalmente à seguir.
Na recém lançada versão 223 do firmware, a B-GoGo passou a permitir a comunicação com o software Scratch, através do modo Gogo Board.
Este firmware poderá ser obtido aqui e a versão do Blocos compatível com esta e outras melhorias, poderá ser obtido aqui.
Podemos simular a Scratch Board apenas utilizando softwares para a simulação de uma porta serial, através do com0com e utilizando o Processing para enviar dados, assim como pode ser visto no PicoBoard Emulator.
println(0x80 + 0x38 + 0x1);
Através deste comando, poderemos formar o primeiro pacote de bytes que deverão ser convertidos e enviados à porta serial.
Podemos simular a Scratch Board apenas utilizando softwares para a simulação de uma porta serial, através do com0com e utilizando o Labview para enviar dados, assim como pode ser visto no PicoBoard Emulator.
Acima temos uma forma de compor o pacote de bytes que deverão ser enviados à porta serial, após serem convertidos para o formato hexadecimal, já que o componente VISA Write, não reconhece outro tipo de dados.
Podemos simular a Scratch Board apenas utilizando softwares para a simulação de uma porta serial, através do com0com e utilizando o Visual Basic para enviar dados, assim como pode ser visto no PicoBoard Emulator.
Para gerar o primeiro pacote de bytes, neste caso poderemos utilizar as duas alternativas abaixo:
Label1.Text = (&H80 + &H38 + &H1)
Label2.Text = (10000000 + 111000 + 1)
Ao olharmos o valor &H38, poderemos ficar confusos, no entanto se trata da conversão do valor binário 111, relativo ao valor 7, rotacionado três casas à esquerda.
Agora, depois da formatação dos bytes, deveremos enviá-los à porta serial no formato caracteres, ou seja Chr().
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);
}
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.
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);
}
Conforme verificamos na documentação do protocolo, a placa deverá enviar os valores dos sensores em sequência somente quando o Scratch enviar 0x01 (hexadecimal), do contrário, nada deve ser enviado.
Sendo assim, praticamente toda programação do firmware original da Gogo Board poderá ser mantido e apenas acrescentaremos esta nova função.
Foto: http://lh3.ggpht.com/
Na imagem acima temos a ordem dos sensores e seus respectivos valores que deverão ser utilizados na programação.
Foto: http://www.instructables.com/id/Scratching-with-Arduino/?lang=pt
Para o segundo pacote de dados, deveremos, formatar novamente o valor de sensor para 10 bits:
(ValorSensor & 0b1111111111)
E por fim, utilizar apenas os 7 bits menos significativos:
((ValorSensor & 0b1111111111) & 0x7F))
Feito isso, ao enviarmos estes bytes ao Scratch, ele deverá alterar o valor do sensor 7, de 0 para 234, ou simplesmente 23, já que o valor original do sensor é arrendodado e vai de uma escala de 0 à 100.
Vamos à analise do código anterior.
(NoCanal & 0b1111)
Será responsável por formatar o número relativo ao sensor (exemplo 7) para em 4 bits.
Deveremos alterar o número em três casas à esquerda:
((NoCanal & 0b1111) << 3)
Em seguida:
(ValorSensor & 0b1111111111)
Formataremos o valor do sensor para 10 bits e extrairemos os 3 bits mais significativos:
((ValorSensor & 0b1111111111) >> 7)
Agora formatamos o resultado para 3 bits:
(((ValorSensor & 0b1111111111) >> 7) & 0b111)
Por fim, somaremos o resultado à “0b10000000”, formando o primeiro pacote de dados.
Utilizando o compilador CCS, por exemplo, deveremos escrever nosso código desta forma:
printf(usb_cdc_putc,"%c", (0b10000000 | ((NoCanal & 0b1111) << 3) | (((ValorSensor & 0b1111111111) >> 7) & 0b111)));
printf(usb_cdc_putc,"%c", ((ValorSensor & 0b1111111111) & 0x7F));
E ainda, entre o envio de cada grupo de bytes, será necessário incluir um tempo mínimo de espera:
delay_us(400);
Assim, formaremos os pacotes de bytes a serem enviados.
Em resumo, o envio de dados se dará da seguinte forma:
Byte1: <1><numero sensor (formado por 4 bits)><valor sensor (formado pelos 3 bits mais significativos)>
Byte2: <0><valor sensor (formado pelos 7 bits menos significativos)>
Na prática, supondo que enviaremos o valor 234 presente no sensor 7, teremos:
Byte1: <01><0b0111><001>
Byte2: <00><1101010>
Desta forma, teremos os bytes que deverão ser enviados. Um detalhe é que o valor do sensor deve conter 10 bits, ou seja 0b0011101010 e não apenas 8.
A Gogo Board, naturalmente se conecta ao Scratch, podendo enviar os valores de seus sensores à ele, como visto aqui.
A título de curiosidade, podemos modificar o firmware original para que a placa também possa emular a Scratch Sensor Board, ou mais conhecida atualmente como PicoBoard, assim como já fizemos com Arduino e com a Raspberry.
Inicialmente, precisaremos entender o protocolo serial do Scratch, através deste documento.
Mundo da Robótica 