Controlador de tester Arduino DMX-512

Acerca de este proyecto

Herramienta de control para pruebas y espectáculo de luces mediante el protocolo DMX-512, ideal para pruebas rápidas en instalaciones de iluminación fijas o temporales. Este proyecto surge de la necesidad de contar con un sistema portátil para pruebas rápidas en instalaciones de iluminación, sin necesidad de instalar consolas de iluminación, interfaces o computadoras en ambientes externos, hostiles o de difícil acceso.

Basado en:

• Arduino Mega 2560 Rev-3

• Biblioteca Arduino cuatro universos DMX v0.3 - Deskontrol

• Library LCD v1.2.1 - Francisco Malpartida

• Arduino de Proteus Simulation - Microcontrolandos

Hardware v0.4

Notas de la versión ...

• Compatible con firmware v0.9 - v1.3

• LCD de 4x20 con retroiluminación y contraste controlados por software

• Alimentación de USB, baterías o fuente de alimentación externa

• Teclado de navegación

• Teclado 4x4

• Potenciómetro de control analógico

• Encender / apagar (no se aplica a la alimentación USB)

• Salida DMX desde bloque de terminales, XLR de 3 pines y XLR de 5 pines

• LED de estado de salida DMX

• Simulación en Proteus V7.7 SP2

• Esquema y PCB en Proteus v8.0 SP1

Esquema

PCB

Simulador

Empezamos la construcción ...

Usamos una placa fenólica una cara, reforzamos el agua con papel de lija de cobre, más fina circularmente

Con Proteus envíe archivos para imprimir un negativo de acetato preimpresión (hay un PDF con el archivo)

Uso y método de película fotosensible

Usamos una película laminadora de papel para adherir perfectamente la placa de circuito impreso

Agrega un poco de agua entre la placa y el acetato para que no se mueva y aplica luz ultravioleta

Aplicar el cloruro férrico están limpios y listos

Perforamos placas

Componentes soldados

Despojado de la guía del potenciómetro

Placa fenólica perforada para poner el potenciómetro

Giramos la perilla y el pin soldado a las almohadillas

En el caso del plato chica, poniéndoles cabeceras suelda la tapa, encima de los pines cortamos con papel de lija y quitamos el agua sobrante

Agregamos cinta adhesiva doble para sujetar el teclado a la placa

Aquí nos encontramos con un detalle, encabezados atascados con el flex del teclado, el corte (lo consideramos para la próxima versión)

Suelde los encabezados que están debajo del teclado y dóblelos hacia atrás para conectar el teclado lateralmente

Colocamos el teclado en la placa LCD, aquí hay un detalle, la base del MAX485 estoy muy pegada al teclado, forzamos un poco (lo consideramos en la próxima versión)

Agregamos a Arduino Mega algo de cinta al puerto USB para evitar un cortocircuito entre pistas

Todos los componentes montados

Cargamos el firmware en el Arduino

Firmware v1.2

Notas de la versión ...

• Compatible con hardware v0.3 - v0.4

• Navegación desde el cursor de fácil acceso e intuitiva

• Inserción rápida de valores desde el teclado

• Inserte valores del potenciómetro analógico

• Los bancos de memoria almacenan 8 universos DMX

• Lectura de la EEPROM para iniciar el universo DMX preseleccionado

• Selección de opciones de memoria para comenzar

• DMX Control Unitario, selecciona un canal específico y muestra los valores de los canales anteriores y siguientes

• Matrix Control DMX muestra una matriz de 3 x 5 con los valores de los canales mostrados

• Chaser DMX Control permite secuenciar los canales seleccionados, con un tiempo seleccionado

• DMX Sequencer permite la secuenciación entre universos almacenados en la memoria EEPROM con un tiempo seleccionado

• Multiply DMX Control permite multiplicar valores para llenar los canales seleccionados

• Función para localizar luminaria del canal seleccionado

• Acceso rápido a las opciones de memoria

• Opciones de memoria Guardar, Cargar, Borrar, Borrar todo (para bancos y memoria RAM vacía

• Opciones de memoria para los 8 bancos de universos DMX

• Función Black Out

• Control de la retroiluminación de la pantalla LCD

• Control de contraste LCD

• Atajos de teclado desde la luz de fondo de la pantalla LCD

• compilado por Arduino IDE v1.0.6

• Librería Arduino cuatro universos DMX v0.3 - Deskontrol.net

• Library LCD v1.2.1 - Francisco Malpartida

Código

  // **************************************** *********************************************** ****************************** // ***************** *********************************************** *********************************************** ****** // ** ** // ** Controlador de tester Arduino DMX-512 ** // ** ** // ** - 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.blog spot.mx/2012/12/arduino-componentes-para-o-proteus.html ** // ** ** // ** Autor:** // ** ** // ** Daniel Roberto Becerril Ángeles * * // ** [email protected] ** ** // ** https://github.com/daniel3514/Arduino-DMX-512-Tester-Controller/ ** // ** ** // ** Licenciamiento:** // ** ** // ** GNU Licencia Pública General Versión 3 ** // ** https://www.gnu.org/copyleft/gpl.html ** // ** ** / / ********************************************** *********************************************** ************************ // *********************** *********************************************** *************************************************nulo // 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 kbaudios - 2 a 512 canales) Estándar USITT DMX-512 // # define DMX1024 (1) // (500 kbaudios - 2 a 1024 canales) Completamente no estándar - PROBADO ok // # de fine DMX2048 (2) // (1000 kbaudios - 2 a 2048 canales) llamado por los fabricantes DMX1000K, DMX 4x o DMX 1M ??? null // Puertos, variables // DMX // int DMX_Data_Flux =2; // control de flujo de datos para dmx, 0 por defecto int DMX_Values ​​[515]; // matriz 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; // retraso de lectura de boton // Potenciometro int Pot =A15; // entrada de potencia // LCD int LCD_RS =8; // puertos de conexión de LCD int LCD_E =9; int LCD_D4 =10; int LCD_D5 =11; int LCD_D6 =12; int LCD_D7 =13; LCD de cristal líquido (LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7); // Configuración de LCD 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 apagadanullvoid 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, SALIDA); pinMode (Boton_Array_3, SALIDA); pinMode (Boton_Array_4, SALIDA); 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, ALTO); digitalWrite (Boton_Array_2, ALTO); digitalWrite (Boton_Array_3, HIGH); digitalWrite (Boton_Array_4, HIGH); // LCD pinMode (LCD_RS, SALIDA); pinMode (LCD_E, SALIDA); pinMode (LCD_D7, SALIDA); pinMode (LCD_D6, SALIDA); pinMode (LCD_D5, SALIDA); pinMode (LCD_D4, SALIDA); pinMode (Back_Light_PWM, SALIDA); lcd. comienzo (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 la transmisión universo 0, modo estandar DMX512 // no conectados pinMode (5, OUTPUT); digitalWrite (5, BAJO); pinMode (6, SALIDA); digitalWrite (6, BAJO); pinMode (7, SALIDA); digitalWrite (7, BAJO); pinMode (22, SALIDA); digitalWrite (22, BAJO); pinMode (23, SALIDA); digitalWrite (23, BAJO); pinMode (24, SALIDA); digitalWrite (24, BAJO); pinMode (25, SALIDA); digitalWrite (25, BAJO); pinMode (26, SALIDA); digitalWrite (26, BAJO); pinMode (27, SALIDA); digitalWrite (27, BAJO); pinMode (28, SALIDA); digitalWrite (28, BAJO); pinMode (29, SALIDA); digitalWrite (29, BAJO); pinMode (31, SALIDA); digitalWrite (31, BAJO); pinMode (33, SALIDA); digitalWrite (33, BAJO); pinMode (35, SALIDA); digitalWrite (35, BAJO); pinMode (37, SALIDA); digitalWrite (37, BAJO); pinMode (39, SALIDA); digitalWrite (39, BAJO); pinMode (41, SALIDA); digitalWrite (41, BAJO); pinMode (43, SALIDA); digitalWrite (43, BAJO); pinMode (46, SALIDA); digitalWrite (46, BAJO); pinMode (48, SALIDA); digitalWrite (48, BAJO); pinMode (50, SALIDA); digitalWrite (50, BAJO); pinMode (52, SALIDA); digitalWrite (52, BAJO); pinMode (A0, SALIDA); escritura digital (A0, BAJA); pinMode (A1, SALIDA); escritura digital (A1, BAJA); pinMode (A2, SALIDA); escritura digital (A2, BAJA); pinMode (A3, SALIDA); escritura digital (A3, BAJA); pinMode (A4, SALIDA); escritura digital (A4, BAJA); pinMode (A5, SALIDA); escritura digital (A5, BAJA); pinMode (A6, SALIDA); escritura digital (A6, BAJA); pinMode (A7, SALIDA); escritura digital (A7, BAJA); pinMode (A8, SALIDA); escritura digital (A8, BAJA); pinMode (A9, SALIDA); escritura digital (A9, BAJA); pinMode (A10, SALIDA); escritura digital (A10, BAJA); pinMode (A11, SALIDA); escritura digital (A11, BAJA); pinMode (A12, SALIDA); escritura digital (A12, BAJA); pinMode (A13, SALIDA); escritura digital (A13, BAJA); pinMode (A14, SALIDA); escritura digital (A14, BAJA); } nullvoid loop () {digitalWrite (2, HIGH); // max 485 como salida Back_Light_Init (); Contrast_Init (); GUI_About (); GUI_Memory_Init (); } nullvoid Back_Light_Init () {// ultimo estado del byte de luz de fondo Back_Light_Value =EEPROM.read (513); analogWrite (Back_Light_PWM, Back_Light_Value); if (Back_Light_Value ==0) {Back_Light_On_Off =0; } si (Back_Light_Value> 0) {Back_Light_On_Off =1; }} void Contrast_Init () {// ultimo estado del byte de contraste 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 (Luz trasera_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; ir a la salida; } // apagar if (Back_Light_On_Off ==1) // si esta encendida apagarla {analogWrite (Back_Light_PWM, 0); Back_Light_On_Off =0; } salida:{retraso (300); // para impedir la repetición 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; ID de byte =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 ("Comprobador y controlador"); // Firmware lcd.setCursor (0, 2); lcd.print ("Firma 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); retraso (2000); // retardo de muestra de mensaje} nullvoid Multi_Matrix (int inicial) {// dibujar banco Numerico_Write (inicial, 13, 0); Numerico_Write (inicial + 14, 17, 0); // matriz 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); // matriz 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); // matriz 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 del cursor LCD_Row_Pos =0; // posicion e cursor // configuracion de cursor Cursor_Conf_Clear (); // limpiar matriz // Fila 0 Cursor_Conf [0] [4] =1; // Memoria Cursor_Conf [0] [8] =1; // Unidad Cursor_Conf [0] [12] =1; // Banco Inicial Cursor_Conf [0] [16] =1; // Banco Final // Fila 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; // Fila 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; // Fila 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 // Memoria if (LCD_Col_Pos ==4 &&LCD_Row_Pos ==0) {GUI_Memory (); goto inicio; } // Controlar si (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; si (Inicial ==1) Num_Val =15; más 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; ir a Salida_DMX; } // posicion 2 if (LCD_Col_Pos ==4 &&LCD_Row_Pos ==1) {Canal_Actual =Inicial + 1; ir a Salida_DMX; } // posicion 3 if (LCD_Col_Pos ==8 &&LCD_Row_Pos ==1) {Canal_Actual =Inicial + 2; ir a Salida_DMX; } // posicion 4 if (LCD_Col_Pos ==12 &&LCD_Row_Pos ==1) {Canal_Actual =Inicial + 3; ir a Salida_DMX; } // posicion 5 if (LCD_Col_Pos ==16 &&LCD_Row_Pos ==1) {Canal_Actual =Inicial + 4; ir a Salida_DMX; } // posicion 6 if (LCD_Col_Pos ==0 &&LCD_Row_Pos ==2) {Canal_Actual =Inicial + 5; ir a Salida_DMX; } // posicion 7 if (LCD_Col_Pos ==4 &&LCD_Row_Pos ==2) {Canal_Actual =Inicial + 6; ir a Salida_DMX; } // posicion 8 if (LCD_Col_Pos ==8 &&LCD_Row_Pos ==2) {Canal_Actual =Inicial + 7; ir a Salida_DMX; } // posicion 9 if (LCD_Col_Pos ==12 &&LCD_Row_Pos ==2) {Canal_Actual =Inicial + 8; ir a Salida_DMX; } // posicion 10 if (LCD_Col_Pos ==16 &&LCD_Row_Pos ==2) {Canal_Actual =Inicial + 9; ir a Salida_DMX; } // posicion 11 if (LCD_Col_Pos ==0 &&LCD_Row_Pos ==3) {Canal_Actual =Inicial + 10; ir a Salida_DMX; } // posicion 12 if (LCD_Col_Pos ==4 &&LCD_Row_Pos ==3) {Canal_Actual =Inicial + 11; ir a Salida_DMX; } // posicion 13 if (LCD_Col_Pos ==8 &&LCD_Row_Pos ==3) {Canal_Actual =Inicial + 12; ir a Salida_DMX; } // posicion 14 if (LCD_Col_Pos ==12 &&LCD_Row_Pos ==3) {Canal_Actual =Inicial + 13; ir a Salida_DMX; } // posicion 15 if (LCD_Col_Pos ==16 &&LCD_Row_Pos ==3) {Canal_Actual =Inicial + 14; ir a 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) // análogo {Analog_Read_DMX (Num_Col_Pos - 2, Num_Row_Pos); Num_Col_Pos =Num_Col_Pos - 4; ir al Banco; } si (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; ir al Banco; } void Cursor_Conf_Clear () {para (byte Conteo_Col =0; Conteo_Col <=19; Conteo_Col ++) {para (byte Conteo_Row =0; Conteo_Row <=3; Conteo_Row ++) {Cursor_Conf [Conteo_Row] [Conteo_Col] =0; }}} void GUI_Navegar (matriz de bytes, int banco) {Long Boton_Delay_Cursor =300; // retardo de lectura del byte boton LCD_Col_Pos_Ant; // saber el estado anterior para borrar el byte del cursor LCD_Row_Pos_Ant; // saber el estado anterior para borrar cursor // guardar valor anterior de fila col LCD_Col_Pos_Ant =LCD_Col_Pos; LCD_Row_Pos_Ant =LCD_Row_Pos; // Dibujar el 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 // Izquierda 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; }} ir a Salida; } // Derecha 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:{} }nullvoid 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 } }nullvoid 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; } }nullvoid 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); retraso (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; }nullvoid 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); retraso (300); // rebote de boton } }nullvoid 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 } 

User Input

At startup it presents options "Initial Memory", to set the initial values ​​of RAM

• The ">" indicates where the cursor is positioned on the menu

• The "+" and the blinking cursor, the numerical symbol indicates that user input is expected

• The navigation between menus are made from the cursor up, down, right, left and center that applies as "enter"

• When "Enter" is given in a menu that requires user input appears "+ ___" and the blinking cursor indicating the user input, in this case the keypad is used if the document number is less than 3 digits press " # "that functions as an" enter "on the number pad

• If it is a user entry where the value of a DMX channel is indicated, you can press (after giving "enter") key "A" that you type directly "255" (maximum value of a channel) or the "B" key you type directly "000" (the minimum value of a channel)

• The "C" key functions as a means for locating a luminaire or a specific channel, just enough to select a channel position in value, to "enter" and press "C", the value would sequence channel between "000 "and" 255 ", to stop press again return to" C "

• The "*" key on or off the back light

• The "D" active only for the analog potentiometer values, the key can enter the value by turning

• The "Ctrl" returns to the menu option "Control Options"

Initial Memory:

Sets the initial values of the RAM, EEPROM read from:

• Empty (EEPROM leave intact unmodified, all channels are in "000")

• Load (loading the values stored in the EEPROM of the DMX universe)

• Clear (erase the values stored in the EEPROM and leave the channels "000")

Control Options:

The user selects the control method of different DMX channels

• "Memory" Access memory options

• "Unitaryquick access to a specific channel

• "Matrix" display a matrix of 3 x 5 with the current values of the different channels

• "Chaser" make a specific sequence between channels

• "Multiply" assign a value to a specific number of channels, with a specific numerical jump

• "Config" access system settings

Unitary Control

It allows quick access to a specific channel

• "Channel" channel access

• "Value" access channel value

• "Ctrl" Accessing the menu "Control Options"

• "Memory" Access to the menu “Memory Options”

Matrix Control

Displays a matrix of 3 x 5 with the current values of different DMX channels

• "C ---" shows the number of the selected channel from the cursor

• "Mem" access "Memory Options"

• "Ctrl" access "Control Options"

• "001-015" access to the number of channels to be displayed in the matrix of 3 x 5, the first number represents the first channel and the second to the last channel

Chaser Control

Allows a specific sequence between channels

• "ChaserCH" shows the current value sequenced (after the start of sequence)

• "Delay", select the amount of time in mS (milliseconds) between each step, the value approximates the number by 10 =the number of mS

• "First CH", select the first channel of the sequence

• "Final CH". select the last channel in the sequence

• "Ctrl" access "Control Options", sequenced values do not affect the RAM out with the old values

• "Start" begins the sequence and switches to "Stop", here you can stop the sequence

Example:

Select "Delay" 100 (100x10 =1000 mS), "First CH" 001 and "Final CH" 512 The result is a sequence from channel 1 to 512 and the step between the channels makes every second

Multiply Control

Assign a value to a specific number of channels, with a specific numerical jump

• "Value" selects the value to be written (000-255)

• "First CH" selects the first channel

• "Multiply" selects the number of channels to multiply

• "Quantity" select the number of times to multiply

• "Ctrl" Access"Control Options", RAM affects channel

• "Memory" Access "Memory Options"

• "Apply" Evaluates the request is not possible the application displays the message "Error", otherwise apply multiplication channels and places the selected value

Example:

Select "Value" =255, "First CH" =001, "Multiply" =003 "Quantity" =170 and "Apply"

The result:170 channels from channel 1 to 510, 3 on 3 with the value 255

Memory Options

Easy access to the EEPROM options

• "Save" saves the DMX universe with current values

• "Load" load from EEPROM values previously saved DMX universe

• "Empty" Delete RAM with the current DMX values without affecting the EEPROM

• "Clear" Clear DMX universe stored in the EEPROM

• "Black" Options "Black Out", puts all channels of DMX universe with "000", without affecting the memory, to exit press "enter" or "central" and returns the above values

• Cancel (return to the previous menu without changes)

Config

Overall system configuration

• Located in"Control Options"

• "Backlight" Select dimmer value between 000-255 of the LCD backlight

• "Contrast" Select dimmer value between 150-255 LCD contrast (lower liite 150, to prevent the LCD not see)

• "Exit" returns to the previous menu

• The modified values are saved in EEPROM memory automatic

Acerca de

Displays the "About .." project and the hardware and firmware versions installed

• Located in "Config"

• To exit press "enter" or "center"

For more Information, updates repository...

// ***************************************************************************************************************************// ***************************************************************************************************************************// ** **// ** 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.m x/2012/12/arduino-componentes-para-o-proteus.html **// ** **// ** Autor:**// ** **// ** Daniel Roberto Becerril Angeles **// ** [email protected] ** **// ** https://github.com/daniel3514/Arduino-DMX-512-Tester-Controller/ **// ** **// ** Licenciamiento:**// ** **// ** GNU General Pubic Licence Version 3 **// ** https://www.gnu.org/copyleft/gpl.html **// ** **// ***************************************************************************************************************************// ***************************************************************************************************************************// 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 cha nnels) Completely non standard - TESTED ok //#define DMX2048 (2) // (1000 kbaud - 2 to 2048 channels) called by manufacturers DMX1000K, DMX 4x or DMX 1M ???// 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 apagadavoid 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); //tamao 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); } void loop() { digitalWrite(2, HIGH); // max 485 como salida Back_Light_Init(); Contrast_Init(); GUI_About(); GUI_Memory_Init(); }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); retraso (2000); //retardo de muestra de mensaje }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:{} }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) { } }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);...This file has been truncated, please download it to see its full contents.

Esquemas

Repository

https://github.com/daniel3514/Arduino-DMX-512-Tester-Controller