//#define F_CPU 8000000
#include<util\delay.h>
#include"lib_dmx_in.h"
#include<stdio.h>
#include<stdlib.h>
#include "lib_indicator.h"
#include <avr/wdt.h>
//#include "lib_dmx_in.h"
#include <avr/interrupt.h>
// ********************* definiciones locales *********************
enum {IDLE, BREAK, STARTB, STARTADR}; //DMX states
volatile uint8_t gDmxState;
const char colors[][3]={
{255,0,0},
{0,255,0},
{0,0,255},
{255,128,0},
{255,0,128},
{128,255,0},
{128,0,255},
{0,255,128},
{0,128,255},
{255,255,0},
{255,0,255},
{0,255,255},
{255,255,255}
};
//Vuelva a escribir el valor del final de la tabla de colores de la Ilustración
void set_color(int color){
while(color>12){
color-=12;
}
DmxRxField[0]=colors[color][0];
DmxRxField[1]=colors[color][1];
DmxRxField[2]=colors[color][2];
}
//Inicialización salida por o cualitativa
void init_pinouts(){
DDRB |= (1<<PB5) | (1<<PB6) | (1<<PB7); //Pin de salida LED
DDRD |= (1<<PD2); //La colocación del selector de la transmisión de salida
PORTD |= (1<<PD2); //Ajuste de estatus para RX 0 - venida de transmisión
}
//Inicializar el puerto y romper? para el sonido de control en cs
void init_Sound(){
DDRD &= ~(1<<PD3); //Configuración de 4 pines del puerto D como la entrada
PORTD |= (1<<PD3); //establecer resistencia socavó alcanzando dual. Importante para la Q3 polaridad
MCUCR |= (1<<ISC11); //Configuración de interrupción INT1
GICR |= (1<<INT1); //la conexión INT1 interrumpir ??
}
//Inicializar el temporizador para evitar cortar efecto estroboscópico
#define OV_COUNT 14 //161 metros, 7 no repleta? = 0.25ms
#define OV_SIZE 161 //vale ?? comenzando Contador inicial
volatile int timer_counter=0; //contador del temporizador
void init_timer(){
TCCR0 |= (1<<CS02) ; //prescaler 256
TIMSK |= (1<<TOIE0); //en? desbordamientos de interrupción
TCNT0 = OV_SIZE; //vale ?? comenzando Contador inicial
}
//devolver el cronómetro
void reset_timer(){
TCNT0 = OV_SIZE; //vale ?? comenzando Contador inicial
timer_counter=0;
}
enum {FALSE=0, TRUE=1};
volatile char sound_time=TRUE;
//programa de primordial
int main(void)
{
cli();
init_DMX_RX(); //Inicialización recibir DMX
init_pinouts(); //Establece los puertos de E / S
init_timer(); //Ajuste del temporizador
init_Sound(); //inicializar la entrada para controlar el sonido bastante.
sei(); //en relación ?? ¡romper?
int PWM_timer;
while(1) //el centro principal bucle
{
get_dips(); //Cheque Dipswitch y descargar la dirección DMX
for (PWM_timer=0; PWM_timer<255 ; PWM_timer++) //soga explicar a través de una serie de relleno
{
if (DmxRxField[0]>PWM_timer) //rojo
{
PORTB &= ~(1<<PB5); //LED apagado
}else{
PORTB |= (1<<PB5); //LED prendido
}
if (DmxRxField[1]>PWM_timer) //verde
{
PORTB &= ~(1<<PB6); //LED apagado
}else{
PORTB |= (1<<PB6); //LED prendido
}
if (DmxRxField[2]>PWM_timer) //azul
{
PORTB &= ~(1<<PB7); //LED apagado
}else{
PORTB |= (1<<PB7); //LED prendido
}
}
}
}
void change_color()
{
int temp;
int color_number=0;
do{
temp=color_number;
temp+=7;
if (temp>12)
{
temp-=12;
}
}while ((temp>12)|(color_number==temp)); //reloj? El temporizador sea inferior a un valor? de los registros en la tabla, y? para que no? el mismo color
color_number=temp; //recordando barato actualmente mostrar en contra de color
set_color(color_number); //que aclarar el color de la matriz definida
}
//comenzar la función manual que interrumpe el sonido
ISR(INT1_vect)
{
if(sound_time==FALSE){return;} //como no hacia arriba molino ?? tiempo mínimo luminoso, salir
change_color();
reset_timer(); //devolver el cronómetro en un tiempo mínimo luminosa
sound_time=FALSE; //el establecimiento de una bandera para el temporizador
}
ISR(TIMER0_OVF_vect){ //interrupción del temporizador
int count;
switch (mode){
case SOUND:
count = OV_COUNT + DmxAddress;
break;
case MANUAL:
count = OV_COUNT + DmxAddress * 4;
break;
default:
count = OV_COUNT;
}
if(timer_counter>=count){
timer_counter=0;
sound_time=TRUE; //tiempo mínimo deducible luminoso, puede cambiar? color
if (mode==MANUAL){
change_color();
}
}else{ timer_counter++; }
}
// *************** DMX recepción de inicialización ****************
void init_DMX_RX(void)
{
#ifdef USE_DIP
DDRA = 0; //establecer Dips
PORTA = 0xFF;
DDRB &= ~((1<<PB0)|(1<<PB1));
PORTB |= (1<<PB0)|(1<<PB1);
#endif
DDRD |= (1<<2);
PORTD &= ~(1<<2);
UBRRH = 0; //habilitar la recepción
UBRRL = ((F_OSC/4000)-1); //250kbaud, 8N2
UCSRC = (1<<URSEL)|(3<<UCSZ0)|(1<<USBS);
UCSRB = (1<<RXEN)|(1<<RXCIE);
gDmxState= IDLE;
}
// ************* Ver DMX dirección de inicio **************
void get_dips(void)
{
#ifdef USE_DIP
uint16_t Temp;
if (!(PINB &(1<<PB1))){ //modo manual / sonido
Temp= //DMXAdress = tiempo de retardo
(!(PINA &(1<<PA7)) *1) +
(!(PINA &(1<<PA6)) *2) +
(!(PINA &(1<<PA5)) *4) +
(!(PINA &(1<<PA4)) *8) +
(!(PINA &(1<<PA3)) *16) +
(!(PINA &(1<<PA2)) *32) +
(!(PINA &(1<<PA1)) *64) +
(!(PINA &(1<<PA0)) *128);
DmxAddress= Temp;
if (!(PINB &(1<<PB0))) //manual, sin sonido
{
mode=MANUAL;
}
else
{
mode=SOUND;
GICR |= (1<<INT1); //activación de sonido trigger INT1
}
UCSRB &= ~(1<<RXCIE); //Receptor desactivar si la dirección de inicio = 0
set_color(color_number);
return;
}
mode=DMX;
Temp=
(!(PINA &(1<<PA7)) *1) +
(!(PINA &(1<<PA6)) *2) +
(!(PINA &(1<<PA5)) *4) +
(!(PINA &(1<<PA4)) *8) +
(!(PINA &(1<<PA3)) *16) +
(!(PINA &(1<<PA2)) *32) +
(!(PINA &(1<<PA1)) *64) +
(!(PINA &(1<<PA0)) *128) +
(!(PINB &(1<<PB0)) *256);
if (Temp != 0)
{
DmxAddress= Temp;
if (!(UCSRB &(1<<RXCIE))) //receptor es desabilitado -> enable y esperar break
{
gDmxState= IDLE;
UCSRB |= (1<<RXCIE);
GICR &= ~(1<<INT1); //desabilitar activación de sonido trigger INT1
}
}
else
{
UCSRB &= ~(1<<RXCIE); //desabilitar Receptor si la dirección de inicio = 0
GICR &= ~(1<<INT1); //desabilitar activación de sonido trigger INT1
uint8_t i;
for (i=0; i<sizeof(DmxRxField); i++)
{
DmxRxField[i]= 0;
}
}
#endif
}
// *************** DMX recepción ISR ****************
ISR (USART_RX_vect)
{
static uint16_t DmxCount;
uint8_t USARTstate= UCSRA; //obtener el estado antes del dato!
uint8_t DmxByte = UDR; //obtener el dato
uint8_t DmxState = gDmxState; //sólo tienes que cargar una vez de SRAM Aumentar la velocidad
if (USARTstate &(1<<FE)) //comprobar si hay break
{
UCSRA &= ~(1<<FE); //reset bandera (Necesario para la simulación en AVR Studio)
DmxCount = DmxAddress; //reset contador de canales (contar los canales antes de la dirección de inicio)
gDmxState= BREAK;
}
else if (DmxState == BREAK)
{
if (DmxByte == 0) gDmxState= STARTB; //código de arranque normal detectado
else gDmxState= IDLE;
}
else if (DmxState == STARTB)
{
if (--DmxCount == 0) //alcanzado con la dirección de inicio?
{
DmxCount= 1; //establecer contador para canales necesarios
DmxRxField[0]= DmxByte; //Ver primera canal DMX de dispositivo
gDmxState= STARTADR;
}
}
else if (DmxState == STARTADR)
{
DmxRxField[DmxCount++]= DmxByte; //leer canales
if (DmxCount >= sizeof(DmxRxField)) //canales recibidos todos?
{
gDmxState= IDLE; //esperar para el próximo break
}
}
}
