Interfaz USB-DMX basada en DMX4ALL.

[piovi]

Muchas gracias juanm, pro buscando imagenes e internet me di cuenta que el SN75176BP no es igual al max488, me podrias decir en que pines del SN75176BP van los que antes estaban en los pines  2, 3, 5, 6, 8, 7 del max? y de los capacitores del Xtal cual va de cada lado, o es lo mismo?? desde ya muchisimas gracias por el aporte a todoss!! a muchos que tenemos pequeñas cosas nos cuesta demasiado una consola DMX o pagar el robo de caro que es una interfaz,... saludos!!

[ariel landa]

hola Khronos_Nieto.
te cuento ya hace como 6 meses me arme tu controladora dmx la cual me anda de 10 ahora el problema que me surgio es el siguiente yo la usaba con 4 efectos led de 3 canales cada uno lo cual me dava 12 canales de datos hasta aca bien  desde el principio me salto algo rarro en la interfaz. lo rarro era que tenia que tener el segundo canal del freestyler al maximo para que ande la controladora es decir que en 16 canales que tiene le tenia que restar 2. mas de 16 nunca me detecto la iterfaz.
ahora me compre 4 cabezas mobiles de 8 canales cada una lo cual me voy a 2 canales con las cabezas y 12 de efectos led.
mi gran problema es: como ahora para que me tome minimo 100 canales como para no tener mas drama y como se puede solucionar el tema del segundo canal. desde ya muchas gracias a todos y espero respuestas.
me olvide de comentarte yo no se programacion si me podes facilitar el hex modificado seria de mucha ayuda.

[Khronos_Nieto]

Buenas compañeros,

Disculpad mi ausencia en este hilo de DMX, sigo frecuentando mucho el foro pero apenas he tocado nada de DMX desde este pequeño proyecto. Además resulta que los focos RGB con los que hacía mis pruebas no los tengo ahora disponibles (están en casa, a 400 km.. ).

Para Ariel Landa y otros que han preguntado acerca de como incrementar el número de canales, si hechan un vistazo al código verán que es muy muy sencillo. El programa realmente no tiene dificultad ninguna, y creo recordar que estaba mas o menos bien comentado. De todas formas os comento lo que hay que hacer para aquellos que no se manejen mucho en C.

Abran el archivo principal "Interface_usb-dmx2.c" y dentro de la rutina "Procesa", está la siguiente sentencia: "while (indiceTX < 16){" simplemente incrementen ese 16 a un número superior (máximo 511 evidentemente).

También hay que incrementar el tamaño del array que almacena los valores para cada canal, originalmente es de 16, pero si ponen por ejemplo 100 en el while anterior, tendrán que poner también el array con un tamaño de 100. El array esta declarado en la zona de variables "int8 TramaDMX[16];".

Simplemente es cambiar esas dos cosas y recompilar en CCS.

Un saludo.!

[Juanm]

GRACIAS KHRONOS!!!!!!!!!!

habia intentado hacerlo pero metia 512 xD (no se casi nada de programacion, solo pascal que no es igual pero es parecido, e intente hacer algo sin entender nada, error burdo, y no contar al 0 como un canal, puede ser?? )

cuando ande con tiempo y consiga el pickit de un familiar reprogramo y comento a ver si funka

MUCHAS GRACIAS CHE! sos un capo 

salutes

[Juanm]

tengo una duda, cambie los valores que dijiste y no toque nada mas, compilo, el ccs me da 4warnings pero 0 error, eso esta bien??

grabo el pic con el hex nuevo y cuando conecto el USB me tira como que no reconoce el dispositivo, saco, grabo de vuelta el mismo pic con le mismo programador pero con el hex ORIGINAL y lo reconoce al toke....

que estoy haciendo mal?? cambie los 2 uses en la carpeta del CCS y los modifico para que me anden (tenia como directorio de los uses un /include/nombre_del_include y lo cambie a <nombre_del_include> para que me funkara, al igual que en el programa principal... esta mal eso?? )

lo que me queda probar es compilar el programa si como me lo mandas vos (el programa en C original) a ver si es problema de la compilacion u otra cosa...

EDITO:

esto es lo que me tira el log

Código: [Seleccionar]

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

[Juanm]

bueno, al fin logre compilarlo y que me funke! no sar el compilador desde el MPLAB, compilen directo del CCS, no se por que no me funka compilando desde el mplab...

muchas gracias!!!!!!!

[DJ TRAN-C]

Tengo un problema:

Conecto la interfaz dmx al puerto usb de la Pc me pide el driver !y no consigo donde sacarlo! 
si me pudieran ayudar se los agradecería mucho.
Saludos.
 

[Juanm]

Esta en la carpeta "include", si mal no me equivoco es el archivo "mchpcdc.inf", por lo menos use ese de "diver" 

[matgg]

Buenas gente:

Estoy siguiendo este tema y quiero probarlo con el simulador, pero qué es lo que debería ver en el simulador???

porque las salidas siempre estna en 0
deberia usar el programa y configurrar que use el puerto virtual del proteus???

Muchas Gracias

si tengo que poner ese puerto alguno sabe cuál es? o como puedo saberlo??

 

[mauro36]

Hola a todos los del foro, queria hacer comentario con respecto al esquema.
En el pin de VUSB hay un capacitor ceramico de 470nf cuando en realidad va un capacitor electrolitico de 10uf.
Quiza con eso tambien se reduzca el ruido que te hacia "reiniciar" el micro

[wilmar88]

Muy bueno el proyecto, en la sumulación 10 puntos, ahora lo armé en protoboard pero con el 4550, alguien lo probó con este??? porfavor si alguien podría decirme los pasos para seguir para cambiar al 4550 ya que soy nuevo con el CCS y no se como modificar esta cuestión, muchas gracias !

Una cosita mas, en el dibujo dice 12Mhz puedo colocar uno de 11.0592 o uno de 20mhz??? y en el programa dice 48000000 en el clock, se debe cambiar?? o algo en las cabeceras del pic?

Wilmar

[dishelt]

hola  a todos, tengo pensado contruir el circuito de manolator, pero tengo una duda, no es mas facil poner un adaptador de paralelo a usb?

[luiscolo]

Estimado Khronos y toda la gente del hilo y del foro:
aun no me he dado por vencido respecto del usb y los ruidos electricos y el descuelgue del puerto serie;
finalmente, he decidido hacer un "casting" de adaptadores usb_rs232 de los disponibles en mercado libre, y el resultado fue el siguiente:

todos ellos, excepto uno, tienen el mismo problema, que con cualquier ruido electrico se desconectan del programa aunque no se desmonta el puerto, y la unica manera sigue siendo desenchufar y reenchufar el adaptador,

pero... pero !!!!!

un modelo chipset cp2102 funciona a la perfeccion, ademas de tener drivers firmados digitalmente,
con la interfaz optoacoplada (como siempre lo estuvo) he hecho tormenta de conexion/desconexion y ni una sola vez he logrado el efecto tan odiado, nunca ha dejado de funcionar y creo que sera la opcion definitiva, al menos por este año, para mis comunicaciones usb a la pc!

lamento no tener una solucion para el mismo problema con los pic, pero bueno, ya habra algun otro forero que de en la tecla,
por lo pronto les acerco esta solucion ya que he estado desahuciado con este tema, llegando a pensar que no iba a tener solucion;

les mando un abrazo grande y hasta pronto!

[cristiancrm]

Hola, amigos. Cómo están?

Yo estoy haciendo una interface DMX también basada en el code de nuestro queridísimo amigo.
También se me presentó la idea de hacerlo vía RS232 directamente y tuve que recurrir a un conversor.
Bueno, hace un tiempo concurrí una presentación de productos Microchip que se hizo en BsAs, y ahí nos entregaron una placa que cumple la funcionalidad de convertir USB a señales RS232 (incluye el MAX232, con lo cual también tiene salidas TTL). Bien, ese día conocí al MCP2200. Es un integradito que necesita un cristal de 12Mhz y un par de capacitores para salir funcionando. De todos los adaptadores que probé, éste me resultó de maravillas. Posee una aplicación para cambiar el VId del USB entre otros parámetros. También es posible modificar el boudrate. Para quienes viven en BsAs, pueden conseguirlo en Elemon, ahí los venden y creo que cuesta algo de u$s4.

Respecto a la interface DMX, aun no logro hacerla funcionar. Configuré el PIC para que la USART funcione a 250Kbps. Desde el hyperterminal envío las tramas una a una y funciona de maravilla. Pero el problema aparece cuando lo hago desde el FreeStyler. Por algún motivo no interpreta los datos que le llega al PIC y no hace nada. Para poder comprobarlo, en cada estado de recepción puse un led, de manera que se pueda verificar si realmente llega el 0X43 de inicio de trama. Desde el hyperterminal el led enciende bien cuando le envío 0x43, pero no desde el freeStyler. Analicé los datos que el FreeStyler envía y noto que están bien, con la única diferencia que éste lo envía todo junto (C001L255, por ejemplo), mientras que desde el hyper terminal sale byte a byte.
También hice una aplicación en VC# para usar el mismo método que usa FreeStyler para enviar los datos. De comienzo tampoco me funcionó, pero me dí cuenta que era un problema de configuración del PIC, estaba configurado para usar 9bits, y VC# usaba 8bits. Luego de cambiar eso, desde VC# funciona de maravillas. Pero claro, no tengo aun toda la funcionalidad que ofrece freeStyler, es por eso que quiero hacerlo funcionar con éste último.
De momento, mi idea es usar el puerto serie conectado al PIC, y a éste conectarle los 3 Leds, sin enviar nada por medio de otro puerto. Como les comenté, esto funciona bien desde HyperTerminal y desde VC#.

Mis preguntas son:

1 - A qué baudrate opera FreeStyler sobre el puerto configurado? No pude ver el baudrate, pero sí el puerto COM.
2 - Es posible que freeStyler esté trabajando a otro baudrate que el configurado en el PIC?

Desde ya, muchas gracias a todos y éxitos!
Cristian.

[cristiancrm]

Hola, amigos.

Para complementar mis preguntas, a continuación les dejo el código del firmware que estoy haciendo para el DMX.
Si alguien tiene alguna sugerencia al respecto, bienvenida será.
Básicamente el problema está cuando intento usar el FreeStyler. Veo que los bytes de reconocimiento se envían al PIC, pero no recibe respecta de este. Lo mismo pasa cuando intenta enviar la trama DMX. Lo raro es que desde VC# (como les comenté anteriormente) envío exactamente lo mismo y sí me responde. No conozco mucho FreeStyler, pero para validar los datos que envía lo hice con un analizador de puerto serie, como hizo nuestro colega.

Básicamente está compuesto por dos interrupciones.

1 - Interrupción del Timer para definir el nivel de cada led.
2 - Interrupción del Puerto Serie por recepción, para adquirir los datos enviados desde la PC.

En la interrupción de la USART se puede observar el algoritmo para analizar los datos de la trama recibida. Está dividido en dos partes: por un lado, la recepción de los bytes de reconocimiento que envía el FreeStyler. El PIC devuelve 0x47. Por otro lado, la recepción de los datos de la trama siempre y cuando el PIC haya respondido el ACK a FreeStyler.
Probé también sin validar los bytes de reconocimiento, ya que FreeStyler envía a "rolete" la trama, pero no pasa nada.

Estoy atento a cualquier comentario.
Gracias de antemano.
Cristian.

Código: [Seleccionar]

#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){
     
   }
}