¿Has leído el artículo?, ¿has visto el vídeo?
Sólo hay que teclear el canal en el teclado matricial. Se reciben TODOS los canales.
que tal amigo nocturno solo molestando para ver si estan bien declarados las entradas para poder dirreccionar el dmx a un canal en especifico dejo el programa espero puedas ayudarme..
#include <16F887.h>
#FUSES WDT //Watch Dog Timer
#FUSES HS //High speed Osc (> 4mhz)
#FUSES PUT //Power Up Timer
#FUSES NOPROTECT //Code not protected from reading
#FUSES NOBROWNOUT //No brownout reset
#FUSES NOMCLR //Master Clear pin used for I/O
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD //No EE protection
#use delay(clock=20000000,RESTART_WDT) // Utilizo clock de 20MHz porque me facilita la elección exacta del baudrate a 250k y tenia el cristal
/************************************************************************
* Registros USART *
************************************************************************/
#byte SPBRG= 0x99 // Registros para el pic 16F628
#byte RCSTA= 0x18 // Aqui se han modificado las direcciones correspondientes para el 628
#byte TXSTA= 0x98
#byte RCREG= 0x1A
#byte PIR1= 0x0C
#byte PIE1= 0x8C
#bit SPEN= RCSTA.7
#bit RX9= RCSTA.6
#bit SREN= RCSTA.5
#bit CREN= RCSTA.4
#bit ADDEN= RCSTA.3
#bit FERR= RCSTA.2
#bit OERR= RCSTA.1
#bit RX9D= RCSTA.0
#bit BRGH= TXSTA.2
#bit SYNC= TXSTA.4
#bit RCIF= PIR1.5
#bit RCIE= PIE1.5
//************************************************************************
#byte TRISC = 0x87
#byte TRISD = 0x88
#byte PORTC = 0x07
#byte PORTD = 0x08
// 9 bits para conseguir la direccion del dispositivo (Midireccionreal)
#bit RD0 = PORTD.0
#bit RD1 = PORTD.1
#bit RD2 = PORTD.2
#bit RD3 = PORTD.3
#bit RD4 = PORTD.4
#bit RD5 = PORTD.5
#bit RD6 = PORTD.6
#bit RD7 = PORTD.7
#bit RC4 = PORTC.4
//************E*****************************************************
/************************************************************************
* Estados protocolo DMX *
************************************************************************/
#define DMX_ESPERA_BYTE 0
#define DMX_ESPERA_BREAK 1
#define DMX_ESPERA_START 2
#define DMX_ESPERA_DATO 3
#define DMX_RECEPCION_DATOS 4
/************************************************************************
* Variables globales y constantes *
************************************************************************/
//--------------------Se han quitado las variables que no utilizo--------------------------------------
int8 DMX_Estado = DMX_ESPERA_BREAK; // Estado de la máquina de estados
int8 DatoRX; // Dato genérico recibido en USART
//int8 DMX_Indice = 0; // Apuntador a una posición de la trama DMX
int8 Ticks = 0;
//***********************************************************************
int8 Midireccionreal, Midireccionvirtual;
int16 CanalDMX; // Canal DMX seleccionado para visualizar, de 1 a 512
int8 DatoDMX; // Dato que contiene el canal seleccionado
int16 DMX_Indice = 0; // Apuntador a una posición de la trama DMX
void Cojedireccion (void);
void Cojedireccion (void){
DatoDMX =0;
if (RD0 == 1)
DatoDMX = DatoDMX+1;
if (RD1 == 1)
DatoDMX = DatoDMX+2;
if (RD2 == 1)
DatoDMX = DatoDMX+4;
if (RD3 == 1)
DatoDMX = DatoDMX+8;
if (RD4 == 1)
DatoDMX = DatoDMX+16;
if (RD5 == 1)
DatoDMX = DatoDMX+32;
if (RD6 == 1)
DatoDMX = DatoDMX+64;
if (RD7 == 1)
DatoDMX = DatoDMX+128;
if (RC4 == 1)
DatoDMX = DatoDMX+256;
}
//*********************************************************************
#define TotalCanales 12 // Total canales a almacenar en este caso solo interesan los 3 primeros
int8 TramaDMX[TotalCanales];// = {0,0,0,0,0,0,0,0,0,0,0,0}; // Trama completa de valores DMX
int8 r1,g1,b1,r2,g2,b2,r3,g3,b3,r4,g4,b4;
union // Estructura para hacer una copia del registro RCSTA
{
unsigned char registro;
struct {
unsigned char RX9D:1;
unsigned char OERR:1;
unsigned char FERR:1;
unsigned char ADDEN:1;
unsigned char CREN:1;
unsigned char SREN:1;
unsigned char RX9:1;
unsigned char SPEN:1;
} bits ;
}Copia_RCSTA;
/************************************************************************
* Interrupción Timer 0: *
************************************************************************/
#int_Timer0
TIMER0_isr()
{
Ticks++;
if (Ticks==0)
{
r1 = TramaDMX[0];
g1 = TramaDMX[1];
b1 = TramaDMX[2];
r2 = TramaDMX[3];
g2 = TramaDMX[4];
b2 = TramaDMX[5];
r3 = TramaDMX[6];
g3 = TramaDMX[7];
b3 = TramaDMX[8];
r4 = TramaDMX[9];
g4 = TramaDMX[10];
b4 = TramaDMX[11];
output_high(pin_B0);
output_high(pin_B1);
output_high(pin_B2);
output_high(pin_B3);
output_high(pin_B4);
output_high(pin_B5);
output_high(pin_B6);
output_high(pin_B7);
output_high(pin_A1);
output_high(pin_A2);//r4
output_high(pin_A3);//g4
output_high(pin_A0);//b4
}
if(Ticks==r1)
output_low(pin_A2);
if(Ticks==g1)
output_low(pin_A3);
if(Ticks==b1)
output_low(pin_B3);
if(Ticks==r2)
output_low(pin_B4);
if(Ticks==g2)
output_low(pin_B5);
if(Ticks==b2)
output_low(pin_B6);
if(Ticks==r3)
output_low(pin_B7);
if(Ticks==g3)
output_low(pin_A0);
if(Ticks==b3)
output_low(pin_A1);
if(Ticks==r4)
output_low(pin_B0);
if(Ticks==g4)
output_low(pin_B1);
if(Ticks==b4)
output_low(pin_B2);
/*******************************
set_timer0(128);
}
/************************************************************************
* Interrupción RDA: dato recibido por la USART *
* Esta interrupción se activa cada vez que se recibe un dato en la *
* USART. Mediante el control de una máquina de estados se determina *
* la validez y el significado del dato recibido, y se obra en *
* consecuencia. *
************************************************************************/
//--------La interrupción de la USART no se ha modificado, esta tal cual el receptor de Nocturno----------------
//--------solo cambia el hecho de que TotalCanales vale 3 en lugar de 512----------------------------------------
#int_rda
void Dato_Recibido_USART(void)
{
while (RCIF) // ejecutamos mientras haya un dato pendiente de procesar
{
// Hacemos una copia del registro RCSTA porque sus bits cambian de valor
// al leer RCREG y modificar CREN
Copia_RCSTA.registro = RCSTA;
// En RCREG está el dato que acaba de recibir la USART
DatoRX = RCREG;
// Si se reciben más de 3 bytes sin haberlos procesado, se produce un error
// de Overrun. En este caso, se borra el error reiniciando CREN y dejamos
// la interrupción preparada para procesar la siguiente trama DMX
if (Copia_RCSTA.bits.OERR)
{
CREN=0;
CREN=1;
DMX_Estado = DMX_ESPERA_BYTE;
return;
}
// Máquina de estados
switch (DMX_Estado)
{
case DMX_ESPERA_BYTE: // si estamos en este estado y hay error FRAME
// es que nos ha pillado en medio de un Byte. Hay que seguir esperando
// hasta que desaparezca el error.
if (!Copia_RCSTA.bits.FERR)
// Ha llegado un byte. Ahora esperaremos la señal Break
DMX_Estado = DMX_ESPERA_BREAK;
break;
case DMX_ESPERA_BREAK: // estamos esperando la señal Break
// Esta señal se identifica porque aparece el error de Frame
if (Copia_RCSTA.bits.FERR)
// Tras recibir el error de Break, hay que esperar un byte de valor 0
if (!DatoRX)
DMX_Estado = DMX_ESPERA_START;
break;
case DMX_ESPERA_START: // ya hemos recibido el Break y ahora hay que
// esperar un Byte con valor 0, que será la señal de Start
// Mientras tanto, si recibimos un error de Frame, hay que volver a
// empezar para recibir la señal de comienzo de trama.
if (Copia_RCSTA.bits.FERR)
DMX_Estado = DMX_ESPERA_BYTE;
else {
if (!DatoRX)
{
// Llegados a este punto, ya hemos recibido el Byte Start=0
// y comenzamos la trama de valores DMX.
DMX_Indice = 0;
DMX_Estado = DMX_RECEPCION_DATOS;
} else
// Si el dato recibido no es 0, volvemos a empezar
DMX_Estado = DMX_ESPERA_BREAK;
}
break;
case DMX_RECEPCION_DATOS:
// En este estado estamos recibiendo la trama de datos DMX
// Si se detecta un error de Frame es que ha habido un error y estamos
// al principio
if (Copia_RCSTA.bits.FERR)
if (!DatoRX)
DMX_Estado = DMX_ESPERA_START;
else
DMX_Estado = DMX_ESPERA_BYTE;
else
{
// Almacenamos el dato recibido en nuestro array
TramaDMX[DMX_Indice++] = DatoRX;
// Si ha llegado al final de la capacidad, cambiamos al estado de espera
// de nueva trama
if (DMX_Indice >= TotalCanales)
DMX_Estado = DMX_ESPERA_BREAK;
}
break;
}
}
return;
}
void main()
{
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_wdt(WDT_18MS);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
setup_oscillator(False);
//**********************************************************************************
set_tris_d(0xFF); //Se configura para 8 entradas
set_tris_c(0x01); //Se configuran los pines de los Leds como salidas y el resto como entradas
CanalDMX=2; // Por defecto, el canal seleccionado es el primero
Cojedireccion();
Midireccionvirtual = Midireccionreal;
//**********************************************************************************
// Configuración de la USART
SPBRG=4; // A 20Mhz el baudrate es 250.000, sale de la tabla de la hoja de datos del 16F628
BRGH=1; // Seleccionamos high speed
SYNC=0; // Transmisión asíncrona
SPEN=1; // Activamos la USART
RX9=1; // 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
// Activamos las interrupciones de recepción de la USART y del Timer0
enable_interrupts(INT_RDA);
enable_interrupts(INT_TIMER0);
enable_interrupts(GLOBAL);
//-----------------------------------------------------------
// set_timer0(128);
set_timer0(255);
while(true)
{
delay_ms(5000);
}
}
