0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看技术视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

如何利用DMX-512协议实现测试仪控制器的设计

科技观察员 来源:Daniel Becerril 作者:Daniel Becerril 2022-08-15 15:25 次阅读

通过DMX-512协议进行测试和灯光显示的控制工具,非常适合对固定或临时照明装置进行快速测试。该项目源于需要有一个用于快速测试照明装置的便携式系统,而无需在外部、敌对或难以访问的环境中安装照明控制台、接口或计算机。

硬件

4x20 LCD 背光和对比度由软件控制

USB、电池或外接电源供电

导航键盘

4x4 键盘

模拟控制电位器

开关机(不适用于USB电源

来自接线端子、XLR 3 针和 5 针 XLR 的 DMX 输出

输出状态 LED DMX

Proteus V7.7 SP2 中的模拟

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

示意图

pYYBAGL587uAcMCvAAHDTeTF-Lo359.png

印刷电路板

poYBAGL588GAI7u4AANOSet4-jA617.png

仿真器

pYYBAGL588eAH3HcAALfRSLXQHs742.png

使用酚醛板,加强铜砂纸水,循环变薄

使用 Proteus 发送文件以打印印前醋酸盐底片(文件中有 PDF)

poYBAGL588yAEbtAAAWbVbKkgC4276.png

感光胶片的用途和方法

poYBAGL589KAI5JpAAODcxBoL5w131.png

使用纸覆膜机薄膜完美粘附 pcb

pYYBAGL589iAV8UDAASmmxjCPWw852.png

在板和醋酸盐之间加一点水,使其不会移动并施加紫外线

poYBAGL5892ACPVbAAO8TXSY8zg397.png

应用氯化铁清洁并准备好

pYYBAGL58-OAP6uOAASJMiyKKd4871.png
poYBAGL58-iAI2GeAAM09TV2o8I807.png

焊接元件

pYYBAGL58-yAIQy4AASiA2NcFqA136.png

剥去电位器导轨

pYYBAGL58_GAM1PeAASb2h7ay4Q544.png

酚醛钻孔板放置电位器

pYYBAGL58_qAClRnAAVGepfrEw0418.png

我们转动旋钮并将引脚焊接到焊盘上

poYBAGL59AiALyn3AAWjm7Ezb6Q336.png

将它们放在顶部焊接顶部,用砂纸和水切割的销钉上方去除多余的

pYYBAGL59A2AXi4QAAMG_PFkG7k792.png

我们添加胶带双面胶带将键盘连接到板上

poYBAGL59BGASdw2AAR36dsyw7Y865.png

在这里有一个细节,头部被键盘的弯曲堵塞,切口

poYBAGL59BaAdUrWAAOqiquabDo958.png

焊接键盘下方的接头并向后弯曲以横向连接键盘

poYBAGL59BuAXi_mAAPNjQ3MS5Q590.png

把键盘放在液晶板上,这里有一个细节,MAX485的底座和键盘很贴合

pYYBAGL59CCAfauuAAW2MgilBbk296.png

Arduino Mega 的 USB 端口上添加一些胶带,以防止轨道之间发生短路

pYYBAGL59CWAJIL6AASANHcoBhY696.png

所有已安装的组件

poYBAGL59CyAToDKAALABIJ67l4985.png

我们在 Arduino 上加载固件

poYBAGL59DOAUS83AAOIHottH70978.png

代码

// ***************************************************************************************************************************
// ***************************************************************************************************************************
// ** **
// ** 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”返回菜单选项“控制选项”

poYBAGL59E-AO__JAAKx7_QzYdQ441.png

初始:

设置 RAM 的初始值,EEPROM 读取自:

空(EEPROM保持原样不变,所有通道都在“000”)

加载(加载存储在 DMX Universe 的 EEPROM 中的值)

清除(擦除存储在 EEPROM 中的值并保留通道“000”)

pYYBAGL59FaAdKqCAAMRfDBPAoU016.png

控制选项:
用户选择不同DMX通道的控制方式

“内存”访问内存选项

"统一快速访问特定频道

“矩阵”显示一个 3 x 5 的矩阵,其中包含不同通道的当前值

“追逐者”在频道之间制作特定的序列

“乘”为特定数量的通道分配一个值,具有特定的数值跳转

“配置”访问系统设置

单一控制
它允许快速访问特定频道

“频道”频道访问

“价值”获取渠道价值

“Ctrl” 访问菜单“控制选项”

“内存” 访问“内存选项”菜单

pYYBAGL59FyATgt1AAMW1-jT4E0817.png

矩阵控制
显示一个 3 x 5 的矩阵,其中包含不同 DMX 通道的当前值

“C ---”从光标处显示所选通道的编号

“内存”访问“内存选项”

“Ctrl”访问“控制选项”

“001-015”获取要显示的通道数,以3×5的矩阵形式显示,第一个数字代表第一个通道,第二个到最后一个通道

poYBAGL59GOAcT1WAAMVjxOG6a8985.png

延迟控制
允许通道之间的特定序列

“ChaserCH”显示排序的当前值(在序列开始之后)

“延迟”,选择每一步之间的时间量,单位为 mS(毫秒),该值近似于数字 10 = mS 的数量

“First CH”,选择序列的第一个通道

“最后的 CH”。选择序列中的最后一个通道

“Ctrl”访问“控制选项”,序列值不影响RAM out with old values

“开始”开始序列并切换到“停止”,您可以在此处停止序列

例子:

选择“延迟”100 (100x10 = 1000 mS)、“第一通道”001 和“最后通道”512 结果是从通道 1 到 512 的序列,通道之间的步长每秒

poYBAGL59GmADXGiAAL33E0xWcY730.png

乘法控制
为特定数量的通道分配一个值,并带有特定的数字跳转

“值”选择要写入的值(000-255)

“First CH”选择第一个频道

“乘”选择要相乘的通道数

“数量”选择要乘的次数

“Ctrl”访问“控制选项”,RAM影响通道

“内存”访问“内存选项”

“应用”评估请求是不可能的应用程序显示消息“错误”,否则应用乘法通道并放置选定的值

例子:

选择“值”= 255,“第一个通道”= 001,“乘”= 003“数量”= 170 和“应用”

结果:从通道 1 到 510 的 170 个通道,3 对 3,值为 255

poYBAGL59G-AWVUjAALs13vGCf0989.png

内存选项
轻松访问 EEPROM 选项

“保存”以当前值保存 DMX Universe

从先前保存的 DMX Universe 的 EEPROM 值中“加载”加载

"Empty" 使用当前 DMX 值删除 RAM,而不影响 EEPROM

“清除”清除存储在 EEPROM 中的 DMX 宇宙

“Black” 选项 “Black Out”,将DMX全域的所有通道置“000”,不影响内存,按“enter”或“central”退出,返回上述值

取消(返回上一级菜单,不做任何更改)

pYYBAGL59HWAZi71AALyWmNrb2I085.png

配置
整体系统配置

位于“控制选项”

“背光” 选择 LCD 背光的 000-255 之间的调光值

“对比度”选择调光值在150-255 LCD对比度之间(降低150,防止LCD看不到)

“退出”返回上一级菜单

修改后的值自动保存在 EEPROM 存储器中

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 测试仪
    +关注

    关注

    6

    文章

    3692

    浏览量

    54762
  • 控制器
    +关注

    关注

    112

    文章

    16204

    浏览量

    177420
  • DMX512协议
    +关注

    关注

    1

    文章

    6

    浏览量

    11423
收藏 人收藏

    评论

    相关推荐

    【Aworks申请】楼宇智能WiFi LED调光(DMX512协议控制器

    串口转WiFi模块,实现dmx512协议数据的发送,在我的led灯体里面放置一块DMX512协议接收控制
    发表于 07-18 17:01

    了解一下DMX512的基本协议

    的灯光控制器与灯具设备进行数据传输的工业标准,全称是USITTDMX512(1990),包括电气特性、数据协议、数据格式等方面的内容。每一个DMX 控...
    发表于 11-30 06:03

    DMX512的基本协议相关资料分享

    的灯光控制器与灯具设备进行数据传输的工业标准,全称是USITTDMX512(1990),包括电气特性、数据协议、数据格式等方面的内容。每一个DMX
    发表于 11-30 06:20

    DMX512数据协议标准

      DMX512数据协议是美国舞台灯光协会(USITT)于1990年发布的一种灯光控制器与灯具设备进行数据传输的标准。它包括电气特性,数据协议,数据格式等方面的内容。   
    发表于 10-10 16:13 461次下载

    DMX512控制协议及其实现

    主要介绍DMX512协议以及单片机编程方法实现
    发表于 06-08 17:29 36次下载

    DMX512协议是什么 DMX512数字灯光控制系统介绍

    基于DMX512控制协议进行调光控制的灯光系统叫做数字灯光系统。目前,包括电脑灯在内的各种舞台效果灯、调光控制器
    发表于 09-13 17:25 10.7w次阅读
    <b class='flag-5'>DMX512</b><b class='flag-5'>协议</b>是什么 <b class='flag-5'>DMX512</b>数字灯光<b class='flag-5'>控制</b>系统介绍

    DMX512灯光控制协议及LED控制系统的设计

    总线方案。DMX512是现在最流行的控制方法, 但是在实际应用中多采用控制器互联来进行控制的照明方案, 软件比较复杂。DALI 总线是欧洲提出的一种灯光
    发表于 10-31 14:53 75次下载
    <b class='flag-5'>DMX512</b>灯光<b class='flag-5'>控制</b><b class='flag-5'>协议</b>及LED<b class='flag-5'>控制</b>系统的设计

    dmx512是什么_dmx512端口定义

    dmx512是什么?DMX是Digital MultipleX的缩写,意为多路数字传输。DMX512控制协议是美国舞台灯光协会(usITT)
    发表于 11-07 10:46 2.9w次阅读
    <b class='flag-5'>dmx512</b>是什么_<b class='flag-5'>dmx512</b>端口定义

    DMX512控制器工作原理和优势

     DMX512控制器能够输出标准的DMX512控制信号,能够级联多DMX灯具,可以配合LED DMX
    发表于 11-11 16:27 5964次阅读

    DMX512控制器的工作原理

    DMX512控制器能够输出标准的DMX512控制信号,DMX512控制器能够输出标准的
    发表于 11-13 11:15 1w次阅读

    DMX512控制器说明及介绍,DMX512控制器使用说明

     dmx512是一款很简单实用的控制器,这款控制器适用国际标准的通用信号作为传输协议,简单高效,DMX的信号是属于465信号,也叫并行信号,
    发表于 12-06 16:11 8.7w次阅读
    <b class='flag-5'>DMX512</b><b class='flag-5'>控制器</b>说明及介绍,<b class='flag-5'>DMX512</b><b class='flag-5'>控制器</b>使用说明

    dmx512控制器作用和特点是什么(工作原理及接线图)

    DMX512控制器能够输出标准的DMX512控制信号,能够级联多DMX灯具,可以配合LED DMX
    发表于 12-06 16:52 8.3w次阅读

    基于STM32的DMX512开发笔记

    的灯光控制器与灯具设备进行数据传输的工业标准,全称是USITTDMX512(1990),包括电气特性、数据协议、数据格式等方面的内容。每一个DMX 控...
    发表于 11-21 20:51 71次下载
    基于STM32的<b class='flag-5'>DMX512</b>开发笔记

    dmx512控制器-dmx512灯光控制器-512控制器

    dmx512控制器dmx512灯光控制器512控制器、T2-1000AC LED全彩
    发表于 11-17 11:25 1443次阅读

    针对灯光和控制|功能底座DMX-Base上线

    标准数字接口控制调光方式。但在实际使用中,DMX512协议也存在着以下的痛点。控制器昂贵市面上的专业D
    的头像 发表于 04-26 15:27 632次阅读
    针对灯光和<b class='flag-5'>控制</b>|功能底座<b class='flag-5'>DMX</b>-Base上线