TUTORIAL: Projeto PicUSB quase pronto PIC<-->RF<-->PIC<-->USB<-->PC

[MatheusLPS]

Projeto PicUSB: PIC<-->RF<-->PIC<-->USB<-->PC

by MatheusLPS

Olá galera do fórum! td bem com vocês? Então, tenho boas notícias para quem curte um microcontrolador e não sabe ligá-lo no PC através da USB. Os problemas acabaram!

Atenção:

Esse projeto não é direcionado àqueles totalmente novos ao mundo dos microcontroladores. è necessário um certo grau de conhecimento para poder passar por cima dos problemas que podem ocorrer. E lembrem-se: "O tio GOOGLE está aí para sanar a maioria das dúvidas!"

Então, estou desenvolvendo um trabalho para a faculdade onde preciso utilizar algum microcontrolador e ligá-lo de alguma forma ao computador para ver informações. Este pré-projeto tem o intuito de apresentar o conceito de como se fazer a troca de dados entre um microcontrolador e um computador via USB.

Especificação do componente utilizado (USB)

Atualmente portas do tipo RS232, serial e outras não são mais utilizadas, por serem consideradas ultrapassadas. O protocolo USB ganha vantagem no que diz respeito a velocidade de transferência de informação bem como a facilidade de ligação ao sistema, embora essa última característica seja um tanto complexa no que diz respeito ao software de controle. Grande parte desse trabalho consiste em fazer o PC reconhecer um dispositivo USB válido.

Metodologia

A princípio, teve-se a ideia de utilizar a porta paralela do computador para fazer a comunicação com o PIC, no entanto, considerando-se que um notebook não possui tal conexão decidiu-se analisar outras alternativas. Diante de tal limitação lançou-se mão dos componentes USB e microcontroladores para sanar o problema.

Utilizou-se como recurso metodológico o livro texto USB Complete Third edition, Everything You Need to Develop Custom USB Peripherals escrito por Jan Axelson. Percebe-se que o livro é a bíblia para quem quiser começar a usar USB, contém vários exemplos e códigos fontes.

Infelizmente esse não é o caso, mesmo querendo fazer algo novo, não quero reinventar a roda. O protocolo USB já existe faz um tempo, só quero saber como é feito, algo mais superficial. E o livro aborda assunto que decidimos não buscar.

a partir da proposta inicial, fez-se uma pesquisa intensa para encontrar o material que unisse os elementos PIC, USB e Compilador CCS que é o que já vem sendo utilizado. Infelizmente, o material sobre o assunto é escasso, ainda mais de um tema tão específico. Por sorte foi encontrado na internet um fórum que auxiliou na determinação do tipo de PIC à utilizar.

Foi com muito custo que encontrei um fórum gringo, em espanhol, que me ajudou bastante:

Projeto PicUSB por J1M

Esse carinha aí fez um protocolo em 2005 que me ajudou muito a compreender como um simples PIC pode ser interfeiceado ao PC.

Ele colocou à disposição de todos seus arquivos com código fonte para que todas as pessoas pudessem tirar proveito. Foi com esse intuito que resolvi postar minha experiência para que outros não tenham tanta dificuldade como eu tive em realizar o projeto. Desde a ideia até a fase que estou, foram 2 meses de pesquisa.

Diagrama de blocos do Projeto Inicial

O diagrama pode ser visto na imagem abaixo:

Como podem ver acima, o intuito do projeto é controlar um carrinho, através do computador, construido com 2 servo-motores . Esse carrinho pode nos enviar diversas informações como por exemplo: temperatura onde se encontra, umidade relativa do ar e etc.

Nesse 1º post darei apenas uma ideia do projeto, mais para frente, irei dar informações mais detalhadas acerca da contrução tanto do hardware quanto do software que foi a parte mais complicada.

Ferramentas Necessárias

Nessa parte citarei os programas necessários para que o projeto seja executado.

Microsoft Visual C# 2010 Express: O autor do exemplo utilizou o 2005 Express, no entanto, para que todas as funções que adicionei funcionem, é necessário o 2010 Express. É gratuito!

Pic C Compiler: É da CCS. Utilizei esse pois já estou acostumado e a bibliografia encontrada também usava ele. NÃO SEI USAR OUTROS COMPILADORES!

ISIS Proteus: Para testarmos o nosso projeto, precisamos de um simulador. E esse eu recomendo.

Sistema Operacional de 32bits: Os drivers USB do Proteus não funcionam em sistemas 64bits. E os drivers USB do PIC também não. Eu uso o windows 7 64 bits e não queria instalar outro SO apenas para testar os circuitos. Então abri mão do recurso de uma máquina virtual. Instalei o XP SP3 e o Windows 7 32Bits nela e os circuitos funcionaram tranquilamente.

Como Funciona

A princípio temos um PIC conectado ao computador e alguns leds ligados ao microcontrolador a fim de testes.

O circuito do PIC é o seguinte:

Percebe-se que a parte de hardware está tranquila, são poucos componentes.

Temos o PIC da esquerda que está ligado ao PC via USB, o PIC da direita é o PIC que estará no carrinho. Percebam que eles estão ligados apenas po 1 fio, simulando uma conexão RF via RS232. O LCD está apenas como debugador para certificar que a informação está chegando.

Temos que ligá-lo no PC e ele deve ser reconhecido como um dispositivo USB:

Na foto acima, iniciei os testes com um 18F2550. Agora estou com um 18f4550 e funciona também!

Agora é necessário criar um software voltado a objeto que controle o nosso PIC. Isso é feito no Microsoft visual C# 2010 Express.

Como teste, fiz um programa baseado no feito pelo J1M, autor original da estrutura. Esse programa acende/apaga leds vermelhos, azuis, lê a temperatura através de um LM35 e mostra em um gráfico. Ahhh, deixei no programa do windows uma função que recebe 2 números inteiros, envia ao PIC e o PIC soma e retorna o resultado q é mostrado na tela.

Screenshot do Sofware:

Na imagem acima, é a screenshot do sistema funcionando no Windows XP instalado numa máquina virtual. No windows 7 funcionou também !

Por enquanto não postarei os códigos fontes dos programas para que não fique muito sobrecarregado o post.

Conclusão

Essa é a parte teórica, escomendei os PICs para poder testar de verdade. Tudo leva a crer que não terei problemas.

Nos próximos dias coloco atualizações de como anda o projeto.

Falou

[MatheusLPS]

Ei pessoal, finalmente terminei meu projeto e já posso passar adiante todo o conhecimento que adquiri. Vamos lá então.

OBS: Esse projeto utiliza a porta USB de forma plena, sem emulação de uma porta COM.

1º Passo: Download dos arquivos fontes, tanto dos dois PICs quanto do aplicativo que faz o controle mais arquivos necessários:

Trabalho_Final

Antes de mais nada, precisamos de um PIC com suporte nativo a USB. Para esse projeto escolhi o 18F4550 pois possui 40 pinos, que é mais do que suficiente, boa memória e suporte a USB.

Para esse projeto, tenho esse diagrama de blocos:

O circuito é o mais simples de todos, não tem mistério. Segue abaixo:

Veja que temos 1 PIC conectado a USB, seu cristal de 12Mhz, os capacitores de 15pF no cristal, um capacitor de 47uF no pino 18 (VUSB), 1 resistor no MCLR, 1 led vermelho para indicar que o PIC está rodando mas não foi reconhecido como um dispositivo válido no computador, 1 led verde para quando instalarmos o driver, ele acende indicando que o dispositivo foi enumerado pelo windows e um sensor de temperatura LM35.

A parte do 2º PIC explico depois.

Para que o PIC seja reconhecido pelo windows devemos programá-lo com o seguinte código escrito no CCS. Observe que não fiz o código, usei um que encontrei no fórum www.todopic.com.ar e modifiquei a minha necessidade. O dono do código o fez de modo aberto. Por isso os comentários estão em espanhol.

//// PicUSB.c ////
//// ////
//// Este ejemplo muestra como desarrollar un sencillo dispositivo ////
//// USB con el PIC18F2550, aunque puede ser facilmente adaptado ////
//// para la serie 18Fxx5x. Se suministra el PicUSB.exe, así como ////
//// su código fuente para Visual C# 2005, podréis encontrar tb ////
//// los drivers para el dispositivo. No se suministra esquema de ////
//// conexión puesto que está pensado para ser usado en el GTP USB, ////
//// cualquiera de las tres versiones disponibles, si aun no teneis ////
//// el programador, podeis utilizar el esquema de esse proyecto. ////
//// ////
//// Cuando el dispositivo sea conectado al PC, saldrá el asistente ////
//// para la instalación del driver. Instala el suministrado junto ////
//// a este ejemplo, lo encontrareis dentro de la carpeta Driver. ////
//// Una vez instalado podreis usar el PicUSB.exe para encender o ////
//// apagar el led bicolor del GTP USB, y para realizar la suma de ////
//// dos números introducidos. ////
//// ////
//// Realizado con el compilador CCS PCWH 3.227 ////
//// ////
//// Por: Jaime Fernández-Caro Belmonte [email protected] ////
//// ////
//// http://www.hobbypic.com ////
/////////////////////////////////////////////////////////////////////////
#include <18F4550.h>
#device adc=10
#define WireTX PIN_C6 // <--------- C 6
#define WireRX PIN_C7
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL3,CPUDIV1,VREGEN
#use delay(clock=48000000)
#use rs232(baud=9600,xmit=WireTX , rcv=WireRX ,ERRORS , STREAM=Wireless )

/////////////////////////////////////////////////////////////////////////////
//
// CCS Library dynamic defines. For dynamic configuration of the CCS Library
// for your application several defines need to be made. See the comments
// at usb.h for more information
//
/////////////////////////////////////////////////////////////////////////////
#define USB_HID_DEVICE FALSE //deshabilitamos el uso de las directivas HID
#define USB_EP1_TX_ENABLE USB_ENABLE_BULK //turn on EP1(EndPoint1) for IN bulk/interrupt transfers
#define USB_EP1_RX_ENABLE USB_ENABLE_BULK //turn on EP1(EndPoint1) for OUT bulk/interrupt transfers
#define USB_EP1_TX_SIZE 4 //size to allocate for the tx endpoint 1 buffer
#define USB_EP1_RX_SIZE 8 //size to allocate for the rx endpoint 1 buffer


/////////////////////////////////////////////////////////////////////////////
//
// If you are using a USB connection sense pin, define it here. If you are
// not using connection sense, comment out this line. Without connection
// sense you will not know if the device gets disconnected.
// (connection sense should look like this:
// 100k
// VBUS-----+----/\/\/\/\/\----- (I/O PIN ON PIC)
// |
// +----/\/\/\/\/\-----GND
// 100k
// (where VBUS is pin1 of the USB connector)
//
/////////////////////////////////////////////////////////////////////////////
//#define USB_CON_SENSE_PIN PIN_B2 //CCS 18F4550 development kit has optional conection sense pin

/////////////////////////////////////////////////////////////////////////////
//
// Include the CCS USB Libraries. See the comments at the top of these
// files for more information
//
/////////////////////////////////////////////////////////////////////////////
#include <pic18_usb.h> //Microchip PIC18Fxx5x Hardware layer for CCS's PIC USB driver
#include <PicUSB.h> //Configuración del USB y los descriptores para este dispositivo
#include <usb.c> //handles usb setup tokens and get descriptor reports


/////////////////////////////////////////////////////////////////////////////
//
// Al conectar el PicUSB al PC encendemos el Led Rojo hasta que el dispositivo
// halla sido configurado por el PC, en esse momento encederemos el Led Verde.
// Esperaremos hasta que se reciba un paquete proveniente del PC. Comprobaremos
// el primer byte del paquete recibido para comprobar si queremos entrar en el
// modo Suma, donde se realizará una suma de dos operandos, que corresponderan
// con los dos bytes restantes del paquete recibido; una vez realizada la suma
// enviaremos el paquete con el resultado de vuelta al PC. Si entramos en el
// modo Led comprobaremos el segundo byte del paquete recibido para comprobar
// si deberemos apagar los leds, encender el verder o el rojo.
//
/////////////////////////////////////////////////////////////////////////////

#define LED_OK PIN_B6
#define LED_FAIL PIN_B7
#define LED_ON output_high
#define LED_OFF output_low

int periodo;
int ciclo1=0;
int ciclo2=0;
int ciclo3=0;

#define modo recibe[0]
#define param1 recibe[1]
#define param2 recibe[2]
#define param3 recibe[3]
#define param4 recibe[4]
#define resultado envia[0]
#define barra send[0]
#define status send2[0]

/*=====================
A interrupção:
=======================*/

#int_timer1
void TIMER1_isr (void)
{
set_timer1(65480); //Preload do timer1

/*=====================
Testes para ciclo = 0:
=======================*/

if (ciclo1 == 0)
{
output_low (PIN_B0);
}
if (ciclo2 == 0)
{
output_low (PIN_B1);
}
if (ciclo3 == 0)
{
output_low (PIN_B2);
}

/*==============================
Já que o ciclo é diferente de 0:
================================*/
if (periodo <255)
{
If (periodo < ciclo1)
{
output_high (PIN_B0);
}
else
{
output_low (PIN_B0);
}


If (periodo < ciclo2)
{
output_high (PIN_B1);
}
else
{
output_low (PIN_B1);
}

If (periodo < ciclo3)
{
output_high (PIN_B2);
}
else
{
output_low (PIN_B2);
}

}
else if (periodo == 255)
{
output_high (PIN_B0);
output_high (PIN_B1);
output_high (PIN_B2);
periodo=0;
}
periodo++;
}

void main(void) {

int8 recibe[5]; //declaramos variables
int8 envia[2];
int8 send[1];
int8 send2[1];
int16 adc=0;

LED_OFF(LED_OK); //encendemos led rojo
LED_ON(LED_FAIL);

usb_init(); //inicializamos el USB

setup_adc_ports(AN0); //Configura canais analógico
setup_adc(ADC_CLOCK_INTERNAL); //De acordo com relógio interno.

/*SETUP_TIMER_1 (T1_INTERNAL|T1_DIV_BY_2); //Configurar timer1 para clock iterno/8
enable_interrupts (INT_TIMER1); //Habilitar Interrupções
enable_interrupts (global);*/

usb_task(); //habilita periferico usb e interrupciones
usb_wait_for_enumeration(); //esperamos hasta que el PicUSB sea configurado por el host

/*SETUP_TIMER_1 (T1_INTERNAL|T1_DIV_BY_2); //Configurar timer1 para clock iterno/8
enable_interrupts (INT_TIMER1); //Habilitar Interrupções
enable_interrupts (global);*/

LED_OFF(LED_FAIL);
LED_ON(LED_OK); //encendemos led verde

while (TRUE)
{
if(usb_enumerated()) //si el PicUSB está configurado
{
if (usb_kbhit(1)) //si el endpoint de salida contiene datos del host
{

usb_get_packet(1, recibe, 5); //cojemos el paquete de tamaño 3bytes del EP1 y almacenamos en recibe

if (modo == 0) // Modo_Suma
{
resultado = param1 + param2; //hacemos la suma
usb_put_packet(1, envia, 2, USB_DTS_TOGGLE); //enviamos el paquete de tamaño 1byte del EP1 al PC
}

if (modo == 1) // Modo_Carro
{
if (param1 == 0)
{
fputc('U',Wireless);
delay_ms(20);

}

if (param1 == 1)
{
fputc('R',Wireless);
delay_ms(20);

}

if (param1 == 2)
{
fputc('D',Wireless);
delay_ms(20);

}

if (param1 == 3)
{
fputc('L',Wireless);
delay_ms(20);
}

if (param1 == 4)
{
fputc ('S',Wireless);
}
}

if (modo == 2) // Envio da Temperatura
{
set_adc_channel(0); //Habilitación canal0
delay_us(20);
adc = read_adc();
barra=((5*adc*100)/1024);
usb_put_packet(1, send, 1, USB_DTS_TOGGLE); //enviamos el paquete de tamaño 1byte del EP1 al PC
}
if (modo == 3) //Modo PWM
{
if (param1 == 1) //pwm ativado
{
ciclo1=param2;
ciclo2=param3;
ciclo3=param4;
}
}

if (modo == 4)
{
status=1;
usb_put_packet(1, send2, 1, USB_DTS_TOGGLE); //enviamos el paquete de tamaño 1byte del EP1 al PC
}

}
}
}
}

/////////////////////////////////////////////////////////////////////////

Para quem já programa no CCS, conseguirá compreender o código de boa pois não tem muito mistério.

Mas vou explicar um pouco:

Primeiro é declarada todas as informações da conexão a USB, as variáveis e por fim o código começa.

Nesse meu código que foi adaptado, o objetivo é receber comandos do computador e transmití-los pela RS232 ao outro PIC para que ele controle um L293 que é uma ponte H dupla. Sei que o segundo PIC está superdimensionado para essa tarefa, mas já que tinha um aqui sobrando, usei ele mesmo.

No título do tópico diz que utilizo módulos RF, sim, tentei mas deu uns problemas e deixei para fazer com o RF no próximo semestre, já que era apenas um adicional. Com apenas 1 fio nos pinos TX e RX, funcionou tranquilo.

Além dessa tarefa principal, o 1º PIC que está no USB, recebe a cada 1s um pedido de envio ao PC o valor da temperatura ambiente que é adquirida através do LM35.

Há também uma rotina de 3 canais PWM por software, no entanto quando ela é ativada, o PIC perde a conexão com a USB. Essa parte ficou para ser desenvolvida no próximo semestre na faculdade também. Os 3 canais funcionam, mas a USB vai embora.

Depois que você programa o PIC e conecta na USB, é apresentada a janela de instalação do driver. Veja que no windows 64bits o driver não funciona. No windows 7 32 bits, o projeto funcionou durante um tempo, depois parou e não descobri porque. Só funcionou de forma plena no windows XP.

Driver instalado, o PIC é reconhecido e enumerado como um dispositivo de USB válido.

Para enviar informações e receber dados, precisamos de um aplicativo. O meu foi escrito no Microsoft Visual Studio C#. vocês encontram os arquivos necessários no link lá de cima. Veja uma SS do aplicativo:

Para que ele funcione, é necessário a instalação do Net Framework 4.0. Podem encontrar no site da microsoft.

Podem conferir o video do projeto em funcionamento:

Por enquanto é isso. Isso aqui não é bem um tutorial passo-a-passo. Apenas as informações que vocês precisam e não encontram por aí em português.

Adiciono mais coisas mais para frente.

[MatheusLPS]

Reservado para o Projeto parte 3.

[aphawk]

MatheusLPS,

Excelente a sua iniciativa, parabéns !!!!

Estou no aguardo do restante do projeto !

Paulo

[Sink00]

Opa beem legal a sua iniciativa. A primeira vez que eu tentei usar o USB do pic eu apanhei bastante ate conseguir hahaha... seria bom ter um tutorial pronto. você sabe que tipo de conexao usb voce esta usando? HID, Bulk ....

A aproveitando a iniciativa, apenas para referencia de quem precisar aqui tambem estão alguns sites que so muito bons para entender o USB e como fazer para conectar um PIC ao USB:

Esse primeiro link é um projeto implementando o PIC18F2550 com conexao USB para ler e controlar portas do PIC. Ele é feito em CCS e o Host no Computador é VB6. Tem schematic, HEX, arquivo dos codigos, e o programa em VB6.

LINK1

O segundo e provavelmente o mais famoso, é um site com muita informaçao sobre como criar um dispositivo HID usando PIC entre outros.

LINK2

Esse terceiro é um site que descreve muuiiittoo bem o protocolo USB

LINK3

Para finalizar o link para a Microchip Application Libraries, que seria um conjunto de bibliotecas e exemplos da Microchip para serem utilizados com os seus compiladores gratuitos. Nela estão incluidos diversos emplos de implementeção do USB (todos os tipos). Para quem não gosta do compilador deles a biblioteca tambem traz codigos de aplicaçoes para o HOST do computador (C++, C#...), drivers, e documentação.

LINK4

Mais uma vez,otima iniciativa!!!

[test man*~]

Opa beem legal a sua iniciativa. A primeira vez que eu tentei usar o USB do pic eu apanhei bastante ate conseguir hahaha...

HEhHEhehEhE, eu apanhei bastante e não aprendi... ¬¬"

Muito bom Matheus, também estou aguardando o restante do projeto!

[MatheusLPS]

Obrigado gente!

@Sink00: Ótimos links, com isso vamos enriquecendo o tópico!

Você sabe que tipo de conexao usb voce esta usando? HID, Bulk ....

É bulk. Pois:

Dispositivos HID tem uma velocidade máxima de 64Kb/s (or 512 KB/s) em cada direção. Parece muito, hun? Nem tanto. Imagine contruir um scanner USB ou um dispositivo de aquisição de imagens. Uma simples imagem pode ter alguns megas, então levará alguns minutos ou horas para ser transferida. Mas a USB era para ser de alta velocidade, certo? Solução:Transferência Bulk. Ela utiliza a velocidade máxima da USB. Podemos ter velocidades de até 12MB/s em alguns dispositivos como o 18F4550 ou 480MB/s em outros dispositivos.

Pois é... no início apanhei também.. mas com calma vamos chegando lá. Cada dia aprendo coisas novas. No presente momento estou estudando mais a parte do aplicativo em C#. A parte do PIC em si tá mais tranquila...

O Microsoft Visual C# é fantástico.... está praticamente tudo pronto nele. O problema q sou totalmente novo em C# e tem muitas coisas q podem ser configuradas no desenvolvedor aí dá p brincar bastante por lá. A grande vantagem q a prórpia microsoft disponibiliza alguns tutoriais básicos no MDSN. Tem me ajudado muito.

O único inconveniente q vi até agora é a parte de RF. Não consegui fazer a comunicação entre o 18F4550 q vai na USB e um 16F877A. Só usando 2 18F4550. O problema q ele custa 10 reais a mais q o 16f877A. Não é um absurdo.. mas quanto mais barato melhor.

Falou

[Dani piresk]

Só complementando aqui:

Eu já usei muito pic 18f2550 e 18f4550 usando conexão HID com o pc, e nunca tive problemas com sistemas operacionais 64 bits, eu não cheguei a ver o código do link, mas depois vou analisar.

Creio que ele possa não funcionar com o x64 pois talvez a forma do HID Descriptor que o cara criou não seja padronizada.

EDIT: Postei junto com o Matheus, hehe, bom, nesse caso que é bulk, aí sim eu concordo que os drivers tem de ser diferente pro x86 e pro x64..

EDIT2: Esse driver do cara, funciona no x64 sim..

Con la llegada de Windows Vista se nos acabó el poder jugar con nuestros PICs de la serie 18Fxx5x, que recordemos son los que llevan el USB 2.0. El driver proporcionado por Microchip y su mpusbapi.dll que tantas horas de diversión nos habían dado no son compatibles con este nuevo Sistema Operativo. Pero gracias a Microsoft y su WinUSB por fin podemos volver a enviar datos a la velocidad de la luz por USB! Y no solo en Windows Vista x64 y x86, sino también en Windows XP x64 y x86. Para mostrar el funcionamiento de este nuevo Driver he creado una aplicación llamada PicWinUSB que espero os sea útil.

Traduzido pelo google translate, kkk:

Com o advento do Windows Vista que correu o jogo de poder com a nossa série de PICs 18Fxx5x, lembramos são os únicos com o USB 2.0. O driver fornecido pela Microchip e sua mpusbapi.dll tantas horas de diversão que tínhamos dado não são compatíveis com este novo sistema operacional. Mas, graças à Microsoft e nós podemos finalmente WinUSB reenviar os dados na velocidade da luz por USB! E não apenas no Windows Vista x64 e x86, mas no Windows XP x64 e x86. Para mostrar como este novo driver eu criei uma aplicação chamada PicWinUSB eu espero que seja útil.

[Sink00]

Obrigado gente!

@Sink00: Ótimos links, com isso vamos enriquecendo o tópico!

É bulk. Pois:

Dispositivos HID tem uma velocidade máxima de 64Kb/s (or 512 KB/s) em cada direção. Parece muito, hun? Nem tanto. Imagine contruir um scanner USB ou um dispositivo de aquisição de imagens. Uma simples imagem pode ter alguns megas, então levará alguns minutos ou horas para ser transferida. Mas a USB era para ser de alta velocidade, certo? Solução:Transferência Bulk. Ela utiliza a velocidade máxima da USB. Podemos ter velocidades de até 12MB/s em alguns dispositivos como o 18F4550 ou 480MB/s em outros dispositivos.

Falou

Sim sim isso é verdade... porém a dificuldade de implementar ambas é a mesma (tendo o driver no caso do bulk claro). Mas se você quer chegar perto do limite da banda do USB, esquece o PIC18F2550. Ele não tem capacidade de processamento suficiente para isso. E lembre-se, bulk só é rápido se você mandar uma quantidade grande de dados em uma direção. Se você ficar alternando a direção do fluxo de dados a velocidade vai ficar restrita ao frame do USB (1ms).

Eu normalmente implemento meus aplicativos em C++ no computador, mas se eu puder ajudar em algo, estamos aqui hehe abs.

[MatheusLPS]

Eu normalmente implemento meus aplicativos em C++ no computador, mas se eu puder ajudar em algo, estamos aqui hehe abs.

Opa, claro q toda ajuda é bem vinda!

Ahh gente, outra coisa, esses dias estou meio ocupado com esse Projeto. Estou dando retoques finais.

Como eu disse ali em cima, que a programação em C# tava fácil pois o Visual c# tem tudo, me enganei. Não que seja difícil. Mas tudo deve ser programado. Tudo! Todas as caixas, todos os botões... são muitos detalhes. Mas tá saindo. Assim q terminar com e software, vou tomar um tempo para fazer um tutorial bacana pra cá.

Só para não passar em branco, umas screens de comoestá ficando o software:

Rodando no Windows 7 32bits numa Máquina Virtual criada com Sum VirtualBox:

O controle servirá para controlar um carrinho por RF.

Os 3 canais PWM por software de teste. Pensei q não daria certo:

Minha área de trabalho como fica quando estou desenvolvendo (uma bagunça):

As janelas não ficam assim! Só para tirar a screen

Falou

t+

[MatheusLPS]

Atualização:

Projeto feito:

Mais tarde posto como fiz..

EDIT: Informações adicionadas no post número 2.

Falou

[tcamarante]

Pessoal, estou começando a mexer com um PIC18F4550 e não estou conseguindo fazer o PC reconhece-lo como dispositivo USB, já tentei em vários PCs e todos deram mensagem de "O hardware não pode ser usado ...". Eu estou usando o compilador microC da microchip e encotrei um tutorial que explica bem como fazer usando esta ferramenta, mas nele fala que o windows reconhece automáticamente o PIC.O tutorial é:

http://www.cerne-tec.com.br/artigousbparte1.pdf

http://www.cerne-tec.com.br/artigousbparte2.pdf

Se puderem me dar uma ajuda...

Obrigado.

[shunt]

Encontrei um excelente material sobre CCS e USB ... em português.

O trabalho é desenvolvido por um grupo no yahoo.

Segue o link para o arquivo (278 pg):

http://www.scribd.com/101015Apostila-CPIC/d/39560007

Link para o grupo:

www.tinyurl.com/SanUSB.

Abraço.

[MatheusLPS]

tcamarante, se fosse com o CCs poderia te ajudar, com o MicroC não sei nadinha...

Boa shunt, gostei do material!

valeu

[Nanaba]

Fala Matheus, muito bom seu projeto.

Cara, sou de SJDR também, porém moro em BH e estou iniciando em eletronica e PIC, trabalho como analista de sistemas mas sem fui fascinado por eletronica, principalmente robotica, gostaria de saber se você tem algum contato, tipo msn ou gtalk?

valeu

Luciano Lima

msn: [email protected]

gtalk: [email protected]

site: www.lucianolima.com.br

[tcamarante]

Valeu Matheus

Parabéns pelo iniciativa e pelo projeto, vou continuar acompanhando.

Eu encontrei em outro tópico alguém com o mesmo problema

http://forum.clubedohardware.com.br/resolvido-lcd-usb/714734

vou tentar fazer aqui.

Obrigado.

[MatheusLPS]

Texto atualizado, vide post número 2!

Falou

[-X2-]

Muito bom !!, queria poder ser mais avançado pra conseguir fazer isso, ainda nem consegui fazer comunicação RS232 entre dois pic

alias, consegui, mas não do modo que quero, fiz no proteus os dois pics, e um deles tem um led, criei um programa pro primeiro que só envia o numero "3", dai o segundo tem um:

if (valor==3)
  output_bit(PIN_C0,1);

dai ele funciona, porém eu queria enviar um vetor de tamanho 12, só de numeros int, mas ele num quer funcionar...

mas deixa pra lá, está de parabéns você, vou continuar acompanhando

[RomuloPessoa]

Oi Matheus,

Parabens pelo seu projeto. Muito interessante.

Eu também estou fazendo uma aplicação com o Pic. Tentei utilizar o seu exemplo para ver se o PC reconheceria o Pai. Ele reconhece, mais marcou como dispositivi desconhecido. Você sabe o que pode ser isso?

Valeu

Rômulo

[MatheusLPS]

Bem, pode ser muitas coisas. Primeiro de tudo você verifica se os pinos D+ e D- não estão invertidos. Pode ser isso. Normalmente o pino verde da USB é o + e o branco é o menos. No meu caso veio azul (+) e amarelo (-).

Depois certifique-se que o pino 18 do 18F4550 está com um capacitor de 47uF eletrolítico.

Verifique os capacitores do cristal (15pF).

Falou

[RomuloPessoa]

Eu conferi as ligações e estão todas corretas. O PC chega a reconhecer o PIC, porém marca como dispositivo desconhecido. Eu vou nas opções avançadas de hardware, coloco para atualizar driver e seleciono o driver que você disponobilizou. Ai aparece a mensagem de que o driver não contem informações sobre o meu hardware. O que será que é isso?

Valeu

[MatheusLPS]

Qual o sistema operacional q você está usando?

Aqui só funcionou de forma plena no windows XP.

Falou

[RomuloPessoa]

o windows xp mesmo. Deixa eu te perguntar, quando eu crio um project wizard no PICC, eu apenas escolho o tipo do pic e nomeio. Tem algum configuração que eu tenha que fazer?

[MatheusLPS]

RomuloPessoa, nunca usei o PIC wizard. Prefiro configurar no braço mesmo.

Sempre crio um projeto em branco e vou adicionando configurações.

Se você quiser fazer esse projeto aqui. Tem os arquivos necessários no post #2.

Lembre de conferir as ligações e os capacitores que são essenciais.

Falou

[AlyssonMachado]

Parabens Matheus pelo projeto!

Sou de BH e "brinco" com PIC´s a algum tempo, porém comecei a mexer com USB tem pouco tempo. Primeira coisa que fiz foi estudar o protocolo (USB 2.0 Specification) daí comecei a entender melhor como tudo funciona!

Fiz uns programas recentemente baseado em códigos disponíveis na net ( todos para C#), e estudando a linguagem to começando a criar minhas próprias variações.

Achei um fonte bacana na NET pra HID ai dei umas modificadas e acrescentei um leitor de temperatura de um lm35 tb:

Achei muito bacana sua interface, Como faz pra colocar gráficos? tem algum material que possa disponibilizar?

meu email é [email protected]

Podemos trocar bastante informação, sou aficionado do uC´s hehe

falows