Paso 4: código
[código]
/*******************************************************
RSP Humpleby 2014
Proyecto - contador adaptable puede ser adaptado a cualquier máquina actual.
Beneficios:-
Cuenta de parte exacta y confiable capaz de enviar datos hacia otros lugares más.
Capaz de cerrar la máquina al final de cambio sobre
Puede decirle a operador cuando final de parte se hace ahorro de costos en "correr más"
Puede montar en posiciones menos propensos que los actuales contadores mecánicos.
Ahorro de costes a largo plazo.
Más confiable.
Excepcionalmente flexible puede ser programada para incluir funciones adicionales en la misma junta como máquina tempratures, automatizado de datos de luces, ethernet, llamada de registro, etc..
Todo el + 5v a + 20 máxima tensión.
Más barato que los contadores mecánicos.
Registros y sellos de tiempo mostrará donde contadores se resetear o adulterados.
Si los operadores son conscientes de esto pueden ser menos propensos a "fudge" números que cuentas mejor / más precisas.
También debería ser posible agregar función para incluir la barra / material tipo selección que resulta en mejores niveles de stock de partes específicas.
Puede establecerse para el operador (no seguro) o cambio de incremento de mantenimiento (seguro).
Entrada de sensor escudo actualmente para la demostración, pero modificado fácilmente para múltiples fuentes de inductivo, capacitivo, IR, micro, etc. etc..
Este programa actualmente para barra tijeras con tamaño de incremento variable (puede alojar cualquier incremento de 1 a 32.767 véase más arriba).
***********************************************************
Conoce limitaciones:-
Límite superior de la cuenta 32.767 debido a matematica de 8 bits (podría utilizar el flotador para ampliar contador).
Sensor pegado puede continuar cuenta pero mostrará fecha y hora donde esto sucedió, y esto ocurriría en otros contadores electrónicos.
Susceptible al ruido eléctrico alto. Debe ser en caso seleccionado / metal en la mayoría de las aplicaciones.
Requiere fuente de alimentación de 10 pies de MCU.
EEPROM write límite 100.000!!!!!! momento en el que la unidad necesita programa para 4 nuevas localidades de la EEPROM (512 disponible)
TO DO *****************************************************
Añadir EEPROM recuperar para la cuenta en caso de apagón
configurar menú de tamaño de paquete
configurar menú incremento
***********************************************************
Revisión
1.4 uso de matriz de cadena.
Auto ajuste incremento en solo para máquinas que no sean de corte (definido por orden de sting).
Añadir EEPROM escribir según la sugerencia de George
Añadir clara de EEPROM para reset legítimo (probablemente dos puntos)
1.3 había añadido a sugerencia de Andrew de la cuenta regresiva del paquete.
Añadida rutina para el perno alto final del paquete. señal del operador.
Añadido lista (array) para uso futuro.
1.2 incluido por cuenta.
Incremento de la cuenta agregada y límites inferiores superiores.
Salida serial mejorado.
1.1 basic contador función y sólo de reajuste.
********************************************************/
#include / / biblioteca de visualización
LiquidCrystal lcd (8, 13, 9, 4, 5, 6, 7); Seleccione los pines utilizados en el panel LCD
#include / / funciones de EEPROM
paquete de int = 1000; tamaño del paquete
int nm = 2; selección de máquina 0 = esquileo grande, 1 = pequeño corte etc etc.
int lcd_key = 0; valor de clave inicial
int adc_key_in = 0; configurar pin analógico para leer clave
int cuenta = 0; contar desde cero
int inc = 50; establecer incremento contador *** temp establecida en 50 para demostración solamente ***
deb int = 300; debounce 1er disparo falso factor (0,3 segundos)
del2 int = 100; debounce 2do disparo falso factor (0.1 segundos)
int led2 = 11; Utilice 11 como indicador de la señal de final de paquete
int addr = 0; configurar para escribir EEPROM
va5 int = 1234; sistema como una cuenta extraña para lectura de EEPROM y transferencia del paquete actualmente no utilizado
bd0 int = ((EEPROM.read(0)*4)); Leer valor de paquete de EEPROM utilizado actualmente no
nm0 int = ((EEPROM.read(1)*4)); Leer valor de nm de EEPROM utilizado actualmente no
ct0 int = ((EEPROM.read(2)*4)); Valor de la cuenta de lectura de EEPROM utilizado actualmente no
int in0 = ((EEPROM.read(3)*4)); Leer valor de inc de EEPROM utilizado actualmente no
#define btnRIGHT 0 / / permite disminuir pasos de cuenta (inc)
#define btnUP 1 / / inrement contar (inc)
#define btnDOWN 2 / / disminuir cuenta (Inc)
#define btnLEFT 3 / usados para incrementar medidas de conteo (inc)
#define btnSELECT 4 / usados para poner el contador a cero
#define btnNONE 5 / / utilizado sólo con fines de error
#define endloop 6 / / saltar al final de la rutina de paquete
#define reinicio / / aún no se ha iniciado
MÁQUINA lista (variable véase "nm") puede cambiar estos para satisfacer sus propias necesidades, pero pongo las máquinas haciendo varios cortes en el frente de la lista así que una corte podría ser 6 bares que es la base para la cuenta de incremento.
char * cad1 [] = {"esquileo grande 45", "corte pequeña 45", "Corte recto", "Prensa de la placa", "Forma de rodillo", "ESTAMPADOR", "Enhebrador de uno", "Enhebrador de dos",
"ME / MÁQUINA D", "PELADOR", "AUTO PERNO UNO", "AUTO PIN DOS", "MANUAL DE PERNO UNO", "MANUAL DE PERNO DOS", "ENCABEZADO", "SOLDADOR UNO", "SOLDADOR DOS", "SOLDADOR TRES"};
int read_LCD_buttons() / / leer los botones
{
reiniciar;
adc_key_in = analogRead(0); leer el valor del escudo
mis botones cuando están centradas en estos valies: 0 144, 329, 504, 741
Añadir aproximadamente 50 a esos valores y comprobar para ver si estamos cercanas
Si (nm > = 3) inc = 1; Si la máquina no esquileo entonces incremento = 1
Si (paquete < = 0) volver endloop;
Si (adc_key_in > 1000) vuelta btnNONE; generalmente sin interruptor accionado
BAR INC
Si (adc_key_in < 50 & & inc < = 10) inc inc = 1; aumentar la barra cuenta el tamaño de paso proporcionado no más de 10
EEPROM.write (3, inc); Tienda INC en EEPROM
Si (adc_key_in < 50) devuelve btnRIGHT;
CONTADOR INC
Delay(DEL2);
Si (paquete < = 0) volver endloop;
Si (adc_key_in < 250) cuenta = cuenta + inc; contador de incremento por "inc"
EEPROM.write (2, cuenta); Cuenta de almacén en EEPROM
Si (adc_key_in < 250) paquete = paquete - inc; reducir el tamaño de paquete
Si (adc_key_in < 250) vuelta btnUP;
Delay(DEL2);
CONTADOR DICIEMBRE
Si (paquete < = 0) volver endloop;
Si (adc_key_in < 450) cuenta = cuenta -inc; contador de decremento por "inc"
EEPROM.write (2, cuenta); Cuenta de almacén en EEPROM
Si (adc_key_in < 450) paquete paquete = inc; aumentar el tamaño del paquete
EEPROM.write (0, paquete); Paquete de tienda en EEPROM
Si (adc_key_in < 450) vuelve btnDOWN;
BARRA DEC
Delay(DEL2);
Si (paquete < = 0) volver endloop;
Si (adc_key_in < 650 & & inc > = 1) inc = inc - 1; tamaño de paso de decremento bar Conde
EEPROM.write (3, inc); Tienda INC en EEPROM
Si (adc_key_in < 650) vuelve btnLEFT;
ENDLOOP SALTO
Delay(DEL2);
Si (paquete < = 0) volver endloop;
RESET
Delay(DEL2);
Si (adc_key_in < 850) cuenta = 0; reiniciar contador
Si (adc_key_in < 850) paquete = 1000; paquete de RESET
para (int i = 0; i < 3; i ++) / / claro primeros 5 bytes de EEPROM
EEPROM.write (i, 0); claro los primeros 5 bytes de EEPROM
Si (adc_key_in < 850) vuelta btnSELECT;
volver btnNONE; en caso de error
}
void setup() / / INITALISE
{
Serial.Begin (9600); Configurar cuenta serial y remota usando "término cool"
mientras (!. Serie) {}
; Espere a que el puerto serial para conectar. Necesario sólo para Leonardo
}
LCD.Begin (16, 2); fijar número la pantalla del LCD de filas y columnas:
lcd.setCursor (0, 0); línea 1
LCD.Print ("c2014 JENMAR INC"); pantalla de bienvenida
lcd.setCursor (0, 1); línea 2
LCD.Print ("contador de adaptación"); pantalla de bienvenida
retrasar (5000); pausa de 10 segundos
LCD.Clear(); borrar la pantalla
lcd.setCursor (0, 0); línea 2
LCD.Print(Str1[Nm]); LOGO DE MÁQUINA STD
pinMode (led2, salida); definir la señal de
}
void loop() / / lazo principal
{
lcd.setCursor(0,1); mover al principio de la segunda línea
lcd_key = read_LCD_buttons(); leer los botones
interruptor (lcd_key) / / función de botón que se pulsa, realizamos una acción
{
btnRIGHT caso:
{
Si (inc > = 10) inc = 10; asegurar el límite superior
Serial.println(Str1[Nm]);
Serial.Print ("incremento =");
Serial.println(Inc);
retardo (deb); Debounce y paso de contador de incremento + 1
rotura;
}
btnLEFT caso:
{
Si (inc < = 0) inc = 1; asegurar un límite más bajo
Serial.println(Str1[Nm]);
Serial.Print ("decremento =");
Serial.println(Inc);
retardo (deb); Debounce decremento contador paso - 1
rotura;
}
caso btnUP:
{
LCD.Print(Count); contador de la exhibición más cuenta
LCD.Print ("BNDL >"); Paquete de texto
LCD.Print(bundle); Haz la cuenta
LCD.Print(""); espacios finales
Serial.println(Str1[Nm]);
Serial.Print ("a cuenta");
Serial.println(Count);
retardo (deb); Debounce
rotura;
}
btnDOWN caso:
{
LCD.Print(Count); contador de la exhibición menos cuenta
LCD.Print ("BNDL >"); Paquete de texto
LCD.Print(bundle); Haz la cuenta
LCD.Print(""); espacios finales
Serial.println(Str1[Nm]);
Serial.Print ("a cuenta");
Serial.println(Count);
retardo (deb); Debounce
rotura;
}
caso btnSELECT:
{
LCD.Print(Count); Mostrar el contador a cero
LCD.Print ("BNDL >"); Paquete de texto
LCD.Print(bundle); Haz la cuenta
LCD.Print(""); espacios finales
Serial.Print ("***");
Serial.Print (Str1[nm]);
Serial.Print ("RESET contador *** =");
Serial.println(Count);
para (int i = 0; i < 4; i ++) / / claro primeros 5 bytes de EEPROM
EEPROM.write (i, 0); claro los primeros 5 bytes de EEPROM
retardo (deb); Debounce
rotura;
}
caso endloop:
{
digitalWrite (led2, HIGH); encender la señal de fin de paquete
LCD.Clear(); borrar la pantalla
lcd.setCursor (0, 0); línea 1
LCD.Print («> final de paquete < "); pantalla de bienvenida
lcd.setCursor (0, 1); línea 2
LCD.Print ("* cambio sobre *"); pantalla de bienvenida
retardo (20000); pausa de 20 segundos
digitalWrite (led2, LOW); Apagar la señal de fin de paquete
paquete = 1000; paquete de RESET
cuenta = 0; reiniciar contador
para (int i = 0; i < 4; i ++) / / claro primeros 5 bytes de EEPROM
EEPROM.write (i, 0); claro los primeros 5 bytes de EEPROM
LCD.Clear(); borrar la pantalla
lcd.setCursor (0, 0); línea 1
LCD.Print(Str1[Nm]); LOGOTIPO DE ETS
lcd.setCursor(0,1); línea 2
rotura;
}
caso btnNONE:
{//lcd.print ("NONE"); tratar como una tecla normal
retardo (deb); Debounce
rotura;
}
caso epWRITE:
// {
Escribir copias de las variables críticas a EEPROM
int va0 = paquete / 4; variables de preparación para eeprom
int va1 = nm / 4; variables de preparación para eeprom
int va2 = recuento / 4; variables de preparación para eeprom
int va3 = inc / 4; variables de preparación para eeprom
EEPROM.write (0, va0); escribir en la eeprom
EEPROM.write (1, va1); escribir en la eeprom
EEPROM.write (2, va2); escribir en la eeprom
EEPROM.write (3, va3); escribir en la eeprom
// }
caso EPclear:
// {
Restablecimiento legítimo *** a fiar reset sección ***
Rutina claro EEPROM
para (int i = 0; i < 4; i ++) / / claro primeros 5 bytes de EEPROM
EEPROM.write (i, 0); claro los primeros 5 bytes de EEPROM
rotura;
// }
caso EPread:
// {
Leer y actualizar las variables de la EEPROM si existen y son diferentes de valor 0 o inicial
va0 = (EEPROM.read(0)*4); Valor paquete de lectura de EEPROM
paquete de int = va0 * 4; Establecer variables mediante eeprom
VA1 = (EEPROM.read(1)*4); Valor de la cuenta de lectura de EEPROM
int cuenta = va1 * 4; Establecer variables mediante eeprom
VA2 = (EEPROM.read(2)*4); Leer valor de nombre de máquina de EEPROM
int nm = va2 * 4; Establecer variables mediante eeprom
VA3 = (EEPROM.read(3)*4); Valor del incremento de lectura de EEPROM
int inc = va4 * 4; Establecer variables mediante eeprom
rotura;
// }
}
}
EXPRESIONES DEL FOLCLORE
[/ code]
