DMX.cpp

00001 /*
00002  * DMX512 send/recv library
00003  * Copyright (c) 2013 Hiroshi Suga
00004  * Released under the MIT License: http://mbed.org/license/mit
00005  */
00006 
00007 /** @file
00008  * @brief DMX512 send/recv
00009  */
00010 
00011 #include "mbed.h"
00012 #include "DMX.h"
00013 
00014 DMX::DMX (PinName p_tx, PinName p_rx) : _dmx(p_tx, p_rx) {
00015 
00016     clear();
00017 //    mode_tx = DMX_MODE_BEGIN;
00018     mode_tx = DMX_MODE_STOP;
00019     mode_rx = DMX_MODE_BEGIN;
00020     is_recived = 0;
00021     is_sent = 0;
00022 
00023 #if defined(TARGET_LPC1768) || defined(TARGET_LPC2368)
00024     if (p_rx == P0_3) {
00025       _uart = (LPC_UART_TypeDef*)LPC_UART0;
00026       NVIC_SetPriority(UART0_IRQn, 1);
00027     } else
00028     if (p_rx == p14) {
00029       _uart = (LPC_UART_TypeDef*)LPC_UART1;
00030       NVIC_SetPriority(UART1_IRQn, 1);
00031     } else
00032     if (p_rx == p27) {
00033       _uart = LPC_UART2;
00034       NVIC_SetPriority(UART2_IRQn, 1);
00035     } else
00036     if (p_rx == p10) {
00037       _uart = LPC_UART3;
00038       NVIC_SetPriority(UART3_IRQn, 1);
00039     }
00040 #elif defined(TARGET_LPC4088)
00041     if (p_rx == p10) {
00042       _uart = LPC_UART3;
00043       NVIC_SetPriority(UART3_IRQn, 1);
00044     } else
00045     if (p_rx == p31) {
00046       _uart = (LPC_UART_TypeDef*)LPC_UART4;
00047       NVIC_SetPriority(UART4_IRQn, 1);
00048     }
00049 #elif defined(TARGET_LPC11UXX)
00050     if (p_rx == p10) {
00051       _uart = LPC_USART;
00052       NVIC_SetPriority(UART_IRQn, 1);
00053     }
00054 #elif defined(TARGET_LPC11XX)
00055     // LPC1114 support by Stanly Chen
00056     if (p_rx == P1_6) {
00057       _uart = (LPC_UART_TypeDef*)UART_0;
00058       NVIC_SetPriority(UART_IRQn, 1);
00059     }
00060 #elif defined(TARGET_LPC13XX)
00061     if (p_rx == P0_18 || p_rx == P1_26) {
00062       _uart = LPC_USART;
00063       NVIC_SetPriority(USART_IRQn, 1);
00064     }
00065 #endif
00066 
00067     _dmx.baud(250000);
00068     _dmx.format(8, Serial::None, 2);
00069     _dmx.attach(this, &DMX::int_rx, Serial::RxIrq);
00070 
00071 //    timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_BETWEEN);
00072 }
00073 
00074 void DMX::put (int addr, int data) {
00075     if (addr < 0 || addr >= DMX_SIZE) return;
00076     data_tx[addr] = data;
00077 }
00078 
00079 void DMX::put (unsigned char *buf, int addr, int len) {
00080     if (addr < 0 || addr >= DMX_SIZE) return;
00081     if (len > DMX_SIZE - addr) len = DMX_SIZE - addr;
00082     memcpy(&data_tx[addr], buf, len);
00083 }
00084 
00085 int DMX::get (int addr) {
00086     if (addr < 0 || addr >= DMX_SIZE) return -1;
00087     return data_rx[addr];
00088 }
00089 
00090 void DMX::get (unsigned char *buf, int addr, int len) {
00091     if (addr < 0 || addr >= DMX_SIZE) return;
00092     if (len > DMX_SIZE - addr) len = DMX_SIZE - addr;
00093     memcpy(buf, &data_rx[addr], len);
00094 }
00095 
00096 void DMX::int_timer () {
00097 
00098     switch (mode_tx) {
00099     case DMX_MODE_BEGIN:
00100         // Break Time
00101         timeout01.detach();
00102         _uart->LCR |= (1 << 6);
00103         mode_tx = DMX_MODE_BREAK;
00104         timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_BREAK);
00105         break;
00106 
00107     case DMX_MODE_BREAK:
00108         // Mark After Break
00109         timeout01.detach();
00110         _uart->LCR &= ~(1 << 6);
00111         mode_tx = DMX_MODE_MAB;
00112         timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_MAB);
00113         break;
00114 
00115     case DMX_MODE_MAB:
00116         // Start code
00117         timeout01.detach();
00118         addr_tx = 0;
00119         mode_tx = DMX_MODE_DATA;
00120         _dmx.attach(this, &DMX::int_tx, Serial::TxIrq);
00121 #ifdef DMX_UART_DIRECT
00122         while(!(_uart->LSR & (1<<5)));
00123         _uart->THR = DMX_START_CODE;
00124 #else
00125         _dmx.putc(DMX_START_CODE);
00126 #endif
00127         break;
00128     }
00129 }
00130 
00131 void DMX::int_tx () {
00132     // Data
00133     if (mode_tx == DMX_MODE_DATA) {
00134         if (addr_tx < DMX_SIZE) {
00135 #ifdef DMX_UART_DIRECT
00136             _uart->THR = (uint8_t)data_tx[addr_tx];
00137 #else
00138             _dmx.putc(data_tx[addr_tx]);
00139 #endif
00140             addr_tx ++;
00141         } else {
00142             _dmx.attach(0, Serial::TxIrq);
00143             mode_tx = DMX_MODE_BEGIN;
00144             is_sent = 1;
00145             timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_BETWEEN);
00146         }
00147     }
00148 }
00149 
00150 void DMX::int_rx () {
00151     int flg, dat;
00152 
00153     flg = _uart->LSR;
00154 #ifdef DMX_UART_DIRECT
00155     dat = _uart->RBR;
00156 #else
00157     dat = _dmx.getc();
00158 #endif
00159 
00160     if (flg & ((1 << 7)|(1 << 3)|(1 << 4))) {
00161         // Break Time
00162         if (addr_rx >= 24 && mode_rx == DMX_MODE_DATA) {
00163             is_recived = 1;
00164         }
00165         mode_rx = DMX_MODE_BREAK;
00166         return;
00167     }
00168 
00169     if (mode_rx == DMX_MODE_BREAK) {
00170 
00171         // Start Code
00172         if (dat == DMX_START_CODE) {
00173             addr_rx = 0;
00174             mode_rx = DMX_MODE_DATA;
00175         } else {
00176             mode_rx = DMX_MODE_ERROR;
00177         }
00178 
00179     } else
00180     if (mode_rx == DMX_MODE_DATA) {
00181 
00182         // Data
00183         data_rx[addr_rx] = dat;
00184         addr_rx ++;
00185 
00186         if (addr_rx >= DMX_SIZE) {
00187             is_recived = 1;
00188             mode_rx = DMX_MODE_BEGIN;
00189         }
00190     }
00191 }
00192 
00193 void DMX::start () {
00194     if (mode_tx == DMX_MODE_STOP) {
00195         mode_tx = DMX_MODE_BEGIN;
00196         is_sent = 0;
00197         timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_BETWEEN);
00198     }
00199 }
00200 
00201 void DMX::stop () {
00202     _dmx.attach(0, Serial::TxIrq);
00203     timeout01.detach();
00204     mode_tx = DMX_MODE_STOP;
00205 }
00206 
00207 void DMX::clear () {
00208     int i;
00209 
00210     for (i = 0; i < DMX_SIZE; i ++) {
00211         data_tx[i] = 0;
00212         data_rx[i] = 0;
00213     }
00214 }