usb_init(); // Inicializo USB
usb_cdc_init(); // Inicializo como dispositivo serie virtual CDC
while(!usb_cdc_connected()) {} // Espero hasta la conexión USB
for(;;){
if (usb_enumerated()) { // Espero que el dispositivo sea reconocido como emulador serie CDC
if (usb_cdc_kbhit()){ // Compruebo si hay recepción USB
-------
-------
-------
}
}
}usb_init(); // Inicializo USB
usb_cdc_init(); // Inicializo como dispositivo serie virtual CDC
while(!usb_cdc_connected()) {} // Espero hasta la conexión USB
for(;;){
if (usb_cdc_kbhit()){ // Compruebo si hay recepción USB
}
}
Buenass!! he buscado muuucho un circuito como este y la verdad que esta muy bueno, quisiera saber si alguien lo hizo y funciona correctamente....y descargue de el link para bajar el proyecto que pusiste, pero no estan los valores de las resistencias ni de casi ningun componente en el esquema....
/************************************************************************
* RUTINA PROCESA *
************************************************************************/
void Procesa(){
Envia_Break();
Envia_Start();
indiceTX = 0;
while (indiceTX < 16){ // En este bucle se envían los 16 canales de datos
if (TXIF==1){
TXREG = TramaDMX[indiceTX];
while (TRMT == 0){}
indiceTX=indiceTX + 1;
}
}
while (indiceTX < 100){ // En este bucle se envían el resto de canales, forzados a 0.
if (TXIF==1){ // No es obligatorio enviar los 512 canales que dice el protocolo,
TXREG = 0x00; // nosotros solo utilizamos 16, sin embargo existe un tiempo mínimo entre
while (TRMT == 0){} // el comienzo de una trama y el comienzo de otraq ue hay que cumplir.
indiceTX=indiceTX + 1; // A efectos prácticos, se podrían enviar tramas de tan solo 24 canales (no menos),
} // con lo que se conseguiría un refresco mas rápido.
} // En nuestro caso enviaremos tramas de 100 canales para ir sobre seguro.
// De estos 100 canales, 16 tendrán datos válidos recibidos por USB y los restantes se fuerzan a 0.
delay_us(100);
}/************************************************************************
* RUTINA PROCESA *
************************************************************************/
void Procesa(){
Envia_Break();
Envia_Start();
indiceTX = 0;
while (indiceTX < 512){ // En este bucle se envían los 16 canales de datos
if (TXIF==1){
TXREG = TramaDMX[indiceTX];
while (TRMT == 0){}
indiceTX=indiceTX + 1;
}
}
//while (indiceTX < 100){ // En este bucle se envían el resto de canales, forzados a 0.
// if (TXIF==1){ // No es obligatorio enviar los 512 canales que dice el protocolo,
// TXREG = 0x00; // nosotros solo utilizamos 16, sin embargo existe un tiempo mínimo entre
// while (TRMT == 0){} // el comienzo de una trama y el comienzo de otraq ue hay que cumplir.
// indiceTX=indiceTX + 1; // A efectos prácticos, se podrían enviar tramas de tan solo 24 canales (no menos),
// } // con lo que se conseguiría un refresco mas rápido.
//} // En nuestro caso enviaremos tramas de 100 canales para ir sobre seguro.
// // De estos 100 canales, 16 tendrán datos válidos recibidos por USB y los restantes se fuerzan a 0.
delay_us(100);
} /************************************************************************
* RUTINA DE INCIALIZACIÓN *
************************************************************************/
void Inicia(){
// Inicia variables.
for (aux=0;aux<16;aux++){
TramaDMX[aux]= 0x00;Executing: "C:\Archivos de programa\PICC\Ccsc.exe" +FH "Interface_usb-dmx2.c" #__DEBUG=1 +ICD +DF +LN +T +A +M +Z +Y=9 +EA #__18F2550=TRUE
>>> Warning 203 "C:\Archivos de programa\PICC\drivers\pic18_usb.c" Line 514(1,1): Condition always TRUE
>>> Warning 216 "Interface_usb-dmx2.c" Line 533(0,1): Interrupts disabled during call to prevent re-entrancy: (usb_token_reset)
>>> Warning 216 "Interface_usb-dmx2.c" Line 533(0,1): Interrupts disabled during call to prevent re-entrancy: (usb_tbe)
>>> Warning 216 "Interface_usb-dmx2.c" Line 533(0,1): Interrupts disabled during call to prevent re-entrancy: (usb_cdc_flush_out_buffer)
Memory usage: ROM=21% RAM=49% - 55%
0 Errors, 4 Warnings.
Loaded C:\Documents and Settings\Juan\Escritorio\USB DMX\Interface_usb-dmx2.cof.
BUILD SUCCEEDED: Sat Feb 19 02:43:03 2011
#include <18f2610.h>
#FUSES HS //High speed Osc (> 4mhz)
#FUSES NOPROTECT //Code not protected from reading
#FUSES NOBROWNOUT //No brownout reset
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#use delay(clock=20000000)
#use rs232(xmit=PIN_C6, rcv=PIN_C7,stream=PC)
/************************************************************************
* USART registers *
************************************************************************/
#byte BAUDCON= 0xFB8 // BAUD RATE CONTROL REGISTER
#byte SPBRGH= 0xFB0 // EUSART Baud Rate Generator Register, high Byte
#byte SPBRG= 0xFAF // EUSART Baud Rate Generator Register, Low Byte
#byte RCSTA= 0xFAB // RECEIVE STATUS AND CONTROL REGISTER
#byte TXSTA= 0xFAC // TRANSMIT STATUS AND CONTROL REGISTER
#byte RCREG= 0xFAE // EUSART Receive Register
#byte PIR1= 0xF9E // Peripheral Interrupt Request (Flag)
#byte PIE1= 0xF9D // PIE1 (Peripheral Interrupt Enable 1)
#byte TXREG= 0xFAD // Registro de Transmisión
#bit SPEN= RCSTA.7 // Serial Port Enable bit
#bit RX9= RCSTA.6 // 9-bit Receive Enable bit
#bit SREN= RCSTA.5 // Single Receive Enable bit
#bit CREN= RCSTA.4 // Continuous Receive Enable bit
#bit ADDEN= RCSTA.3 // Address Detect Enable bit
#bit FERR= RCSTA.2 // Framing Error bit
#bit OERR= RCSTA.1 // Overrun Error bit
#bit RX9D= RCSTA.0 // 9th bit of Received Data
#bit TX9D= TXSTA.0
#bit TRMT= TXSTA.1 // Bit del estado de llenado del buffer TSR (0 lleno / 1 vacio)
#bit BRGH= TXSTA.2 // High Baud Rate Select bit
#bit SENDB= TXSTA.3
#bit SYNC= TXSTA.4 // EUSART Mode Select bit
#bit TXEN= TXSTA.5
#bit TX9= TXSTA.6
#bit TXIF= PIR1.4 // Flag de interrupción de transmisión de la EUSART
#bit RCIF= PIR1.5 // EUSART Receive Interrupt Flag bit
#bit RCIE= PIE1.5 // EUSART Receive Interrupt Enable bit
#bit BRG16= BAUDCON.3 // 16-bit Baud Rate Register Enable bit
#bit ABDEN= BAUDCON.0 // Auto-Baud Detect Enable bit
/************************************************************************
* Variables globales y constantes *
************************************************************************/
#define RED_LED PIN_B0 // Define el PIN donde se conectará el LED Rojo
#define GREEN_LED PIN_B1 // Define el PIN donde se conectará el LED Verde
#define BLUE_LED PIN_B2 // Define el PIN donde se conectará el LED Azul
#define DMX_WAIT_START 0 // Para salvar el estado de espera de bit de start
#define DMX_WAIT_CHANNEL 1 // Para salvar el estado de espera de bits de canal
#define DMX_WAIT_SEPARATOR 2 // Para salvar el estado de espera de separador
#define DMX_RECEIVE_DATA 3 // Para salvar el estado de espera de valor del canal
#define DMX_SET_DATA 4 // Para salvar el estado de seteo de datos
int8 Ticks = 0; // Para salvar el número de ticks del Timer
int16 redValue = 0; // Para salvar el valor del nivel del LED rojo
int16 greenValue = 0; // Para salvar el valor del nivel del LED verde
int16 blueValue = 0; // Para salvar el valor del nivel del LED azul
int8 receivedData = 0; // Para salvar el dato recibido desde la USART
int8 byteCounter = 0;
int8 DMX_status = DMX_WAIT_START; // Para salvar el status del autómata
int16 selectedChannel = 0; // Para salvar el canal seleccionado
int16 tmpChannel = 0;
int16 tmpChannelValue = 0; // Para salvar el total de bytes del valor del canal
int16 channelValue = 0; // Para salvar el valor del canal seleccionado
int8 ackFlag = 0;
int8 ackStatus = 0;
void sendAck(){
if (TXIF==1){
TXREG = 0x47;
while (TRMT == 0){}
}
return;
}
void setData(){ // Setea los valores recibido para cada canal
if(selectedChannel == 1){
redValue = channelValue;
}
if(selectedChannel == 2){
greenValue = channelValue;
}
if(selectedChannel == 3){
blueValue = channelValue;
}
return;
}
/************************************************************************
* Interrupción Timer 0: *
************************************************************************/
#int_Timer0
void TIMER0_isr()
{
Ticks++;
//Si el timer llega a 0, entonces enciende los LEDs cargando el valor recibido.
if (Ticks==0){
if(redValue)output_high(RED_LED);
if(greenValue)output_high(GREEN_LED);
if(blueValue)output_high(BLUE_LED);
}
//Si el Timer es igual al valor establecido, apaga el LED.
if(Ticks==redValue)
output_low(RED_LED);
if(Ticks==greenValue)
output_low(GREEN_LED);
if(Ticks==blueValue)
output_low(BLUE_LED);
set_timer0(128);
}
/************************************************************************
* Interrupción USART: *
************************************************************************/
#INT_RDA
void receivedUSARTData(){
if(!ackFlag){
while(RCIF){
receivedData = RCREG;
switch(ackStatus){
case 0:
if(receivedData == 0x53){
ackStatus = 1;
}
break;
case 1:
if(receivedData == 0x32){
ackFlag = 1;
sendAck();
}
break;
default:
ackStatus = 0;
break;
}
}
}else{
while(RCIF){ // Repite el proceso siempre que exista un dato en el buffer
receivedData = RCREG; // Salva el dato recibido desde la USART.
switch(DMX_status){
case DMX_WAIT_START:
if(receivedData == 0x43){
DMX_status = DMX_WAIT_CHANNEL;
byteCounter = 0;
tmpChannelValue = 0;
tmpChannel = 0;
byteCounter++;
output_high(PIN_C0);
output_low(PIN_C1);
output_low(PIN_C2);
output_low(PIN_C3);
}
break;
case DMX_WAIT_CHANNEL:
if((receivedData > 0x2F) && (receivedData < 0x3A)){
byteCounter++;
tmpChannel = (tmpChannel * 10) + (receivedData - 48);
if(byteCounter == 4){
DMX_status = DMX_WAIT_SEPARATOR;
}
output_low(PIN_C0);
output_high(PIN_C1);
output_low(PIN_C2);
output_low(PIN_C3);
}else{
DMX_status = DMX_WAIT_START;
}
break;
case DMX_WAIT_SEPARATOR:
if(receivedData == 0x4C){
DMX_status = DMX_RECEIVE_DATA;
byteCounter++;
output_low(PIN_C0);
output_low(PIN_C1);
output_high(PIN_C2);
output_low(PIN_C3);
}else{
DMX_status = DMX_WAIT_START;
}
break;
case DMX_RECEIVE_DATA:
if((receivedData > 0x2F) && (receivedData < 0x3A)){
byteCounter++;
tmpChannelValue = (tmpChannelValue * 10) + (receivedData - 48);
if(byteCounter == 8){
DMX_status = DMX_WAIT_START;
channelValue = tmpChannelValue;
selectedChannel = tmpChannel;
setData();
output_low(PIN_C0);
output_low(PIN_C1);
output_low(PIN_C2);
output_high(PIN_C3);
}
}else{
DMX_status = DMX_WAIT_START;
}
break;
}
}
}
return;
}
/************************************************************************
* Programa Principal *
************************************************************************/
void main()
{
set_tris_b(0);
set_tris_c(0b11001111);
// Activamos las interrupciones de recepción del Timer0
setup_timer_0(RTCC_8_BIT|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
// Configuración de la USART
TX9=1;
TXEN=1;
TX9D=1;
SPBRG=19; // 230400bps en 20Mhz.
SPBRGH=0; // Byte alto para el BRG
BRGH=1; // High Speed
BRG16=1; // 16 bit BRG
SYNC=0; // Transmisión asíncrona
SPEN=1; // Activamos la USART
RX9=0; // 9 bit para la recepcion
SREN=0; // Desactiva recepción de un byte
CREN=1; // Recepción activada
ADDEN=0; // Desactivada la autodetección de dirección
FERR=0; // No hay error de frame con 1 se activa
OERR=0; // No hay error de overrun con 1 se activa
int i =0;
for(i=0;i<=3;i++){
output_high(RED_LED);
output_high(PIN_C0);
output_high(PIN_C1);
output_high(PIN_C2);
output_high(PIN_C3);
delay_ms(300);
output_low(RED_LED);
output_low(PIN_C0);
output_low(PIN_C1);
output_low(PIN_C2);
output_low(PIN_C3);
delay_ms(300);
}
enable_interrupts(INT_RDA);
enable_interrupts(INT_TIMER0);
enable_interrupts(GLOBAL);
set_timer0(128);
redValue = 0;
greenValue = 0;
blueValue = 0;
while(TRUE){
}
}
Felicitaciones compañero!
Tiene muy buena pinta! ((:-)) ((:-))
Gracias por compartir!!
Saludos. 8)