Finished generic DMX Module

Author: Tim Essig

artnet.c

@@ -20,8 +20,6 @@ void universeReceivedTMP(uint8_t universe) {
 }
 
 void doTimerStuff1Hz(void) {
-    PORTA.DIRTGL = 0x03;
-
     for(uint8_t i=0; i < 4; i++) {
         universeFPS[i] = universeFPSCounter[i];
         universeFPSCounter[i] = 0;

dmx.c

@@ -5,111 +5,151 @@
 #include <util/delay.h>
 
 
-
-
 uint8_t dmxBuffer[DMX_NUM_UNIVERSES][DMX_UNIVERSE_SIZE];
 
 uint8_t* getUniverseBuffer(uint8_t universe) {
     return dmxBuffer[universe];
 }
 
 
-
 enum DMX_STATE {
     DMX_IDLE,
     DMX_BREAK,
     DMX_START,
     DMX_RUN
 };
 
+typedef struct DMX_PORT {
+    PORT_t*         PORT;
+    uint8_t         PIN;
+    register8_t*    PIN_CTRL;
+    USART_t*        USART;
+    uint8_t         UNIVERSE;
+    uint8_t         OUTPUT_PORT;
+    enum DMX_STATE  TX_STATE;
+    uint16_t        TX_POSITION;
 
-enum DMX_STATE dmx0state = DMX_IDLE;
-enum DMX_STATE dmx1state = DMX_IDLE;
-enum DMX_STATE dmx2state = DMX_IDLE;
-enum DMX_STATE dmx3state = DMX_IDLE;
-uint16_t dmx0ch = 0;
-uint16_t dmx1ch = 0;
-uint16_t dmx2ch = 0;
-uint16_t dmx3ch = 0;
+} DMX_t;
+
+
+volatile DMX_t dmxPorts[DMX_NUM_UNIVERSES];
 
 
 #define DMX_BAUD_BSCALE          0   // vorher 0b1001 -> -1
 #define DMX_BAUD_RESET_BSEL     15   // 125k BAUD @32Mhz, used for RESET
 #define DMX_BAUD_NORMAL_BSEL     7   // 250k BAUD @32Mhz
 
-#define UART0 USARTD0
+void setupDMXPort(DMX_t* PORT) {
+    PORT->PORT->DIRSET = 1 << PORT->PIN; // Pin 3 -> UART 0 TX
+    *PORT->PIN_CTRL = PORT_INVEN_bm;    
 
-void setupDMXPort(USART_t* uart) {
-    uart->BAUDCTRLB = DMX_BAUD_BSCALE << 4;
-    uart->BAUDCTRLA = DMX_BAUD_RESET_BSEL;
+    PORT->USART->BAUDCTRLB = DMX_BAUD_BSCALE << 4;
+    PORT->USART->BAUDCTRLA = DMX_BAUD_RESET_BSEL;
 
-    uart->CTRLA = USART_TXCINTLVL_gm; // TX Highest INT Level    
-    uart->CTRLC = USART_SBMODE_bm | USART_CHSIZE_8BIT_gc; //2 StopBits, 8 DataBits
+    PORT->USART->CTRLA = USART_TXCINTLVL_gm; // TX Highest INT Level    
+    PORT->USART->CTRLC = USART_SBMODE_bm | USART_CHSIZE_8BIT_gc; //2 StopBits, 8 DataBits
 
-    uart->CTRLB = USART_TXEN_bm; //Enable TX
+    PORT->USART->CTRLB = USART_TXEN_bm; //Enable TX
 }
 
 void setupDMX(void) {
-    //DMX 1
-    PORTC.DIRSET = PIN3_bm; // Pin 3 -> UART 0 TX
-    PORTC.PIN3CTRL = PORT_INVEN_bm;    
-    setupDMXPort(&USARTC0);
-
-    //DMX 2
-    PORTC.DIRSET = PIN7_bm; // Pin 3 -> UART 0 TX
-    PORTC.PIN7CTRL = PORT_INVEN_bm;    
-    setupDMXPort(&USARTC1);
-
-
-    //DMX 3
-    PORTD.DIRSET = PIN3_bm; // Pin 3 -> UART 0 TX
-    PORTD.PIN3CTRL = PORT_INVEN_bm;    
-    setupDMXPort(&USARTD0);
-
-    //DMX 4
-    PORTE.DIRSET = PIN3_bm; // Pin 3 -> UART 0 TX
-    PORTE.PIN3CTRL = PORT_INVEN_bm;    
-    setupDMXPort(&USARTE0);
+    dmxPorts[0].PORT = &PORTC;
+    dmxPorts[0].PIN = 3;
+    dmxPorts[0].PIN_CTRL = &PORTC.PIN3CTRL;
+    dmxPorts[0].USART   = &USARTC0;
+    dmxPorts[0].UNIVERSE = 0;
+    dmxPorts[0].OUTPUT_PORT = 1;
+    dmxPorts[0].TX_STATE = DMX_IDLE;
+
+    dmxPorts[1].PORT = &PORTC;
+    dmxPorts[1].PIN = 7;
+    dmxPorts[1].PIN_CTRL = &PORTC.PIN7CTRL;
+    dmxPorts[1].USART   = &USARTC1;
+    dmxPorts[1].UNIVERSE = 1;
+    dmxPorts[1].OUTPUT_PORT = 2;
+    dmxPorts[1].TX_STATE = DMX_IDLE;
+
+    dmxPorts[2].PORT = &PORTD;
+    dmxPorts[2].PIN = 3;
+    dmxPorts[2].PIN_CTRL = &PORTD.PIN3CTRL;
+    dmxPorts[2].USART   = &USARTD0;
+    dmxPorts[2].UNIVERSE = 2;
+    dmxPorts[2].OUTPUT_PORT = 3;
+    dmxPorts[2].TX_STATE = DMX_IDLE;
+
+    dmxPorts[3].PORT = &PORTE;
+    dmxPorts[3].PIN = 3;
+    dmxPorts[3].PIN_CTRL = &PORTE.PIN3CTRL;
+    dmxPorts[3].USART   = &USARTE0;
+    dmxPorts[3].UNIVERSE = 3;
+    dmxPorts[3].OUTPUT_PORT = 4;
+    dmxPorts[3].TX_STATE = DMX_IDLE;
+
+
+    for(uint8_t i=0; i < DMX_NUM_UNIVERSES; i++) {
+        setupDMXPort(&dmxPorts[i]);
+    }
 }
 
 
-void startDMX_TX(void) {    
-    if(dmx0state == DMX_IDLE) {
-        //Set Baud
-        UART0.BAUDCTRLA = DMX_BAUD_RESET_BSEL;
-        UART0.BAUDCTRLB = DMX_BAUD_BSCALE << 4;
+void startDMX_TX(void) {
+    for(uint8_t i=0; i < DMX_NUM_UNIVERSES; i++) {
+        if(dmxPorts[i].TX_STATE == DMX_IDLE) {
+            //Set Baud
+            dmxPorts[i].USART->BAUDCTRLA = DMX_BAUD_RESET_BSEL;
+            dmxPorts[i].USART->BAUDCTRLB = DMX_BAUD_BSCALE << 4;
 
-        //Send Break Byte
-        UART0.DATA = 0x00;
+            //Send Break Byte
+            dmxPorts[i].USART->DATA = 0x00;
 
-        dmx0state = DMX_START;
+            dmxPorts[i].TX_STATE = DMX_START;
+        }
     }
 }
 
-ISR(USARTD0_TXC_vect) //Transimission complete
-{
-
-    switch(dmx0state) {
+/**
+ * Handle DMX Tx Interrupt
+ */
+void txISR(DMX_t* PORT) {
+    switch(PORT->TX_STATE) {
         case DMX_START:
             //Change Baudrate
-            UART0.BAUDCTRLA = DMX_BAUD_NORMAL_BSEL;
-            UART0.BAUDCTRLB = DMX_BAUD_BSCALE << 4;
+            PORT->USART->BAUDCTRLA = DMX_BAUD_NORMAL_BSEL;
+            PORT->USART->BAUDCTRLB = DMX_BAUD_BSCALE << 4;
 
             //SEND START Byte
-            UART0.DATA = 0x00;
-
-
-            dmx0ch = 0;
-            dmx0state = DMX_RUN;
+            PORT->USART->DATA = 0x00;
 
+            PORT->TX_POSITION = 0;
+            PORT->TX_STATE = DMX_RUN;
         break;
         case DMX_RUN:
-            UART0.DATA = dmxBuffer[0][dmx0ch++];            
+            PORT->USART->DATA = dmxBuffer[PORT->UNIVERSE][PORT->TX_POSITION++];
 
-            if(dmx0ch >= 512) {
-                dmx0state = DMX_IDLE;
+            if(PORT->TX_POSITION >= 512) {
+                PORT->TX_STATE = DMX_IDLE;
             }
         break;
 
     }
 }
+
+ISR(USARTC0_TXC_vect) //Transimission complete
+{
+    txISR(&dmxPorts[0]);
+}
+
+ISR(USARTC1_TXC_vect) //Transimission complete
+{
+    txISR(&dmxPorts[1]);
+}
+
+ISR(USARTD0_TXC_vect) //Transimission complete
+{
+    txISR(&dmxPorts[2]);
+}
+
+ISR(USARTE0_TXC_vect) //Transimission complete
+{
+    txISR(&dmxPorts[3]);
+}

udp.c

@@ -9,11 +9,11 @@
 #define ART_DMX             0x5000
 
 
-static uint8_t eth_type_is_arp_and_my_ip(uint16_t len) {
+/*static uint8_t eth_type_is_arp_and_my_ip(uint16_t len) {
     return len >= 41 && gPB[ETH_TYPE_H_P] == ETHTYPE_ARP_H_V &&
            gPB[ETH_TYPE_L_P] == ETHTYPE_ARP_L_V &&
            memcmp(gPB + ETH_ARP_DST_IP_P, EtherCard::myip, IP_LEN) == 0;
-}
+}*/
 
 void packageLoop(uint16_t len) {
     if (len == 0)