如何利用DMX-512協(xié)議實(shí)現(xiàn)測(cè)試儀控制器的設(shè)計(jì)

通過(guò)DMX-512協(xié)議進(jìn)行測(cè)試和燈光顯示的控制工具，非常適合對(duì)固定或臨時(shí)照明裝置進(jìn)行快速測(cè)試。該項(xiàng)目源于需要有一個(gè)用于快速測(cè)試照明裝置的便攜式系統(tǒng)，而無(wú)需在外部、敵對(duì)或難以訪問(wèn)的環(huán)境中安裝照明控制臺(tái)、接口或計(jì)算機(jī)。

硬件

4x20 LCD 背光和對(duì)比度由軟件控制

USB、電池或外接電源供電

導(dǎo)航鍵盤(pán)

4x4 鍵盤(pán)

模擬控制電位器

開(kāi)關(guān)機(jī)（不適用于USB電源）

來(lái)自接線端子、XLR 3 針和 5 針 XLR 的 DMX 輸出

輸出狀態(tài) LED DMX

Proteus V7.7 SP2 中的模擬

Proteus v8.0 SP1 中的原理圖和 PCB

示意圖

印刷電路板

仿真器

使用酚醛板，加強(qiáng)銅砂紙水，循環(huán)變薄

使用 Proteus 發(fā)送文件以打印印前醋酸鹽底片（文件中有 PDF）

感光膠片的用途和方法

使用紙覆膜機(jī)薄膜完美粘附 pcb

在板和醋酸鹽之間加一點(diǎn)水，使其不會(huì)移動(dòng)并施加紫外線

應(yīng)用氯化鐵清潔并準(zhǔn)備好

焊接元件

剝?nèi)?a target="_blank">電位器導(dǎo)軌

酚醛鉆孔板放置電位器

我們轉(zhuǎn)動(dòng)旋鈕并將引腳焊接到焊盤(pán)上

將它們放在頂部焊接頂部，用砂紙和水切割的銷(xiāo)釘上方去除多余的

我們添加膠帶雙面膠帶將鍵盤(pán)連接到板上

在這里有一個(gè)細(xì)節(jié)，頭部被鍵盤(pán)的彎曲堵塞，切口

焊接鍵盤(pán)下方的接頭并向后彎曲以橫向連接鍵盤(pán)

把鍵盤(pán)放在液晶板上，這里有一個(gè)細(xì)節(jié)，MAX485的底座和鍵盤(pán)很貼合

在 Arduino Mega 的 USB 端口上添加一些膠帶，以防止軌道之間發(fā)生短路

所有已安裝的組件

我們?cè)?Arduino 上加載固件

代碼

// ***************************************************************************************************************************
// ***************************************************************************************************************************
// ** **
// ** Arduino DMX-512 Tester Controller **
// ** **
// ** - Firmware v0.6 **
// ** - Hardware v0.0 - v0.2 **
// ** **
// ** - Compilado en Arduino IDE v1.0.6 **
// ** http://www.arduino.cc/en/Main/OldSoftwareReleases **
// ** - Compilado para Arduino Mega 2560 R3 **
// ** http://www.arduino.cc/en/Main/ArduinoBoardMega2560 **
// ** - Libreria Arduino cuatro universos DMX v0.3 - Deskontrol.net **
// ** http://www.deskontrol.net/blog/libreria-arduino-cuatro-universos-dmx/) **
// ** - Libreria LCD v1.2.1 - Francisco Malpartida **
// ** https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/Home **
// ** - Simulacion en Proteus v7.7 SP2 **
// ** - Simulacion en Proteus de Arduino - Microcontrolandos **
// ** http://microcontrolandos.blogspot.mx/2012/12/arduino-componentes-para-o-proteus.html **
// ** **
// ** Autor: **
// ** **
// ** Daniel Roberto Becerril Angeles **
// ** daniel3514@gmail.com ** **
// ** https://github.com/daniel3514/Arduino-DMX-512-Tester-Controller/ **
// ** **
// ** Licenciamiento: **
// ** **
// ** GNU General Pubic Licence Version 3 **
// ** https://www.gnu.org/copyleft/gpl.html **
// ** **
// ***************************************************************************************************************************
// ***************************************************************************************************************************
null
// Librerias
#include // libreria para LCD
#include
#include
#include
#include // libreria DMX 4 universos deskontrol four universes DMX library - http://www.deskontrol.net/blog

// DMX Library
#define DMX512 (0) // (250 kbaud - 2 to 512 channels) Standard USITT DMX-512
//#define DMX1024 (1) // (500 kbaud - 2 to 1024 channels) Completely non standard - TESTED ok
//#define DMX2048 (2) // (1000 kbaud - 2 to 2048 channels) called by manufacturers DMX1000K, DMX 4x or DMX 1M ???
null
// Puertos, variables
// DMX
//int DMX_Data_Flux = 2; // control de flujo de datos para dmx, 0 por default
int DMX_Values [515]; // array de valores actuales DMX
int Canal_Actual = 1;
// Botones cursor
int Boton_Up = 51;
int Boton_Down = 45;
int Boton_Left = 53;
int Boton_Right = 49;
int Boton_Center = 47;
byte LCD_Col_Pos = 0; // posicion en tiempo real de lcd
byte LCD_Row_Pos = 0; // posicion en tiempo real de lcd
byte Cursor_Conf[4][20] = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, // config de posiciones de lcd Col Row
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
// Botones Numerico Array
int Boton_Array_1 = 36;
int Boton_Array_2 = 34;
int Boton_Array_3 = 32;
int Boton_Array_4 = 30;
int Boton_Array_A = 44;
int Boton_Array_B = 42;
int Boton_Array_C = 40;
int Boton_Array_D = 38;
byte Boton_Calc = 17; // valor calculado # E * F, 17 sin valor calculado
byte Num_Col_Pos = 0; // posicion en tiempo real de lcd
byte Num_Row_Pos = 0; // posicion en tiempo real de lcd
int Num_Val = 0; // valor generado al calculo
long Boton_Delay_Teclado = 100; // delay de lectura de boton
// Potenciometro
int Pot = A15; // entrada de potenciometro
// LCD
int LCD_RS = 8; // puertos de conexion de LCD
int LCD_E = 9;
int LCD_D4 = 10;
int LCD_D5 = 11;
int LCD_D6 = 12;
int LCD_D7 = 13;
LiquidCrystal lcd(LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7); //LCD setup
int Back_Light_PWM = 3; // salida para PWM de Back Light de LCD
int Contrast_PWM = 4; // salida para pwm de contraste de LCD
byte Back_Light_On_Off = 0; // saber si esta encendida o apagada
null
void setup()
{
// DMX
//pinMode(DMX_Data_Flux, OUTPUT);
// Botones cursor
pinMode(Boton_Up, INPUT_PULLUP);
pinMode(Boton_Down, INPUT_PULLUP);
pinMode(Boton_Left, INPUT_PULLUP);
pinMode(Boton_Right, INPUT_PULLUP);
pinMode(Boton_Center, INPUT_PULLUP);
// Botones numerico
pinMode(Boton_Array_1, OUTPUT);
pinMode(Boton_Array_2, OUTPUT);
pinMode(Boton_Array_3, OUTPUT);
pinMode(Boton_Array_4, OUTPUT);
pinMode(Boton_Array_A, INPUT_PULLUP);
pinMode(Boton_Array_B, INPUT_PULLUP);
pinMode(Boton_Array_C, INPUT_PULLUP);
pinMode(Boton_Array_D, INPUT_PULLUP);
digitalWrite(Boton_Array_1, HIGH);
digitalWrite(Boton_Array_2, HIGH);
digitalWrite(Boton_Array_3, HIGH);
digitalWrite(Boton_Array_4, HIGH);
// LCD
pinMode(LCD_RS, OUTPUT);
pinMode(LCD_E, OUTPUT);
pinMode(LCD_D7, OUTPUT);
pinMode(LCD_D6, OUTPUT);
pinMode(LCD_D5, OUTPUT);
pinMode(LCD_D4, OUTPUT);
pinMode(Back_Light_PWM, OUTPUT);
lcd.begin(20, 4); //tama?o de LCD
// DMX
ArduinoDmx0.set_tx_address(1); // poner aqui la direccion de inicio de DMX
ArduinoDmx0.set_tx_channels(512); // poner aqui el numero de canales a transmitir
ArduinoDmx0.init_tx(DMX512); // iniciar transmision universo 0, modo estandar DMX512
// no conectados
pinMode(5, OUTPUT);
digitalWrite(5, LOW);
pinMode(6, OUTPUT);
digitalWrite(6, LOW);
pinMode(7, OUTPUT);
digitalWrite(7, LOW);
pinMode(22, OUTPUT);
digitalWrite(22, LOW);
pinMode(23, OUTPUT);
digitalWrite(23, LOW);
pinMode(24, OUTPUT);
digitalWrite(24, LOW);
pinMode(25, OUTPUT);
digitalWrite(25, LOW);
pinMode(26, OUTPUT);
digitalWrite(26, LOW);
pinMode(27, OUTPUT);
digitalWrite(27, LOW);
pinMode(28, OUTPUT);
digitalWrite(28, LOW);
pinMode(29, OUTPUT);
digitalWrite(29, LOW);
pinMode(31, OUTPUT);
digitalWrite(31, LOW);
pinMode(33, OUTPUT);
digitalWrite(33, LOW);
pinMode(35, OUTPUT);
digitalWrite(35, LOW);
pinMode(37, OUTPUT);
digitalWrite(37, LOW);
pinMode(39, OUTPUT);
digitalWrite(39, LOW);
pinMode(41, OUTPUT);
digitalWrite(41, LOW);
pinMode(43, OUTPUT);
digitalWrite(43, LOW);
pinMode(46, OUTPUT);
digitalWrite(46, LOW);
pinMode(48, OUTPUT);
digitalWrite(48, LOW);
pinMode(50, OUTPUT);
digitalWrite(50, LOW);
pinMode(52, OUTPUT);
digitalWrite(52, LOW);
pinMode(A0, OUTPUT);
digitalWrite(A0, LOW);
pinMode(A1, OUTPUT);
digitalWrite(A1, LOW);
pinMode(A2, OUTPUT);
digitalWrite(A2, LOW);
pinMode(A3, OUTPUT);
digitalWrite(A3, LOW);
pinMode(A4, OUTPUT);
digitalWrite(A4, LOW);
pinMode(A5, OUTPUT);
digitalWrite(A5, LOW);
pinMode(A6, OUTPUT);
digitalWrite(A6, LOW);
pinMode(A7, OUTPUT);
digitalWrite(A7, LOW);
pinMode(A8, OUTPUT);
digitalWrite(A8, LOW);
pinMode(A9, OUTPUT);
digitalWrite(A9, LOW);
pinMode(A10, OUTPUT);
digitalWrite(A10, LOW);
pinMode(A11, OUTPUT);
digitalWrite(A11, LOW);
pinMode(A12, OUTPUT);
digitalWrite(A12, LOW);
pinMode(A13, OUTPUT);
digitalWrite(A13, LOW);
pinMode(A14, OUTPUT);
digitalWrite(A14, LOW);
}
null
void loop()
{
digitalWrite(2, HIGH); // max 485 como salida
Back_Light_Init();
Contrast_Init();
GUI_About();
GUI_Memory_Init();
}
null
void Back_Light_Init()
{
// ultimo estado del back light
byte Back_Light_Value = EEPROM.read(513);
analogWrite(Back_Light_PWM, Back_Light_Value);
if (Back_Light_Value == 0)
{
Back_Light_On_Off = 0;
}
if (Back_Light_Value > 0)
{
Back_Light_On_Off = 1;
}
}

void Contrast_Init()
{
// ultimo estado del comtrast
byte Contrast_Value = EEPROM.read(514);
analogWrite(Contrast_PWM, Contrast_Value);
}

void Back_Light_En()
{
byte Back_Light_Value = EEPROM.read(513); // lectura del ultimo valor desde la eeprom, 513 es donde se guarda el valor
// encender
if (Back_Light_On_Off == 0) // si esta apagada encenderla
{
if (Back_Light_Value == 0) // la encendemos de todos modos
{
analogWrite(Back_Light_PWM, 127); // aqui el valor a encender en el caso que se haya establecido apagado el back light
}
if (Back_Light_Value > 0)
{
analogWrite(Back_Light_PWM, Back_Light_Value); // encender con el valor de la eeprom
}
Back_Light_On_Off = 1;
goto salida;
}
// apagar
if (Back_Light_On_Off == 1) // si esta encendida apagarla
{
analogWrite(Back_Light_PWM, 0);
Back_Light_On_Off = 0;
}
salida:
{
delay(300); // para impedir repeticion del comando
}
}

void GUI_About()
{
byte Firm_Ver_Ent = 0;
byte Firm_Ver_Dec = 6;
byte Hard_Ver_Ent = 0;
byte Hard_Ver_Dec = 0;
byte ID = 20;
lcd.clear ();
lcd.noBlink(); // ocultar cursor
lcd.setCursor(0, 0);
for(int numero = 0; numero <= 512; numero ++)?? ?// efecto binario en lcd
{
lcd.print (numero, BIN);
}
lcd.clear ();
lcd.setCursor(0, 3);
lcd.print("http://goo.gl/kdYlj7");
lcd.setCursor(3, 0);
lcd.print("Arduino DMX-512");
lcd.setCursor(1, 1);
lcd.print("Tester & Controller");
// Firmware
lcd.setCursor(0, 2);
lcd.print("Firm v");
lcd.print(Firm_Ver_Ent);
lcd.print(".");
lcd.print(Firm_Ver_Dec);
// Hardware
lcd.setCursor(11, 2);
lcd.print("Hard v");
lcd.print(Hard_Ver_Ent);
lcd.print(".");
lcd.print(Hard_Ver_Dec);
delay(2000); //retardo de muestra de mensaje
}
null
void Multi_Matrix(int inicial)
{
// dibujar banco
Numerico_Write (inicial, 13, 0);
Numerico_Write (inicial + 14, 17, 0);
// matrix 1
Numerico_Write (DMX_Values[inicial], 1, 1);
Numerico_Write (DMX_Values[inicial + 1], 5, 1);
Numerico_Write (DMX_Values[inicial + 2], 9, 1);
Numerico_Write (DMX_Values[inicial + 3], 13, 1);
Numerico_Write (DMX_Values[inicial + 4], 17, 1);
// matrix 2
Numerico_Write (DMX_Values[inicial + 5], 1, 2);
Numerico_Write (DMX_Values[inicial + 6], 5, 2);
Numerico_Write (DMX_Values[inicial + 7], 9, 2);
Numerico_Write (DMX_Values[inicial + 8], 13, 2);
Numerico_Write (DMX_Values[inicial + 9], 17, 2);
// matrix 3
Numerico_Write (DMX_Values[inicial + 10], 1, 3);
Numerico_Write (DMX_Values[inicial + 11], 5, 3);
Numerico_Write (DMX_Values[inicial + 12], 9, 3);
Numerico_Write (DMX_Values[inicial + 13], 13, 3);
Numerico_Write (DMX_Values[inicial + 14], 17, 3);
}

void GUI_Control_Matrix()
{
int Inicial = 1;
Canal_Actual = 1;
inicio:
lcd.clear();
lcd.setCursor (0, 0);
lcd.print("c--- Mem Ctr -");
Multi_Matrix (Inicial);
// Cursor
LCD_Col_Pos = 12; // posicion de cursor
LCD_Row_Pos = 0; // posicion e cursor
// configuracion de cursor
Cursor_Conf_Clear(); // limpiar array
// Row 0
Cursor_Conf[0][4] = 1; // Memory
Cursor_Conf[0][8] = 1; // Unit
Cursor_Conf[0][12] = 1; // Banco Inicial
Cursor_Conf[0][16] = 1; // Banco Final
// Row 1
Cursor_Conf[1][0] = 1;
Cursor_Conf[1][4] = 1;
Cursor_Conf[1][8] = 1;
Cursor_Conf[1][12] = 1;
Cursor_Conf[1][16] = 1;
// Row 2
Cursor_Conf[2][0] = 1;
Cursor_Conf[2][4] = 1;
Cursor_Conf[2][8] = 1;
Cursor_Conf[2][12] = 1;
Cursor_Conf[2][16] = 1;
// Row 3
Cursor_Conf[3][0] = 1;
Cursor_Conf[3][4] = 1;
Cursor_Conf[3][8] = 1;
Cursor_Conf[3][12] = 1;
Cursor_Conf[3][16] = 1;
// navegar
Banco:
GUI_Navegar(1, Inicial);
// Acciones
// Memory
if (LCD_Col_Pos == 4 && LCD_Row_Pos == 0)
{
GUI_Memory();
goto inicio;
}
// Control
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 0)
{
GUI_Control_Options();
goto inicio;
}
// Banco Inicial
if (LCD_Col_Pos == 12 && LCD_Row_Pos == 0)
{
Num_Row_Pos = 0;
Num_Col_Pos = 13;
Num_Val = Inicial; // para dejar el numero que estaba si no se cambia
Numerico_Calc(0);
if (Num_Val > 498) // limite de matriz
{
Num_Val = 498;
}
if (Num_Val == 0) // limite de matriz
{
Num_Val = 1;
}
Inicial = Num_Val;
goto inicio;
}
// Banco Final
if (LCD_Col_Pos == 16 && LCD_Row_Pos == 0)
{
Num_Row_Pos = 0;
Num_Col_Pos = 17;
if (Inicial == 1)
Num_Val = 15;
else
Num_Val = Inicial - 14; // para dejar el numero que estaba si no se cambia
Numerico_Calc(0);
if (Num_Val > 512) // limite de matriz
{
Inicial = 498;
goto inicio;
}
if (Num_Val < 15)?? ??? ?// limite de matriz
{
Inicial = 1;
goto inicio;
}
Inicial = Num_Val - 14;
goto inicio;
}
// posicion 1
if (LCD_Col_Pos == 0 && LCD_Row_Pos == 1)
{
Canal_Actual = Inicial;
goto Salida_DMX;
}
// posicion 2
if (LCD_Col_Pos == 4 && LCD_Row_Pos == 1)
{
Canal_Actual = Inicial + 1;
goto Salida_DMX;
}
// posicion 3
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 1)
{
Canal_Actual = Inicial + 2;
goto Salida_DMX;
}
// posicion 4
if (LCD_Col_Pos == 12 && LCD_Row_Pos == 1)
{
Canal_Actual = Inicial + 3;
goto Salida_DMX;
}
// posicion 5
if (LCD_Col_Pos == 16 && LCD_Row_Pos == 1)
{
Canal_Actual = Inicial + 4;
goto Salida_DMX;
}
// posicion 6
if (LCD_Col_Pos == 0 && LCD_Row_Pos == 2)
{
Canal_Actual = Inicial + 5;
goto Salida_DMX;
}
// posicion 7
if (LCD_Col_Pos == 4 && LCD_Row_Pos == 2)
{
Canal_Actual = Inicial + 6;
goto Salida_DMX;
}
// posicion 8
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 2)
{
Canal_Actual = Inicial + 7;
goto Salida_DMX;
}
// posicion 9
if (LCD_Col_Pos == 12 && LCD_Row_Pos == 2)
{
Canal_Actual = Inicial + 8;
goto Salida_DMX;
}
// posicion 10
if (LCD_Col_Pos == 16 && LCD_Row_Pos == 2)
{
Canal_Actual = Inicial + 9;
goto Salida_DMX;
}
// posicion 11
if (LCD_Col_Pos == 0 && LCD_Row_Pos == 3)
{
Canal_Actual = Inicial + 10;
goto Salida_DMX;
}
// posicion 12
if (LCD_Col_Pos == 4 && LCD_Row_Pos == 3)
{
Canal_Actual = Inicial + 11;
goto Salida_DMX;
}
// posicion 13
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 3)
{
Canal_Actual = Inicial + 12;
goto Salida_DMX;
}
// posicion 14
if (LCD_Col_Pos == 12 && LCD_Row_Pos == 3)
{
Canal_Actual = Inicial + 13;
goto Salida_DMX;
}
// posicion 15
if (LCD_Col_Pos == 16 && LCD_Row_Pos == 3)
{
Canal_Actual = Inicial + 14;
goto Salida_DMX;
}
Salida_DMX:
Num_Row_Pos = LCD_Row_Pos;
Num_Col_Pos = LCD_Col_Pos + 1;
Num_Val = DMX_Values[Canal_Actual]; // para dejar el numero que estaba si no se cambia
Numerico_Calc(1);
if (Num_Val == 612) // ubicar
{
Ubicar();
Num_Col_Pos = Num_Col_Pos - 4;
}
if (Num_Val == 712) // analogo
{
Analog_Read_DMX(Num_Col_Pos - 2, Num_Row_Pos);
Num_Col_Pos = Num_Col_Pos - 4;
goto Banco;
}
if (Num_Val > 255)
{
Num_Val = 255;
Numerico_Write (255, Num_Col_Pos + 2, Num_Row_Pos);
}
ArduinoDmx0.TxBuffer[Canal_Actual - 1] = Num_Val;
DMX_Values[Canal_Actual] = Num_Val;
goto Banco;
}

void Cursor_Conf_Clear()
{
for (byte Conteo_Col = 0; Conteo_Col <= 19; Conteo_Col ++)
{
for (byte Conteo_Row = 0; Conteo_Row <= 3; Conteo_Row ++)
{
Cursor_Conf[Conteo_Row][Conteo_Col] = 0;
}
}
}

void GUI_Navegar(byte matrix, int banco)
{
long Boton_Delay_Cursor = 300; // delay de lectura de boton
byte LCD_Col_Pos_Ant; // saber el estado anterior para borrar cursor
byte LCD_Row_Pos_Ant; // saber el estado anterior para borrar cursor
// guardar valor anterior de row col
LCD_Col_Pos_Ant = LCD_Col_Pos;
LCD_Row_Pos_Ant = LCD_Row_Pos;
// Dibujar cursor
lcd.setCursor (LCD_Col_Pos, LCD_Row_Pos);
lcd.print(">");
// navegacion
Dibujar:
byte Dibujar_Cursor = 0; // saber si dibujar cursor para evitar repeticiones en lcd, 0 no dibujar, 1 dibujar >, 2 dibujar +
// LCD Back Light *
digitalWrite(Boton_Array_1, LOW); // lectura linea 1
if (digitalRead(Boton_Array_D) == LOW)
{
delay(Boton_Delay_Teclado);
Back_Light_En();
}
digitalWrite(Boton_Array_1, HIGH); // lectura linea 1
// Left
if (digitalRead(Boton_Left) == LOW)
{
delay (Boton_Delay_Cursor);
byte Salida_Left = 0;
byte LCD_Col_Pos_Temp = 0;
LCD_Col_Pos_Temp = LCD_Col_Pos;
while (Salida_Left == 0)
{
if (LCD_Col_Pos_Temp == 0)
{
LCD_Col_Pos_Temp = 20;
}
LCD_Col_Pos_Temp = LCD_Col_Pos_Temp - 1;
if (Cursor_Conf[LCD_Row_Pos][LCD_Col_Pos_Temp] == 1)
{
LCD_Col_Pos = LCD_Col_Pos_Temp;
Dibujar_Cursor = 1;
Salida_Left = 1;
}
}
goto Salida;
}
// Right
if (digitalRead(Boton_Right) == LOW)
{
delay(Boton_Delay_Cursor);
byte Salida_Right = 0;
byte LCD_Col_Pos_Temp = 0;
LCD_Col_Pos_Temp = LCD_Col_Pos;
while (Salida_Right == 0)
{
LCD_Col_Pos_Temp = LCD_Col_Pos_Temp + 1;
if (LCD_Col_Pos_Temp >= 20)
{
LCD_Col_Pos_Temp = 0; // regresar al cero
}
if (Cursor_Conf[LCD_Row_Pos][LCD_Col_Pos_Temp] == 1)
{
LCD_Col_Pos = LCD_Col_Pos_Temp;
Dibujar_Cursor = 1;
Salida_Right = 1;
}
}
goto Salida;
}
// Down
if (digitalRead(Boton_Down) == LOW)
{
delay(Boton_Delay_Cursor);
byte Salida_Down = 0;
byte LCD_Row_Pos_Temp = 0;
LCD_Row_Pos_Temp = LCD_Row_Pos;
while (Salida_Down == 0)
{
LCD_Row_Pos_Temp = LCD_Row_Pos_Temp + 1;
if (LCD_Row_Pos_Temp >= 4)
{
LCD_Row_Pos_Temp = 0; // regresar al cero
}
if (Cursor_Conf[LCD_Row_Pos_Temp][LCD_Col_Pos] == 1)
{
LCD_Row_Pos = LCD_Row_Pos_Temp;
Dibujar_Cursor = 1;
Salida_Down = 1;
}
}
goto Salida;
}
// Up
if (digitalRead(Boton_Up) == LOW)
{
delay(Boton_Delay_Cursor);
byte Salida_Up = 0;
byte LCD_Row_Pos_Temp;
LCD_Row_Pos_Temp = LCD_Row_Pos;
while (Salida_Up == 0)
{
if (LCD_Row_Pos_Temp <= 0)
{
LCD_Row_Pos_Temp = 4;
}
LCD_Row_Pos_Temp = LCD_Row_Pos_Temp - 1;
if (Cursor_Conf[LCD_Row_Pos_Temp][LCD_Col_Pos] == 1)
{
Dibujar_Cursor = 1;
LCD_Row_Pos = LCD_Row_Pos_Temp;
Salida_Up = 1;
}
}
goto Salida;
}
// Center
if (digitalRead(Boton_Center) == LOW)
{
delay(Boton_Delay_Cursor);
byte Salida_Center = 0;
while (Salida_Center == 0)
{
if (Cursor_Conf[LCD_Row_Pos][LCD_Col_Pos] == 1)
{
Dibujar_Cursor = 2; // dibujar +
Salida_Center = 1;
}
}
}
Salida:
// Dibujar Cursor
if (Dibujar_Cursor > 0)
{
if (Dibujar_Cursor == 1)
{
// borra el anterior
lcd.setCursor (LCD_Col_Pos_Ant, LCD_Row_Pos_Ant);
lcd.print(" ");
// escribir >
lcd.setCursor (LCD_Col_Pos, LCD_Row_Pos);
lcd.print(">");
// matrix print posicion
if (matrix == 1)
{
// banco inicial
if (LCD_Col_Pos == 12 && LCD_Row_Pos == 0)
{
lcd.setCursor(1, 0);
lcd.print("---");
goto salida;
}
// banco final
if (LCD_Col_Pos == 16 && LCD_Row_Pos == 0)
{
lcd.setCursor(1, 0);
lcd.print("---");
goto salir;
}
// Memory
if (LCD_Col_Pos == 4 && LCD_Row_Pos == 0)
{
lcd.setCursor(1, 0);
lcd.print("---");
goto salida;
}
// Unitary
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 0)
{
lcd.setCursor(1, 0);
lcd.print("---");
goto salida;
}
// banco 1
if (LCD_Col_Pos == 0 && LCD_Row_Pos == 1)
{
Numerico_Write (banco, 1, 0);
goto salida;
}
// banco 2
if (LCD_Col_Pos == 4 && LCD_Row_Pos == 1)
{
Numerico_Write (banco + 1, 1, 0);
goto salida;
}
// banco 3
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 1)
{
Numerico_Write (banco + 2, 1, 0);
goto salida;
}
// banco 4
if (LCD_Col_Pos == 12 && LCD_Row_Pos == 1)
{
Numerico_Write (banco + 3, 1, 0);
goto salida;
}
// banco 5
if (LCD_Col_Pos == 16 && LCD_Row_Pos == 1)
{
Numerico_Write (banco + 4, 1, 0);
goto salida;
}
// banco 6
if (LCD_Col_Pos == 0 && LCD_Row_Pos == 2)
{
Numerico_Write (banco + 5, 1, 0);
goto salida;
}
// banco 7
if (LCD_Col_Pos == 4 && LCD_Row_Pos == 2)
{
Numerico_Write (banco + 6, 1, 0);
goto salida;
}
// banco 8
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 2)
{
Numerico_Write (banco + 7, 1, 0);
goto salida;
}
// banco 9
if (LCD_Col_Pos == 12 && LCD_Row_Pos == 2)
{
Numerico_Write (banco + 8, 1, 0);
goto salida;
}
// banco 10
if (LCD_Col_Pos == 16 && LCD_Row_Pos == 2)
{
Numerico_Write (banco + 9, 1, 0);
goto salida;
}
// banco 11
if (LCD_Col_Pos == 0 && LCD_Row_Pos == 3)
{
Numerico_Write (banco + 10, 1, 0);
goto salida;
}
// banco 12
if (LCD_Col_Pos == 4 && LCD_Row_Pos == 3)
{
Numerico_Write (banco + 11, 1, 0);
goto salida;
}
// banco 13
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 3)
{
Numerico_Write (banco + 12, 1, 0);
goto salida;
}
// banco 14
if (LCD_Col_Pos == 12 && LCD_Row_Pos == 3)
{
Numerico_Write (banco + 13, 1, 0);
goto salida;
}
// banco 15
if (LCD_Col_Pos == 16 && LCD_Row_Pos == 3)
{
Numerico_Write (banco + 14, 1, 0);
goto salida;
}
// escribir guion de bancos
salida:
lcd.setCursor(16, 0);
lcd.print("-");
salir:
{}
}
}
else
{
// escribir +
lcd.setCursor (LCD_Col_Pos, LCD_Row_Pos);
lcd.print("+");
}

//salida
LCD_Col_Pos_Ant = LCD_Col_Pos;
LCD_Row_Pos_Ant = LCD_Row_Pos;
if (Dibujar_Cursor == 2)
{
goto Salir;
}
else
{
Dibujar_Cursor = 0;
}
}
goto Dibujar;
Salir: {}
}
null
void GUI_Memory_Init()
{
lcd.clear ();
// Texto
lcd.setCursor (0, 0);
lcd.print("Initial Memory:");
lcd.setCursor (2, 2);
lcd.print("Empty");
lcd.setCursor (9, 2);
lcd.print("Load");
lcd.setCursor (15, 2);
lcd.print("Clear");
// Cursor
LCD_Col_Pos = 1; // posicion de cursor
LCD_Row_Pos = 2;
// configuracion de cursor
Cursor_Conf_Clear(); // limpiar array
// Acciones
Cursor_Conf[2][1] = 1; // Empty
Cursor_Conf[2][8] = 1; // Load
Cursor_Conf[2][14] = 1; // Clear
// navegar
GUI_Navegar(0, 0);
// Acciones
// Load
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 2)
{
EEPROM_Load();
GUI_Control_Options();
}
// Clear
if (LCD_Col_Pos == 14 && LCD_Row_Pos == 2)
{
EEPROM_Clear();
GUI_Control_Options();
}
// Empty
if (LCD_Col_Pos == 1 && LCD_Row_Pos == 2)
{
GUI_Control_Options();
}
}

void GUI_Memory()
{
lcd.clear ();
// Texto
lcd.setCursor (0, 0);
lcd.print("Memory Options:");
lcd.setCursor (1, 2);
lcd.print("Save");
lcd.setCursor (1, 3);
lcd.print("Load");
lcd.setCursor (7, 2);
lcd.print("Empty");
lcd.setCursor (7, 3);
lcd.print("Clear");
lcd.setCursor (14, 3);
lcd.print("Cancel");
// Cursor
LCD_Col_Pos = 0; // posicion de cursor
LCD_Row_Pos = 2;
// configuracion de cursor
Cursor_Conf_Clear(); // limpiar array
// Acciones
Cursor_Conf[2][0] = 1; // Save
Cursor_Conf[3][0] = 1; // Load
Cursor_Conf[3][6] = 1; // Clear
Cursor_Conf[2][6] = 1; // Empty
Cursor_Conf[3][13] = 1; // Cancel
// navegar
GUI_Navegar(0, 0);
// Acciones
// Load
if (LCD_Col_Pos == 0 && LCD_Row_Pos == 3)
{
EEPROM_Load();
}
// Clear
if (LCD_Col_Pos == 6 && LCD_Row_Pos == 3)
{
EEPROM_Clear();
}
// Save
if (LCD_Col_Pos == 0 && LCD_Row_Pos == 2)
{
EEPROM_Save();
}
// Empty
if (LCD_Col_Pos == 6 && LCD_Row_Pos == 2)
{
EEPROM_Empty();
}
// Cancel
if (LCD_Col_Pos == 3 && LCD_Row_Pos == 13)
{
null
}
}
null
void EEPROM_Save()
{
lcd.clear ();
lcd.setCursor (17, 1);
for(int Canal = 1; Canal <= 512; Canal ++)
{
EEPROM.write(Canal, DMX_Values[Canal]); // lectura desde EEPROM
lcd.print (Canal, BIN);
}
lcd.clear ();
lcd.setCursor (3, 1);
lcd.print ("Memory Saved!");
delay (1000);
}

void EEPROM_Load()
{
lcd.clear ();
lcd.setCursor (17, 1);
for(int Canal = 1; Canal <= 512; Canal ++)
{
DMX_Values[Canal] = EEPROM.read(Canal); // lectura desde EEPROM
ArduinoDmx0.TxBuffer[Canal - 1] = DMX_Values[Canal]; // salida a DMX
lcd.print (Canal, BIN);
}
lcd.clear ();
lcd.setCursor (3, 1);
lcd.print ("Memory Loaded!");
delay (1000);
}

void EEPROM_Empty()
{
lcd.clear ();
lcd.setCursor (17, 1);
for(int Canal = 0; Canal <= 512; Canal ++)
{
DMX_Values[Canal] = 0; // lectura desde EEPROM
ArduinoDmx0.TxBuffer[Canal] = 0; // salida a DMX
lcd.print (Canal, BIN);
}
lcd.clear ();
lcd.setCursor (3, 1);
lcd.print ("Memory Emptied!");
delay (1000);
}

void EEPROM_Clear()
{
lcd.clear ();
lcd.setCursor (17, 1);
for(int Canal = 0; Canal <= 512; Canal ++)
{
DMX_Values[Canal] = 0; // lectura desde EEPROM
ArduinoDmx0.TxBuffer[Canal] = 0; // salida a DMX
EEPROM.write (Canal, 0); // escritura EEPROM
lcd.print (Canal, BIN);
}
lcd.clear ();
lcd.setCursor (3, 1);
lcd.print ("Memory Cleaned!");
delay (1000);
}

void GUI_Control_Options()
{
iniciar:
// LCD
lcd.clear ();
lcd.setCursor (0, 0);
lcd.print ("Control Options:");
lcd.setCursor (2, 2);
lcd.print ("Unitary");
lcd.setCursor (2, 3);
lcd.print ("Matrix");
lcd.setCursor (12, 2);
lcd.print ("Chaser");
lcd.setCursor (12, 3);
lcd.print ("Multiply");
lcd.setCursor (12, 1);
lcd.print ("Config");
lcd.setCursor (2, 1);
lcd.print ("Memory");
// Cursor
LCD_Col_Pos = 1; // posicion de cursor
LCD_Row_Pos = 2;
// configuracion de cursor
Cursor_Conf_Clear(); // limpiar array
// Acciones
Cursor_Conf[2][1] = 1; // Unitary
Cursor_Conf[3][1] = 1; // Matrix
Cursor_Conf[2][11] = 1; // Chaser
Cursor_Conf[3][11] = 1; // Multiply
Cursor_Conf[1][11] = 1; // Config
Cursor_Conf[1][1] = 1; // Memory
// navegar
GUI_Navegar(0, 0);
// Acciones
// Unitary
if (LCD_Col_Pos == 1 && LCD_Row_Pos == 2)
{
GUI_Control_Unit();
}
// Matrix
if (LCD_Col_Pos == 1 && LCD_Row_Pos == 3)
{
GUI_Control_Matrix();
}
// Chaser
if (LCD_Col_Pos == 11 && LCD_Row_Pos == 2)
{
GUI_Control_Chaser();
}
// Multiply
if (LCD_Col_Pos == 11 && LCD_Row_Pos == 3)
{
GUI_Control_Multiply();
}
// Config
if (LCD_Col_Pos == 11 && LCD_Row_Pos == 1)
{
GUI_Config();
}
// Config
if (LCD_Col_Pos == 1 && LCD_Row_Pos == 1)
{
GUI_Memory();
goto iniciar;
}
}
null
void GUI_Config()
{
Inicio:
byte Back_Light_Value = EEPROM.read(513);
byte Contrast_Value = EEPROM.read(514);
// GUI
lcd.clear ();
lcd.setCursor (0, 0);
lcd.print ("LCD Config:");
lcd.setCursor (15, 0);
lcd.print ("About");
lcd.setCursor (3, 1);
lcd.print ("Back Light:");
Numerico_Write(Back_Light_Value, 15, 1);
lcd.setCursor (5, 2);
lcd.print ("Contrast:");
Numerico_Write(Contrast_Value, 15, 2);
lcd.setCursor (15, 3);
lcd.print ("Ctrl");

// Cursor
LCD_Col_Pos = 14; // posicion de cursor
LCD_Row_Pos = 2; // posicion e cursor
// configuracion de cursor
Cursor_Conf_Clear(); // limpiar array
// Cursores
Cursor_Conf[1][14] = 1; // Back Light Value
Cursor_Conf[2][14] = 1; // Contrast Value
Cursor_Conf[3][14] = 1; // control
Cursor_Conf[0][14] = 1; // About
// navegar
Navegacion:
GUI_Navegar(0, 0);
// Acciones
//Back Light Value
if (LCD_Col_Pos == 14 && LCD_Row_Pos == 1)
{
Num_Row_Pos = 1;
Num_Col_Pos = 15;
Numerico_Calc (1);
if (Num_Val == 712)
{
lcd.setCursor (14, 1);
lcd.print("a"); // indicar que es analogo
digitalWrite(Boton_Array_3, LOW); // lectura linea 3
lcd.blink();
while (digitalRead(Boton_Array_D) == HIGH && digitalRead(Boton_Center) == HIGH) // enter y center para paro
{
Num_Val = analogRead(Pot); // lectura desde el potenciometro
Num_Val = Num_Val / 4; // / 4 porque es de 12 bits
Numerico_Write(Num_Val, 15, 1);
analogWrite(Back_Light_PWM, Num_Val);
delay(50); // retardo de lectura
}
lcd.noBlink();
digitalWrite(Boton_Array_3, HIGH); // lectura linea 3
delay(300); // retraso para center
goto salida;
}
if (Num_Val > 255)
{
Num_Val = 255;
Numerico_Write (255, 15, 1);
}
analogWrite(Back_Light_PWM, Num_Val);
salida:
// mecanismo para on off Enable
if (Num_Val == 0)
{
Back_Light_On_Off = 0;
}
if (Num_Val > 0)
{
Back_Light_On_Off = 1;
}
EEPROM.write(513, Num_Val); // guardar valor nuevo
goto Navegacion;
}
//Contrast Value
if (LCD_Col_Pos == 14 && LCD_Row_Pos == 2)
{
Num_Row_Pos = 2;
Num_Col_Pos = 15;
Numerico_Calc (1);
if (Num_Val == 712)
{
lcd.setCursor (14, 2);
lcd.print("a"); // indicar que es analogo
digitalWrite(Boton_Array_3, LOW); // lectura linea 3
lcd.blink();
while (digitalRead(Boton_Array_D) == HIGH && digitalRead(Boton_Center) == HIGH) // enter y center para paro
{
Num_Val = analogRead(Pot); // lectura desde el potenciometro
Num_Val = Num_Val / 4; // / 4 porque es de 12 bits
if (Num_Val > 149) // limite menor de contraste LCD
{
Numerico_Write(Num_Val, 15, 2);
analogWrite(Contrast_PWM, Num_Val);
}
delay(50); // retardo de lectura
}
lcd.noBlink();
digitalWrite(Boton_Array_3, HIGH); // lectura linea 3
delay(300); // retraso para center
goto salir;
}
if (Num_Val > 255)
{
Num_Val = 255;
Numerico_Write (255, 15, 2);
}
if (Num_Val < 150)
{
Num_Val = 150; // limite menor de contraste LCD
Numerico_Write (150, 15, 2);
}
analogWrite(Contrast_PWM, Num_Val);
salir:
EEPROM.write(514, Num_Val); // guardar valor nuevo
goto Navegacion;
}
// Exit
if (LCD_Col_Pos == 14 && LCD_Row_Pos == 3)
{
GUI_Control_Options();
goto Navegacion;
}
// About
if (LCD_Col_Pos == 14 && LCD_Row_Pos == 0)
{
GUI_About();
while (digitalRead(Boton_Center) == HIGH)
{
// esperamos a que se precione enter
}
delay(300); // retardo para el rebote del boton
goto Inicio;
}
goto Navegacion;
}
null
void GUI_Control_Multiply()
{
int First_Channel = 1;
long Multiply = 0;
long Quantity = 0;
int Value = 255;
iniciar:
// LCD
lcd.clear ();
lcd.setCursor (3, 0);
lcd.print ("Value");
lcd.setCursor (0, 1);
lcd.print ("First CH Ctrl");
lcd.setCursor (0, 2);
lcd.print ("Multiply Memory");
lcd.setCursor (0, 3);
lcd.print ("Quantity Apply");
Numerico_Write (Value, 9, 0);
Numerico_Write (First_Channel, 9, 1);
Numerico_Write (Multiply, 9, 2);
Numerico_Write (Quantity, 9, 3);
// Cursor
LCD_Col_Pos = 8; // posicion de cursor
LCD_Row_Pos = 0;
Siguiente:
// configuracion de cursor
Cursor_Conf_Clear(); // limpiar array
// Acciones
Cursor_Conf[1][8] = 1; // first Channel
Cursor_Conf[3][8] = 1; // quantity
Cursor_Conf[2][8] = 1; // Multiply
Cursor_Conf[1][13] = 1; // control
Cursor_Conf[2][13] = 1; // Memory
Cursor_Conf[3][13] = 1; // apply
Cursor_Conf[0][8] = 1; // value
// navegar
GUI_Navegar(0, 0);
// Acciones
// Control
if (LCD_Col_Pos == 13 && LCD_Row_Pos == 1)
{
GUI_Control_Options();
}
// Memory
if (LCD_Col_Pos == 13 && LCD_Row_Pos == 2)
{
GUI_Memory();
goto iniciar;
}
// Apply
if (LCD_Col_Pos == 13 && LCD_Row_Pos == 3)
{
// Validar datos
long valid = Multiply * Quantity;
if (valid > 512) // si no es valido
{
lcd.setCursor(13, 0);
lcd.print("Error! ");
goto Siguiente;
}
// calcular
lcd.setCursor(13, 0);
lcd.print(" ");
long canal;
for (long conteo = 1; conteo <= Quantity; conteo++)
{
if (conteo == 1)
{
canal = First_Channel;
}
if (conteo != 1)
{
canal = canal + Multiply;
}
if (canal > 512)
{
canal = canal - Multiply;
conteo = Quantity;
}
lcd.setCursor(17, 0);
lcd.print(canal);
delay (5);
ArduinoDmx0.TxBuffer[canal - 1] = Value;
DMX_Values[canal] = Value;
}
lcd.setCursor(13, 0);
lcd.print("Ok!");
goto Siguiente;
}
// First Channel
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 1)
{
Num_Row_Pos = 1;
Num_Col_Pos = 9;
Num_Val = First_Channel; // para dejar el numero que estaba si no se cambia
Numerico_Calc(0);
First_Channel = Num_Val;
if (First_Channel == 0)
{
First_Channel = 1;
Numerico_Write (First_Channel, 9, 1);
}
if (First_Channel > 512)
{
First_Channel = 512;
Numerico_Write (First_Channel, 9, 1);
}
}
// Multiply
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 2)
{
Num_Row_Pos = 2;
Num_Col_Pos = 9;
Num_Val = Multiply; // para dejar el numero que estaba si no se cambia
Numerico_Calc(0);
Multiply = Num_Val;
if (Multiply == 0)
{
Multiply = 1;
Numerico_Write (Multiply, 9, 2);
}
if (Multiply > 512)
{
Multiply = 512;
Numerico_Write (Multiply, 9, 2);
}
}
// Quantity
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 3)
{
Num_Row_Pos = 3;
Num_Col_Pos = 9;
Num_Val = Quantity; // para dejar el numero que estaba si no se cambia
Numerico_Calc(0);
Quantity = Num_Val;
if (Quantity == 0)
{
Quantity = 1;
Numerico_Write (Quantity, 9, 3);
}
if (Quantity > 512)
{
Quantity = 512;
Numerico_Write (Quantity, 9, 3);
}
}
// Value
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 0)
{
Num_Row_Pos = 0;
Num_Col_Pos = 9;
Num_Val = Value; // para dejar el numero que estaba si no se cambia
Numerico_Calc(1);
Value = Num_Val;
if (Value > 255)
{
Value = 255;
Numerico_Write (Value, 9, 0);
}
}
goto Siguiente;
}

void GUI_Control_Chaser()
{
long Delay = 1;
long First = 1;
long Final = 0;
iniciar:
// LCD
lcd.clear ();
lcd.setCursor (0, 0);
lcd.print ("ChaserCH ---");
lcd.setCursor (3, 1);
lcd.print ("Delay x10=mS");
lcd.setCursor (0, 2);
lcd.print ("First CH Ctrl");
lcd.setCursor (0, 3);
lcd.print ("Final CH Start");
Numerico_Write (Delay, 9, 1);
Numerico_Write (First, 9, 2);
Numerico_Write (Final, 9, 3);
// Cursor
LCD_Col_Pos = 8; // posicion de cursor
LCD_Row_Pos = 1;
Siguiente:
// configuracion de cursor
Cursor_Conf_Clear(); // limpiar array
// Acciones
Cursor_Conf[1][8] = 1; // Delay
Cursor_Conf[2][8] = 1; // First
Cursor_Conf[3][8] = 1; // Final
Cursor_Conf[2][14] = 1; // control
Cursor_Conf[3][14] = 1; // Start
// navegar
GUI_Navegar(0, 0);
// Acciones
// Control
if (LCD_Col_Pos == 14 && LCD_Row_Pos == 2)
{
GUI_Control_Options();
}
// Start
if (LCD_Col_Pos == 14 && LCD_Row_Pos == 3)
{
long ciclo_longitud = 1300; // numero multiplicador aprox para 1 seg
long ciclo = 0;
long Delay_Cont = 0;
int canal = First;
lcd.setCursor(15,3);
lcd.print("Stop ");
// borrar canales previos
for(int Canales = 0; Canales <= 512; Canales ++)
{
DMX_Values[Canales] = 0; // lectura desde EEPROM
ArduinoDmx0.TxBuffer[Canales] = 0; // salida a DMX
}
while (digitalRead(Boton_Center) == HIGH) // lectura del boton centro
{
ciclo = ciclo + 1;
if (ciclo == ciclo_longitud)
{
Delay_Cont = Delay_Cont + 1;
if (Delay_Cont == Delay)
{
if (canal > Final)
{
canal = First;
}
Numerico_Write (canal, 9, 0);
// apagar lo anterior
for (long contar = First; contar <= Final; contar ++)
{
ArduinoDmx0.TxBuffer[contar - 1] = 0;
DMX_Values[contar] = 0;
}
// encender el siguiente
ArduinoDmx0.TxBuffer[canal - 1] = 255;
DMX_Values[canal] = 255;
Delay_Cont = 0;
canal = canal + 1;
}
ciclo = 0;
}
}
lcd.setCursor(15,3);
lcd.print("Start");
delay (300); // evita que le gane la descarga del capacitor
goto Siguiente;
}
// Delay
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 1)
{
Num_Row_Pos = 1;
Num_Col_Pos = 9;
Num_Val = Delay; // para dejar el numero que estaba si no se cambia
Numerico_Calc(0);
Delay = Num_Val;
}
// First
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 2)
{
Num_Row_Pos = 2;
Num_Col_Pos = 9;
Num_Val = First; // para dejar el numero que estaba si no se cambia
Numerico_Calc(0);
First = Num_Val;
if (First == 0)
{
First = 1;
Numerico_Write (First, 9, 2);
}
if (First > 512)
{
First = 512;
Numerico_Write (First, 9, 2);
}
}
// Final
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 3)
{
Num_Row_Pos = 3;
Num_Col_Pos = 9;
Num_Val = Final; // para dejar el numero que estaba si no se cambia
Numerico_Calc(0);
Final = Num_Val;
if (Final == 0)
{
Final = 1;
Numerico_Write (Final, 9, 3);
}
if (Final > 512)
{
Final = 512;
Numerico_Write (Final, 9, 3);
}
}
goto Siguiente;
}

void Numerico_Write (int valor, int col, int row)
{
//posicionar el valor en los campos 000
lcd.setCursor (col, row);
lcd.print ("000");
if (valor < 10)
{
lcd.setCursor (col + 2, row);
}
if (valor > 9 && valor < 100)
{
lcd.setCursor (col + 1, row);
}
if (valor > 99)
{
lcd.setCursor (col, row);
}
lcd.print (valor);
}

void GUI_Control_Unit()
{
Inicio:
Canal_Actual = 1;
// GUI
lcd.clear ();
lcd.setCursor (0, 0);
lcd.print ("Unitary Control:");
lcd.setCursor (14, 2);
lcd.print ("Ctrl");
lcd.setCursor (14, 3);
lcd.print ("Memory");
lcd.setCursor (0, 2);
lcd.print ("Channel: 001");
lcd.setCursor (2, 3);
lcd.print ("Value:");
Numerico_Write(DMX_Values[1], 9, 3);
// Cursor
LCD_Col_Pos = 8; // posicion de cursor
LCD_Row_Pos = 2; // posicion e cursor
// configuracion de cursor
Cursor_Conf_Clear(); // limpiar array
// Cursores
Cursor_Conf[2][8] = 1; // Channel
Cursor_Conf[3][8] = 1; // Value
Cursor_Conf[2][13] = 1; // Control
Cursor_Conf[3][13] = 1; // Memory
// navegar
Navegacion:
GUI_Navegar(0, 0);
// Acciones
//Channel
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 2)
{
Numerico_Write(Canal_Actual, 9, 2);
Num_Row_Pos = 2;
Num_Col_Pos = 9;
Num_Val = Canal_Actual; // para dejar el numero que estaba si no se cambia
Numerico_Calc (0);
if (Num_Val > 512)
{
Num_Val = 512;
Numerico_Write (512, 9, 2);
}
if (Num_Val < 1)
{
Num_Val = 1;
Numerico_Write (1, 9, 2);
}
// mostrar valor actual del canal
Canal_Actual = Num_Val;
Numerico_Write(DMX_Values[Canal_Actual], 9, 3);
}
// Value
if (LCD_Col_Pos == 8 && LCD_Row_Pos == 3)
{
Num_Row_Pos = 3;
Num_Col_Pos = 9;
Num_Val = DMX_Values[Canal_Actual]; // para dejar el numero que estaba si no se cambia
Numerico_Calc (1);
if (Num_Val == 612) // ubicar
{
Ubicar();
}
if (Num_Val == 712) // analogo
{
Analog_Read_DMX(9, 3);
goto Navegacion;
}
if (Num_Val > 255)
{
Num_Val = 255;
Numerico_Write (255, 9, 3);
}
// Escribr valor en dmx
ArduinoDmx0.TxBuffer[Canal_Actual - 1] = Num_Val;
DMX_Values[Canal_Actual] = Num_Val;
goto Navegacion;
}
// Memory
if (LCD_Col_Pos == 13 && LCD_Row_Pos == 3)
{
GUI_Memory();
goto Inicio;
}
// Control
if (LCD_Col_Pos == 13 && LCD_Row_Pos == 2)
{
GUI_Control_Options();
}
goto Navegacion;
}

void Ubicar()
{
digitalWrite(Boton_Array_4, LOW);
while (digitalRead(Boton_Array_C) == HIGH)
{
ArduinoDmx0.TxBuffer[Canal_Actual - 1] = 255;
Numerico_Write (255, Num_Col_Pos - 2, Num_Row_Pos);
delay (100);
ArduinoDmx0.TxBuffer[Canal_Actual - 1] = 0;
lcd.setCursor (Num_Col_Pos - 2, Num_Row_Pos);
lcd.print (" ");
delay (100);
}
digitalWrite(Boton_Array_4, HIGH);
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
}

void Numerico_Calc(byte value)
{
// escritura del numero desde el teclado numerico si value es 1 entra opcion de A 255 y B 0
byte Salida = 0;
int Num_Val_Temp_1 = 0;
int Num_Val_Temp_2 = 0;
int Num_Val_Temp_3 = 0;
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
lcd.print("___");
lcd.blink(); // mostrar cursor
//Num_Val = 0;
Num_Col_Pos = Num_Col_Pos + 2;
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
// primer numero
Numerico_Read(); // leer boton
if (Boton_Calc <= 9)
{
lcd.print (Boton_Calc); // escribir valor calculado
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
Num_Val = Boton_Calc; // valor calculado
Num_Val_Temp_1 = Boton_Calc; // valor temporal para el acarreo
}
if (Boton_Calc == 14) // enter
{
goto Salida; // num val = 0
}
if (value == 1) // si es un valor
{
if (Boton_Calc == 10) // 255
{
Num_Val = 255;
goto Salida;
}
if (Boton_Calc == 11) // 000
{
Num_Val = 0;
goto Salida;
}
if (Boton_Calc == 12) // ubicar
{
Num_Val = 612;
goto Salida_Option;
}
if (Boton_Calc == 13) // analogo
{
Num_Val = 712;
goto Salida_Option;
}
}
// segundo numero
Numerico_Read(); // leer boton
if (Boton_Calc == 14) // enter
{
Num_Val = Num_Val_Temp_1;
goto Salida; // num val = num val anterior
}
if (value == 1) // si es un valor
{
if (Boton_Calc == 10) // 255
{
Num_Val = 255;
goto Salida;
}
if (Boton_Calc == 11) // 000
{
Num_Val = 0;
goto Salida;
}
if (Boton_Calc == 12) // ubicar
{
Num_Val = 612;
goto Salida_Option;
}
if (Boton_Calc == 13) // analogo
{
Num_Val = 712;
goto Salida_Option;
}
}
if (Boton_Calc <= 9)
{
// recorrer numero ya impreso
Num_Col_Pos = Num_Col_Pos - 1;
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
lcd.print (Num_Val_Temp_1);
// dibujar numero nuevo
lcd.print (Boton_Calc);
Num_Val_Temp_2 = Boton_Calc;
Num_Col_Pos = Num_Col_Pos + 1;
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
}
// Tercer numero
Numerico_Read(); // leer boton
if (Boton_Calc == 14) // enter
{
Num_Val = (Num_Val_Temp_1 * 10) + Num_Val_Temp_2;
goto Salida;
}
if (value == 1) // si es un valor
{
if (Boton_Calc == 10) // 255
{
Num_Val = 255;
goto Salida;
}
if (Boton_Calc == 11) // 000
{
Num_Val = 0;
goto Salida;
}
if (Boton_Calc == 12) // ubicar
{
Num_Val = 612;
goto Salida_Option;
}
if (Boton_Calc == 13) // analogo
{
Num_Val = 712;
goto Salida_Option;
}
}
if (Boton_Calc <= 9)
{
// recorrer numero ya impreso
Num_Col_Pos = Num_Col_Pos - 2;
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
lcd.print (Num_Val_Temp_1);
lcd.print (Num_Val_Temp_2);
// dibujar numero nuevo
Num_Col_Pos = Num_Col_Pos + 2;
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
lcd.print (Boton_Calc);
Num_Val = Boton_Calc + (Num_Val_Temp_1 * 100) + (Num_Val_Temp_2 * 10);
}
Salida:
lcd.noBlink();
// pintar los ceros antes del numero
Numerico_Write (Num_Val, Num_Col_Pos - 2, Num_Row_Pos);
Num_Col_Pos = Num_Col_Pos - 4;
// regresar el cursor a su ligar
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
Salida_Option:
{
lcd.noBlink();
lcd.setCursor (Num_Col_Pos, Num_Row_Pos);
delay(300); // rebote de boton
}
}
null
void Numerico_Read()
{
long Num_Barrido_Time = 5; // tiempo entre barrido de keys
Boton_Calc = 17; // limpiar valor para lectura
while (Boton_Calc == 17) // valor calculado # E * F, 17 sin valor calculado
{
// Barrido
// Linea 1
digitalWrite(Boton_Array_1, LOW); // lectura linea 1
// Lectura 1A = 1
if (digitalRead(Boton_Array_A) == LOW)
{
Boton_Calc = 1;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 1B = 6
if (digitalRead(Boton_Array_B) == LOW)
{
Boton_Calc = 4;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 1C = 7
if (digitalRead(Boton_Array_C) == LOW)
{
Boton_Calc = 7;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 1D = * = 15
if (digitalRead(Boton_Array_D) == LOW)
{
Boton_Calc = 15;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
digitalWrite(Boton_Array_1, HIGH); // lectura linea 1

// Linea 2
digitalWrite(Boton_Array_2, LOW); // lectura linea 2
// Lectura 2A = 2
if (digitalRead(Boton_Array_A) == LOW)
{
Boton_Calc = 2;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 2B = 5
if (digitalRead(Boton_Array_B) == LOW)
{
Boton_Calc = 5;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 2C = 8
if (digitalRead(Boton_Array_C) == LOW)
{
Boton_Calc = 8;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 2D = 0
if (digitalRead(Boton_Array_D) == LOW)
{
Boton_Calc = 0;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
digitalWrite(Boton_Array_2, HIGH); // lectura linea 2

// Linea 3
digitalWrite(Boton_Array_3, LOW); // lectura linea 3
// Lectura 3A = 3
if (digitalRead(Boton_Array_A) == LOW)
{
Boton_Calc = 3;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 3B = 4
if (digitalRead(Boton_Array_B) == LOW)
{
Boton_Calc = 6;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 3C = 9
if (digitalRead(Boton_Array_C) == LOW)
{
Boton_Calc = 9;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 3D = 14
if (digitalRead(Boton_Array_D) == LOW)
{
Boton_Calc = 14;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
digitalWrite(Boton_Array_3, HIGH); // lectura linea 3

// Linea 4
digitalWrite(Boton_Array_4, LOW); // lectura linea 4
// Lectura 4A = 10
if (digitalRead(Boton_Array_A) == LOW)
{
Boton_Calc = 10;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 4B = 11
if (digitalRead(Boton_Array_B) == LOW)
{
Boton_Calc = 11;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 4C = 12
if (digitalRead(Boton_Array_C) == LOW)
{
Boton_Calc = 12;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
// Lectura 4D = 13
if (digitalRead(Boton_Array_D) == LOW)
{
Boton_Calc = 13;
delay(Boton_Delay_Teclado);
}
delay(Num_Barrido_Time);
digitalWrite(Boton_Array_4, HIGH); // lectura linea 4

// Cursor center "enter"
if (digitalRead(Boton_Center) == LOW)
{
Boton_Calc = 14;
delay(Boton_Delay_Teclado);
}
}
}

void Analog_Read_DMX(byte col, byte row)
{
// escritura del numero desde el potenciometro aplica a dmx
int read;
lcd.setCursor (col - 1, row);
lcd.print("a"); // indicar que es analogo
digitalWrite(Boton_Array_3, LOW); // lectura linea 3
lcd.blink();
int valores = 0;
while (digitalRead(Boton_Array_D) == HIGH && digitalRead(Boton_Center) == HIGH) // enter y center para paro
{
read = analogRead(Pot); // lectura desde el potenciometro
read = read / 4; // / 4 porque es de 12 bits
delay(50);
if (valores != read)
{
Numerico_Write(read, col, row);
ArduinoDmx0.TxBuffer[Canal_Actual - 1] = read;
DMX_Values[Canal_Actual] = read;
valores = read;
}
}
lcd.noBlink();
digitalWrite(Boton_Array_3, HIGH); // lectura linea 3 // retraso para center
delay(300); // delay para salir de la lectura analoga
}
用戶輸入
在啟動(dòng)時(shí)它會(huì)顯示選項(xiàng)“初始內(nèi)存”，以設(shè)置 RAM 的初始值

">" 表示光標(biāo)在菜單上的位置

“+”和閃爍的光標(biāo)，數(shù)字符號(hào)表示需要用戶輸入

菜單之間的導(dǎo)航由光標(biāo)向上、向下、向右、向左和居中進(jìn)行，應(yīng)用為“輸入”

當(dāng)在需要用戶輸入的菜單中給出“Enter”時(shí)，出現(xiàn)“+ ___”并且指示用戶輸入的閃爍光標(biāo)，在這種情況下，如果文檔編號(hào)小于 3 位，則使用小鍵盤(pán)按“#”，其功能為一個(gè)“輸入”在數(shù)字鍵盤(pán)上

如果是用戶輸入，其中顯示了 DMX 通道的值，您可以按（在“回車(chē)”后）直接鍵入“255”（通道的最大值）的鍵“A”或“B”鍵你直接輸入“000”（一個(gè)通道的最小值）

“C”鍵用作定位燈具或特定通道的方法，只需在值中選擇通道位置，“輸入”并按“C”，該值將在“000”和“255”之間排序通道", 停止再按一次返回"C"

“*”鍵開(kāi)啟或關(guān)閉背光

“D”只對(duì)模擬電位器數(shù)值有效，按鍵可通過(guò)轉(zhuǎn)動(dòng)輸入數(shù)值

“Ctrl”返回菜單選項(xiàng)“控制選項(xiàng)”

初始：

設(shè)置 RAM 的初始值，EEPROM 讀取自：

空（EEPROM保持原樣不變，所有通道都在“000”）

加載（加載存儲(chǔ)在 DMX Universe 的 EEPROM 中的值）

清除（擦除存儲(chǔ)在 EEPROM 中的值并保留通道“000”）

控制選項(xiàng)：
用戶選擇不同DMX通道的控制方式

“內(nèi)存”訪問(wèn)內(nèi)存選項(xiàng)

"統(tǒng)一快速訪問(wèn)特定頻道

“矩陣”顯示一個(gè) 3 x 5 的矩陣，其中包含不同通道的當(dāng)前值

“追逐者”在頻道之間制作特定的序列

“乘”為特定數(shù)量的通道分配一個(gè)值，具有特定的數(shù)值跳轉(zhuǎn)

“配置”訪問(wèn)系統(tǒng)設(shè)置

單一控制
它允許快速訪問(wèn)特定頻道

“頻道”頻道訪問(wèn)

“價(jià)值”獲取渠道價(jià)值

“Ctrl” 訪問(wèn)菜單“控制選項(xiàng)”

“內(nèi)存” 訪問(wèn)“內(nèi)存選項(xiàng)”菜單

矩陣控制
顯示一個(gè) 3 x 5 的矩陣，其中包含不同 DMX 通道的當(dāng)前值

“C ---”從光標(biāo)處顯示所選通道的編號(hào)

“內(nèi)存”訪問(wèn)“內(nèi)存選項(xiàng)”

“Ctrl”訪問(wèn)“控制選項(xiàng)”

“001-015”獲取要顯示的通道數(shù)，以3×5的矩陣形式顯示，第一個(gè)數(shù)字代表第一個(gè)通道，第二個(gè)到最后一個(gè)通道

延遲控制
允許通道之間的特定序列

“ChaserCH”顯示排序的當(dāng)前值（在序列開(kāi)始之后）

“延遲”，選擇每一步之間的時(shí)間量，單位為 mS（毫秒），該值近似于數(shù)字 10 = mS 的數(shù)量

“First CH”，選擇序列的第一個(gè)通道

“最后的 CH”。選擇序列中的最后一個(gè)通道

“Ctrl”訪問(wèn)“控制選項(xiàng)”，序列值不影響RAM out with old values

“開(kāi)始”開(kāi)始序列并切換到“停止”，您可以在此處停止序列

例子：

選擇“延遲”100 (100x10 = 1000 mS)、“第一通道”001 和“最后通道”512 結(jié)果是從通道 1 到 512 的序列，通道之間的步長(zhǎng)每秒

乘法控制
為特定數(shù)量的通道分配一個(gè)值，并帶有特定的數(shù)字跳轉(zhuǎn)

“值”選擇要寫(xiě)入的值（000-255）

“First CH”選擇第一個(gè)頻道

“乘”選擇要相乘的通道數(shù)

“數(shù)量”選擇要乘的次數(shù)

“Ctrl”訪問(wèn)“控制選項(xiàng)”，RAM影響通道

“內(nèi)存”訪問(wèn)“內(nèi)存選項(xiàng)”

“應(yīng)用”評(píng)估請(qǐng)求是不可能的應(yīng)用程序顯示消息“錯(cuò)誤”，否則應(yīng)用乘法通道并放置選定的值

例子：

選擇“值”= 255，“第一個(gè)通道”= 001，“乘”= 003“數(shù)量”= 170 和“應(yīng)用”

結(jié)果：從通道 1 到 510 的 170 個(gè)通道，3 對(duì) 3，值為 255

內(nèi)存選項(xiàng)
輕松訪問(wèn) EEPROM 選項(xiàng)

“保存”以當(dāng)前值保存 DMX Universe

從先前保存的 DMX Universe 的 EEPROM 值中“加載”加載

"Empty" 使用當(dāng)前 DMX 值刪除 RAM，而不影響 EEPROM

“清除”清除存儲(chǔ)在 EEPROM 中的 DMX 宇宙

“Black” 選項(xiàng) “Black Out”，將DMX全域的所有通道置“000”，不影響內(nèi)存，按“enter”或“central”退出，返回上述值

取消（返回上一級(jí)菜單，不做任何更改）

配置
整體系統(tǒng)配置

位于“控制選項(xiàng)”

“背光” 選擇 LCD 背光的 000-255 之間的調(diào)光值

“對(duì)比度”選擇調(diào)光值在150-255 LCD對(duì)比度之間（降低150，防止LCD看不到）

“退出”返回上一級(jí)菜單

修改后的值自動(dòng)保存在 EEPROM 存儲(chǔ)器中