Lib. DMX.C de Hendrik Hölscher para ATMEGA328P

//#include "lib_indicator.h"
#include "lib_dmx_in.h"
#include <stdlib.h>
#include <avr/wdt.h>
#include <util/delay.h>








// *************** Initialization ****************
void init_system(void)
{
wdt_reset();
wdt_enable(WDTO_500MS);        //enable watchdog (Timeout= 0.5s)
wdt_reset();
DDRD |= (1<<PD5);            //LED pin is output
DDRD |= (1<<PD6);            //LED pin is output

//init_ind();
init_DMX_RX();
get_dips();
}




int main(void)

{
cli();
init_system();
sei();


//Endlosschleife
    while(1)
    {

            
    if(DmxRxField[0] < 127)
        {
            PORTD |= (1<<PD5); //1. Kanal ON
        }
        else
        {
            PORTD &=~(1<<PD5); //1. Kanal OFF
        }
        
        
    if(DmxRxField[1] < 127)
        {
            PORTD |= (1<<PD6); //2. Kanal ON
        }
        else
        {
            PORTD &=~(1<<PD6); //2. Kanal OFF
        }

    
        }
wdt_reset();
    }

/ **** NOTADEAPLICACI ************************************
*
* Título: biblioteca de recepción DMX512
* Versión: v1.2
* Última actualización: 21.04.07
* Destino: Transceptor Rev.3.01 [ATmega8515]
* Reloj: 8 MHz, 16 MHz
*
* escrito por hendrik hoelscher, www.hoelscher-hi.de
***************************************************************************
 Este programa es software gratuito; puedes redistribuirlo y / o
 modificarlo bajo los términos de la Licencia Pública General GNU 
 según lo publicado por la Free Software Foundation; cualquiera de las versiones 2 de
 la Licencia, o (a su elección) cualquier versión posterior. 

 Este programa se distribuye con la esperanza de que sea de utilidad, 
 pero SIN NINGUNA GARANTÍA; sin siquiera la garantía implícita de
 COMERCIABILIDAD o APTITUD PARA UN PROPÓSITO EN PARTICULAR. Ver el GNU
 Licencia pública general para más detalles. 

 Si no tiene una copia de la Licencia Pública General GNU, escriba al 
 Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, EE. UU. 

 Para otros modelos de licencia, comuníquese con el autor.

;***************************************************************************/


#include "lib_dmx_in.h"
// # incluye "lib_indicator.h"

// ********************* definiciones locales ********************

enumeración {IDLE, BREAK, STARTB, STARTADR}; // Estados DMX

         uint8_t gDmxState;
         uint8_t * gDmxPnt;
         uint16_t DmxCount;


// *************** Inicialización de recepción DMX ****************
vacío init_DMX_RX (vacío)
{
#ifdef USE_DIP
DDRC & = ~ ((1 << PC0) | (1 << PC1) | (1 << PC2) | (1 << PC3) | (1 << PC4));
PORTC | = (1 << PC0) | (1 << PC1) | (1 << PC2) | (1 << PC3) | (1 << PC4);
DDRB & = ~ ((1 << PB1) | (1 << PB2) | (1 << PB3) | (1 << PB4) | (1 << PB5));
PORTB | = (1 << PB1) | (1 << PB2) | (1 << PB3) | (1 << PB4) | (1 << PB5);
// PB1 PB2 PB3 PB4 PB5 PC0 PC1 PC2 PC3
//1    2    4    8    16   32   64   128    256 
#terminara si


DDRD | = (1 << PD2);
PORTD & = ~ (1 << PD2); // habilitar la recepción
UBRR0H = 0;
UBRR0L = ((F_OSC / 4000) -1); // 250 kbaudios, 8N2
UCSR0C = (1 << USBS0) | (3 << UCSZ00);
UCSR0B = (1 << RXEN0) | (1 << RXCIE0);



gDmxState = IDLE;

uint8_t i;
para (i = 0; i <tamaño de (DmxRxField); i ++)
    {
    DmxRxField [i] = 0;
    }
}



// ************* obtener la dirección de inicio DMX **************
void get_dips (vacío)
{
#ifdef USE_DIP
volátil uint16_t Temp;

if (! (PINC & (1 << PC4))) // habilita y deshabilita la recepción
{                            
                        
Temp = 
        (! (PINB & (1 << PB1)) * 1) +
        (! (PINB & (1 << PB2)) * 2) +
        (! (PINB & (1 << PB3)) * 4) +
        (! (PINB & (1 << PB4)) * 8) +
        (! (PINB & (1 << PB5)) * 16) +
        (! (PINC & (1 << PC0)) * 32) +
        (! (PINC & (1 << PC1)) * 64) +
        (! (PINC & (1 << PC2)) * 128) +
        (! (PINC & (1 << PC3)) * 256); // Noveno bit


                            
    }
si (Temp! = 0)
    {
    DmxAddress = Temp;
    if (! (UCSR0B & (1 << RXCIE0))) // si el receptor estaba deshabilitado -> habilitar y esperar el descanso
        {
        gDmxState = IDLE;
        UCSR0B | = (1 << RXCIE0);
        }
    }
demás
    {
    UCSR0B & = ~ (1 << RXCIE0); // deshabilitar el receptor si la dirección de inicio = 0
    para (Temp = 0; Temp <tamaño de (DmxRxField); Temp ++)
        {
        DmxRxField [Temp] = 0;
        }
    }
#demás
    DmxAddress = 1;
#terminara si 
}



// *************** Recepción DMX ISR ****************
ISR (USART_RX_vect)
{
uint8_t USARTstate = UCSR0A; // obtener el estado
uint8_t DmxByte = UDR0; //obtener datos
uint8_t DmxState = gDmxState; // ¡¡¡Solo obtén una vez de SRAM !!!


// IndFlags | = (1 << SIGNAL_COMING);
 
if (USARTstate & (1 << FE0)) // comprobar si hay ruptura
    {
    UCSR0A & = ~ (1 << FE0); // reiniciar bandera
    DmxCount = DmxAddress; // restablecer el contador de tramas
    gDmxState = BREAK;
    }

más si (DmxState == BREAK)
    {
    si (DmxByte == 0) 
        {
        gDmxState = STARTB; // código de inicio normal detectado
        gDmxPnt = ((uint8_t *) DmxRxField +1);
        }
    de lo contrario gDmxState = IDLE;
    }
    
más si (DmxState == STARTB)
    {
    if (--DmxCount == 0) // ¿Se alcanzó la dirección de inicio?
        {
        gDmxState = STARTADR;
        DmxRxField [0] = DmxByte;
        }
    }

más si (DmxState == STARTADR)
    {
    uint8_t * DmxPnt;
    DmxPnt = gDmxPnt;
    * DmxPnt = DmxByte;
    if (++ DmxPnt> = (DmxRxField + sizeof (DmxRxField))) // ¿todos los canales recibidos?
        {
        gDmxState = IDLE;

        }
    si no gDmxPnt = DmxPnt;
    }                            
}

#include <avr / io.h>
#include <stdint.h>
#include <avr / interrupt.h>

#define F_OSC (16000) // frecuencia del oscilador en kHz (típico 8MHz o 16MHz)
#define USE_DIP

volatile uint8_t     DmxRxField[4];         //array of DMX vals (raw)
volatile uint16_t     DmxAddress;            //start address

extern void init_DMX_RX(void);
extern void get_dips(void);