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     int i;
00016 
00017     for (i = 0; i < DMX_SIZE; i ++) {
00018         data_tx[i] = 0;
00019         data_rx[i] = 0;
00020     }
00021 //    mode_tx = DMX_MODE_BEGIN;
00022     mode_tx = DMX_MODE_STOP;
00023     mode_rx = DMX_MODE_BEGIN;
00024     is_recived = 0;
00025     is_sent = 0;
00026 
00027 #if defined(TARGET_LPC1768) || defined(TARGET_LPC2368)
00028     if (p_rx == p10) {
00029       _uart = LPC_UART3;
00030       NVIC_SetPriority(UART3_IRQn, 1);
00031     } else
00032     if (p_rx == p14) {
00033       _uart = (LPC_UART_TypeDef*)LPC_UART1;
00034       NVIC_SetPriority(UART1_IRQn, 1);
00035     } else
00036     if (p_rx == p27) {
00037       _uart = LPC_UART2;
00038       NVIC_SetPriority(UART2_IRQn, 1);
00039     }
00040 #elif defined(TARGET_LPC11U24)
00041     if (p_rx == p10) {
00042       _uart = LPC_USART;
00043       NVIC_SetPriority(UART_IRQn, 1);
00044     }
00045 #elif defined(TARGET_LPC11XX)
00046     if (p_rx == P1_6) {
00047       _uart = (LPC_UART_TypeDef*) UART_0;
00048       NVIC_SetPriority(UART_IRQn, 1);
00049     }
00050     if (p_tx == P1_7) {
00051       _uart = (LPC_UART_TypeDef*) UART_0;
00052       NVIC_SetPriority(UART_IRQn, 1);
00053     }
00054 #endif
00055 
00056     _dmx.baud(250000);
00057     _dmx.format(8, Serial::None, 2);
00058     _dmx.attach(this, &DMX::int_rx, Serial::RxIrq);
00059 
00060 //    timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_BETWEEN);
00061 }
00062 
00063 void DMX::put (int addr, int data) {
00064     if (addr < 0 || addr >= DMX_SIZE) return;
00065     data_tx[addr] = data;
00066 }
00067 
00068 void DMX::put (unsigned char *buf, int addr, int len) {
00069     if (addr < 0 || addr >= DMX_SIZE) return;
00070     if (len > DMX_SIZE - addr) len = DMX_SIZE - addr;
00071     memcpy(&data_tx[addr], buf, len);
00072 }
00073 
00074 int DMX::get (int addr) {
00075     if (addr < 0 || addr >= DMX_SIZE) return -1;
00076     return data_rx[addr];
00077 }
00078 
00079 void DMX::get (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(buf, &data_rx[addr], len);
00083 }
00084 
00085 void DMX::int_timer () {
00086 
00087     switch (mode_tx) {
00088     case DMX_MODE_BEGIN:
00089         // Break Time
00090         timeout01.detach();
00091         _uart->LCR |= (1 << 6);
00092         mode_tx = DMX_MODE_BREAK;
00093         timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_BREAK);
00094         break;
00095 
00096     case DMX_MODE_BREAK:
00097         // Mark After Break
00098         timeout01.detach();
00099         _uart->LCR &= ~(1 << 6);
00100         mode_tx = DMX_MODE_MAB;
00101         timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_MAB);
00102         break;
00103 
00104     case DMX_MODE_MAB:
00105         // Start code
00106         timeout01.detach();
00107         addr_tx = 0;
00108         mode_tx = DMX_MODE_DATA;
00109         _dmx.attach(this, &DMX::int_tx, Serial::TxIrq);
00110 #ifdef DMX_UART_DIRECT
00111         while(!(_uart->LSR & (1<<5)));
00112         _uart->THR = DMX_START_CODE;
00113 #else
00114         _dmx.putc(DMX_START_CODE);
00115 #endif
00116         break;
00117     }
00118 }
00119 
00120 void DMX::int_tx () {
00121     // Data
00122     if (mode_tx == DMX_MODE_DATA) {
00123         if (addr_tx < DMX_SIZE) {
00124 #ifdef DMX_UART_DIRECT
00125             _uart->THR = (uint8_t)data_tx[addr_tx];
00126 #else
00127             _dmx.putc(data_tx[addr_tx]);
00128 #endif
00129             addr_tx ++;
00130         } else {
00131             _dmx.attach(0, Serial::TxIrq);
00132             mode_tx = DMX_MODE_BEGIN;
00133             is_sent = 1;
00134             timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_BETWEEN);
00135         }
00136     }
00137 }
00138 
00139 void DMX::int_rx () {
00140     int flg, dat;
00141 
00142     flg = _uart->LSR;
00143 #ifdef DMX_UART_DIRECT
00144     dat = _uart->RBR;
00145 #else
00146     dat = _dmx.getc();
00147 #endif
00148 
00149     if (flg & ((1 << 7)|(1 << 3)|(1 << 4))) {
00150         // Break Time
00151         if (addr_rx >= 24) {
00152             is_recived = 1;
00153         }
00154         mode_rx = DMX_MODE_BREAK;
00155         return;
00156     }
00157 
00158     if (mode_rx == DMX_MODE_BREAK) {
00159 
00160         // Start Code
00161         if (dat == DMX_START_CODE) {
00162             addr_rx = 0;
00163             mode_rx = DMX_MODE_DATA;
00164         } else {
00165             mode_rx = DMX_MODE_ERROR;
00166         }
00167 
00168     } else
00169     if (mode_rx == DMX_MODE_DATA) {
00170 
00171         // Data
00172         data_rx[addr_rx] = dat;
00173         addr_rx ++;
00174 
00175         if (addr_rx >= DMX_SIZE) {
00176             is_recived = 1;
00177             mode_rx = DMX_MODE_BEGIN;
00178         }
00179     }
00180 }
00181 
00182 void DMX::start () {
00183     if (mode_tx == DMX_MODE_STOP) {
00184         mode_tx = DMX_MODE_BEGIN;
00185         is_sent = 0;
00186         timeout01.attach_us(this, &DMX::int_timer, DMX_TIME_BETWEEN);
00187     }
00188 }
00189 
00190 void DMX::stop () {
00191     _dmx.attach(0, Serial::TxIrq);
00192     timeout01.detach();
00193     mode_tx = DMX_MODE_STOP;
00194 }