如何利用DMX-512协议实现测试仪控制器的设计
描述
通过DMX-512协议进行测试和灯光显示的控制工具，非常适合对固定或临时照明装置进行快速测试。该项目源于需要有一个用于快速测试照明装置的便携式系统，而无需在外部、敌对或难以访问的环境中安装照明控制台、接口或计算机。
硬件
4x20 LCD 背光和对比度由软件控制
USB、电池或外接电源供电
导航键盘
4x4 键盘
模拟控制电位器
开关机（不适用于USB电源）
来自接线端子、XLR 3 针和 5 针 XLR 的 DMX 输出
输出状态 LED DMX
Proteus V7.7 SP2 中的模拟
Proteus v8.0 SP1 中的原理图和 PCB
示意图
印刷电路板
仿真器
使用酚醛板，加强铜砂纸水，循环变薄
使用 Proteus 发送文件以打印印前醋酸盐底片（文件中有 PDF）
感光胶片的用途和方法
使用纸覆膜机薄膜完美粘附 pcb
在板和醋酸盐之间加一点水，使其不会移动并施加紫外线
应用氯化铁清洁并准备好
焊接元件
剥去电位器导轨
酚醛钻孔板放置电位器
我们转动旋钮并将引脚焊接到焊盘上
将它们放在顶部焊接顶部，用砂纸和水切割的销钉上方去除多余的
我们添加胶带双面胶带将键盘连接到板上
在这里有一个细节，头部被键盘的弯曲堵塞，切口
焊接键盘下方的接头并向后弯曲以横向连接键盘
把键盘放在液晶板上，这里有一个细节，MAX485的底座和键盘很贴合
在 Arduino Mega 的 USB 端口上添加一些胶带，以防止轨道之间发生短路
所有已安装的组件
我们在 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
}
用户输入
在启动时它会显示选项“初始内存”，以设置 RAM 的初始值
">" 表示光标在菜单上的位置
“+”和闪烁的光标，数字符号表示需要用户输入
菜单之间的导航由光标向上、向下、向右、向左和居中进行，应用为“输入”
当在需要用户输入的菜单中给出“Enter”时，出现“+ ___”并且指示用户输入的闪烁光标，在这种情况下，如果文档编号小于 3 位，则使用小键盘按“#”，其功能为一个“输入”在数字键盘上
如果是用户输入，其中显示了 DMX 通道的值，您可以按（在“回车”后）直接键入“255”（通道的最大值）的键“A”或“B”键你直接输入“000”（一个通道的最小值）
“C”键用作定位灯具或特定通道的方法，只需在值中选择通道位置，“输入”并按“C”，该值将在“000”和“255”之间排序通道", 停止再按一次返回"C"
“*”键开启或关闭背光
“D”只对模拟电位器数值有效，按键可通过转动输入数值
“Ctrl”返回菜单选项“控制选项”
初始：
设置 RAM 的初始值，EEPROM 读取自：
空（EEPROM保持原样不变，所有通道都在“000”）
加载（加载存储在 DMX Universe 的 EEPROM 中的值）
清除（擦除存储在 EEPROM 中的值并保留通道“000”）
控制选项：
用户选择不同DMX通道的控制方式
“内存”访问内存选项
"统一快速访问特定频道
“矩阵”显示一个 3 x 5 的矩阵，其中包含不同通道的当前值
“追逐者”在频道之间制作特定的序列
“乘”为特定数量的通道分配一个值，具有特定的数值跳转
“配置”访问系统设置
单一控制
它允许快速访问特定频道
“频道”频道访问
“价值”获取渠道价值
“Ctrl” 访问菜单“控制选项”
“内存” 访问“内存选项”菜单
矩阵控制
显示一个 3 x 5 的矩阵，其中包含不同 DMX 通道的当前值
“C ---”从光标处显示所选通道的编号
“内存”访问“内存选项”
“Ctrl”访问“控制选项”
“001-015”获取要显示的通道数，以3×5的矩阵形式显示，第一个数字代表第一个通道，第二个到最后一个通道
延迟控制
允许通道之间的特定序列
“ChaserCH”显示排序的当前值（在序列开始之后）
“延迟”，选择每一步之间的时间量，单位为 mS（毫秒），该值近似于数字 10 = mS 的数量
“First CH”，选择序列的第一个通道
“最后的 CH”。选择序列中的最后一个通道
“Ctrl”访问“控制选项”，序列值不影响RAM out with old values
“开始”开始序列并切换到“停止”，您可以在此处停止序列
例子：
选择“延迟”100 (100x10 = 1000 mS)、“第一通道”001 和“最后通道”512 结果是从通道 1 到 512 的序列，通道之间的步长每秒
乘法控制
为特定数量的通道分配一个值，并带有特定的数字跳转
“值”选择要写入的值（000-255）
“First CH”选择第一个频道
“乘”选择要相乘的通道数
“数量”选择要乘的次数
“Ctrl”访问“控制选项”，RAM影响通道
“内存”访问“内存选项”
“应用”评估请求是不可能的应用程序显示消息“错误”，否则应用乘法通道并放置选定的值
例子：
选择“值”= 255，“第一个通道”= 001，“乘”= 003“数量”= 170 和“应用”
结果：从通道 1 到 510 的 170 个通道，3 对 3，值为 255
内存选项
轻松访问 EEPROM 选项
“保存”以当前值保存 DMX Universe
从先前保存的 DMX Universe 的 EEPROM 值中“加载”加载
"Empty" 使用当前 DMX 值删除 RAM，而不影响 EEPROM
“清除”清除存储在 EEPROM 中的 DMX 宇宙
“Black” 选项 “Black Out”，将DMX全域的所有通道置“000”，不影响内存，按“enter”或“central”退出，返回上述值
取消（返回上一级菜单，不做任何更改）
配置
整体系统配置
位于“控制选项”
“背光” 选择 LCD 背光的 000-255 之间的调光值
“对比度”选择调光值在150-255 LCD对比度之间（降低150，防止LCD看不到）
“退出”返回上一级菜单
修改后的值自动保存在 EEPROM 存储器中
-
【Aworks申请】楼宇智能WiFi LED调光（DMX512协议）控制器2015-07-18 0
-
了解一下DMX512的基本协议2021-11-30 0
-
DMX512的基本协议相关资料分享2021-11-30 0
-
DMX512数据协议标准2010-10-10 3066
-
DMX512控制协议及其实现2016-06-08 1302
-
DMX512协议是什么 DMX512数字灯光控制系统介绍2016-09-13 106827
-
DMX512灯光控制协议及LED控制系统的设计2017-10-31 1384
-
dmx512是什么_dmx512端口定义2017-11-07 29361
-
DMX512控制器工作原理和优势2017-11-11 5957
-
DMX512控制器的工作原理2017-11-13 10143
-
DMX512控制器说明及介绍,DMX512控制器使用说明2017-12-06 87225
-
dmx512控制器作用和特点是什么（工作原理及接线图）2017-12-06 82967
-
基于STM32的DMX512开发笔记2021-11-21 1710
-
dmx512控制器-dmx512灯光控制器-512控制器2022-11-17 1440
-
针对灯光和控制|功能底座DMX-Base上线2023-04-26 627
全部0条评论
快来发表一下你的评论吧 !
