Paso 13:
/* */
/ * Título: olla de Imersion controlador * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * MCWSM * /
/* */
/ * Descripción: * /
/ * Este esbozo se ejecuta en la plataforma Arduino Uno * /
/ * con un escudo de 1602 SainSmart LCD/teclado * /
/ * Relé de estado sólido SainSmart dispositivo y LM35 * /
/ * sensor de temperatura. Está diseñado para control * /
/ * dos elementos comunes de calefacción y un pequeño * /
/ * bomba sumergible en una olla de inmersión. El * /
/ * usuario simplemente marca un temperatura fijada con el * /
/ * teclado y las luces estroboscópicas de contrioller la calefacción * /
/ * elementos para lograr y mantener el agua conjunto * /
/ * temperatura. */
/* */
/ * FUTURO: agregar funciones de temporizador/reloj * /
/* */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
#include < LiquidCrystal.h >
#define VERSION_STRING "1.0"
#define btnRIGHT 0
#define btnUP 1
#define btnDOWN 2
#define btnLEFT 3
#define btnSELECT 4
#define btnNONE 5
#define ELEMENT_1 2 / / elemento 1 puerto de control
#define ELEMENT_2 3 / 2 del elemento de control de Puerto
#define LED_PORT 13
#define THIRTY_SECONDS 30000; 30.000 microsegundos
#define KEYBOARD_PORT 0
#define TEMP_PORT 1
#define aumento 1
#define disminución -1
#define NO_CHANGE 0
#define seleccione 999
#define 0 CELSIUS
#define FARENHEIT 1
#define TEMP_COUNT 10
#define KEY_BOUNCE_DELAY 333
int iTempMode = FARENHEIT; por defecto a Farenheit...
int iSetTemp = 130; iSetTemp es global...
int iKeyPressIn = 0;
flotador fTemp [TEMP_COUNT]; matriz de suavizado de la temperatura global...
int iCurrentIndex = 0; iCurrentIndex es el índice global en matriz temp...
bDegreeSymbol Byte [8] = / / máscara de bits por símbolo °...
{
B11100,
B10100,
B11100,
B00000,
B00000,
B00000,
B00000,
B00000
};
bCheckMarkSymbol Byte [8] = / / máscara de bits por símbolo √...
{
B00000,
B00000,
B00000,
B00001,
B00010,
B10100,
B01100,
B01000
};
LiquidCrystal lcd (8, 9, 4, 5, 6, 7); inicializar la biblioteca con los números de los pines de interfaz
void setup()
{
/*****************************************************/
/* */
/ * Módulo: configuración * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Inicializa la pantalla LCD y splash se muestra * /
/ * pantalla. */
/ * Durante la secuencia de instalación, la temperatura del * /
/ * suavizado de array se inicializa con lecturas como * /
/ * bien. */
/* */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
String strLine1;
String strLine2;
String strElipses = ".";
lcd.createChar (0, bDegreeSymbol); Crear caracteres LCD
lcd.createChar (1, bCheckMarkSymbol);
LCD.Begin (16, 2); columnas de la pantalla de configuración LCD, filas...
DisplayLCD ("Arrancar...", "");
para (iIndex int = 0; iIndex < TEMP_COUNT; iIndex ++) / / instanciar la matriz de temperatura para alisar la señal...
{
fTemp [iIndex] = analogRead(TEMP_PORT);
fTemp [iIndex] = ((fTemp [iIndex] * 3.3) / 1023); 10 milivoltios por grado centígrado
Si (iTempMode == FARENHEIT)
{
fTemp [iIndex] = ConvertCelsiusToFarenheit(fTemp[iIndex]); / / convertir a Farenheit...
}
DisplayLCD ("Arrancar...", strElipses);
strElipses += ".";
Delay(100);
}
pinMode (ELEMENT_1, salida);
pinMode (ELEMENT_2, salida);
pinMode (LED_PORT, salida);
strLine1 = "Cocina de inmersión"; Crear y mostrar pantalla de bienvenida
strLine2 = "versión:";
strLine2 += VERSION_STRING;
DisplayLCD (strLine1, strLine2);
Delay(2000);
}
void loop()
{
/*****************************************************/
/* */
/ * Módulo: bucle * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Obtiene SetTemp nueva, si cualquier. A continuación, llama SetTemp * /
/ * a estroboscópico las resistencias para ajustar la * /
/ * temp. Entonces muestra la información de temperatura, retrasa a uno * /
/ * segundo luego vuelve. Evita la demora de la * /
/ * relés de estado sólidos de ser continuamente * /
/ * enciende y apaga. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
String strLCDLine0 = "";
String strLCDLine1 = "";
iSetTemp = GetSetTemp(iSetTemp); ver si el usuario quiere cambiar a temp...
SetTemp(iSetTemp); control de elementos de calefacción...
DisplayTemps (iSetTemp, GetCurrentTemp(), de '); exhibición de temps...
Delay(1000); no saturar RESS...
}
int GetSetTemp (int iSetTemp)
{
/*****************************************************/
/* */
/ * Módulo: GetSetTemp * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Lee el teclado para ver si los ajustes están siendo * /
/ * a la corriente set temp. El valor predeterminado es * /
/ * que ninguna tecla se depresión. Esto devuelve * /
/ * btnNone de ReadKeypad y los resultados en un * /
/ * retorno inmediato a la persona que llama. De lo contrario, el * /
/ * temperatura se ajusta correctamente y * /
/ * nueva temperatura ajustada. */
/* */
/ * Este módulo también permite al usuario entrar a * /
/ * un submenú donde el puede hacer cosas como cambiar * /
/ * el modo de funcionamiento de Farenheit a Celsius. */
/* */
/ * Si el usuario ha pulsado ninguna tecla para hacer temp * /
/ * ajustes, debe presionar la tecla * /
/ * para hacer los ajustes permanentes y retorno * /
/ * a la persona que llama. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
int iKeyIn;
int iNewSetTemp;
int iTempDelta; AUMENTO. DISMINUCIÓN, o seleccionar...
char cSetTemp [4];
Boolean bSelected = false;
char cTempMode = de ';
iNewSetTemp = iSetTemp; comenzar con temp actual...
iKeyIn = ReadKeypad();
Si (iKeyIn! = btnNONE) / / btnNONE = nada que ver, sólo volver a llamador...
{
hacer / hasta bSelected...
{
Switch(iKeyIn)
{
caso btnUP: / / ajustar la temperatura para arriba...
iNewSetTemp += 1;
cTempMode = 'A'; informar el ajuste del usuario en curso...
rotura;
btnDOWN caso: / / ajuste de temperatura hacia abajo...
iNewSetTemp-= 1;
cTempMode = 'A'; informar el ajuste del usuario en curso...
rotura;
btnLEFT caso:
iNewSetTemp = Menu(); menú de opciones...
bSelected = true; salir una vez que las opciones del menú completan...
rotura;
caso btnSELECT: / / ajustes completan...
bSelected = true;
rotura;
default: / / ignora otras teclas...
rotura;
}
DisplayTemps (iNewSetTemp, GetCurrentTemp(), cTempMode); Mostrar cada ajuste como ocurre...
Delay(KEY_BOUNCE_DELAY); Lisa un rebote clave...
iKeyIn = ReadKeypad(); interno Lee lazo...
} mientras (! bSelected);
}
Return(iNewSetTemp);
}
void SetTemp(int iSetTemp)
{
/*****************************************************/
/* */
/ * Módulo: SetTemp * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Este módulo compara el parámetro iSetTemp * /
/ * la temp actual. Si hay más de uno * /
/ * variación de grado, convierte los elementos de calefacción * /
/ * activar o desactivar según corresponda. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
int iCurrentTemp;
iCurrentTemp = GetCurrentTemp(); ver a temperatura actual...
Si (abs (iSetTemp - iCurrentTemp) > = 1) / / si la temperatura varía por más de 1 grado
{
Si (iCurrentTemp > iSetTemp) / / if temp demasiado alta y desactivar elementos de calefacción
{
digitalWrite (ELEMENT_1, bajo);
digitalWrite (ELEMENT_2, bajo);
digitalWrite (LED_PORT, bajo);
}
otra cosa
{
digitalWrite (ELEMENT_1, alto); Si temp demasiado baja, vuelta en elementos de calefacción
digitalWrite (ELEMENT_2, alto);
digitalWrite (LED_PORT, alto);
}
}
}
int GetCurrentTemp()
{
/*****************************************************/
/* */
/ * Módulo: GetCurrentTemp * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Este módulo lee la temperatura actual de la * /
/ * sensor y la almacena para el suavizado de la señal * /
/ * array. La temperatura del sensor es en * /
/ * Celsius y convertir a Farenheit según sea necesario * /
/ * por el modo de funcionamiento actual. Es el usuario * /
/ * Devuelve un entero que representa el alisado * /
/ * (es decir, promedio de los temps de la matriz) * /
/ * temperatura. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
int iReturnTemp = 0;
Float fCumulativeTemp = 0;
Float fADCIn;
Si ((iCurrentIndex) == TEMP_COUNT) / / permanecer dentro de límites de matriz...
{
iCurrentIndex = 0;
}
fADCIn = analogRead(TEMP_PORT); obtener la señal de temperatura del sensor...
Si (iTempMode == c) / / hacer la conversión a grados Celsius...
{
fTemp [iCurrentIndex] = (((fADCIn * 3.7) / 1024) * 100);
}
otra cosa
{
fTemp [iCurrentIndex] = fADCIn; lectura recta es en farenheit...
}
para (iIndex int = 0; iIndex < TEMP_COUNT; iIndex ++) / / suma el último X lecturas...
{
fCumulativeTemp += fTemp [iIndex];
}
iReturnTemp = ((int)(fCumulativeTemp / TEMP_COUNT)); volver a alisado temp...
iCurrentIndex ++; Índice de golpe para próxima convocatoria...
Return(iReturnTemp);
}
void DisplayTemps (int iSetTemp, int iCurrentTemp, char cTempMode)
{
/*****************************************************/
/* */
/ * Módulo: DisplayTemps * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Este módulo muestra dos líneas de temperaturas * /
/ * en la pantalla LCD. El primero es el set temp * /
/ * y es basada en si somos * /
/ * ajuste, o sea la temperatura. El * /
/ * segunda línea de la pantalla siempre la actual * /
/ * temperatura. */
/* */
/ * Si este módulo es llamado continuamente, el * /
/ * parpadeará por lo que la persona que llama debe demorar entre * /
/ * llamadas. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
String strLine1;
String strLine2;
Si (cTempMode == 'A') / / modo de ajuste...
{
strLine1 = "ajuste:";
}
otra cosa
{
strLine1 = "establece:"; Modo de ajuste de...
}
strLine1 += iSetTemp;
strLine2 = String ("actual:");
strLine2 += iCurrentTemp;
LCD.Clear();
lcd.setCursor (0, 0);
LCD.Print(strLine1);
LCD.Write(byte(0)); símbolo de grado...
Si (iTempMode == FARENHEIT)
{
LCD.Print("F");
}
otra cosa
{
LCD.Print("C");
}
lcd.setCursor (0, 1);
LCD.Print(strLine2);
LCD.Write(byte(0));
Si (iTempMode == FARENHEIT)
{
LCD.Print("F");
}
otra cosa
{
LCD.Print("C");
}
}
DisplayLCD vacío (String strLine0, String strLine1)
{
/*****************************************************/
/* */
/ * Módulo: DisplayLCD * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Este módulo muestra dos líneas el texto en la pantalla * /
/ * Mostrar. */
/ * Si este módulo es llamado continuamente, el * /
/ * parpadeará por lo que la persona que llama debe demorar entre * /
/ * llamadas. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
LCD.Clear();
Si (strLine0.length() > 0)
{
lcd.setCursor (0, 0);
LCD.Print(strLine0);
}
Si (strLine1.length() > 0)
{
lcd.setCursor (0, 1);
LCD.Print(strLine1);
}
}
int ReadKeypad()
{
/*****************************************************/
/* */
/ * Módulo: ReadKeypad * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Lee el teclado SainSmart. Si el usuario * /
/ * presiona una tecla, se devuelve un valor. El valor * /
/ * puede variar de dispositivo a dispositivo. Así, nos * /
/ * determinar el valor de ver si estamos cerca * /
/ * el valor de leer. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
int iKeyIn = analogRead(KEYBOARD_PORT);
Si (iKeyIn > 1000) / / esto es lo más a menudo resultado...
{
volver btnNONE;
}
else if (iKeyIn < 50)
{
Delay(KEY_BOUNCE_DELAY); manejar claves de rebote...
volver btnRIGHT;
}
else if (iKeyIn < 195)
{
Delay(KEY_BOUNCE_DELAY); manejar claves de rebote...
volver btnUP;
}
else if (iKeyIn < 380)
{
Delay(KEY_BOUNCE_DELAY); manejar claves de rebote...
volver btnDOWN;
}
else if (iKeyIn < 555)
{
Delay(KEY_BOUNCE_DELAY); manejar claves de rebote...
volver btnLEFT;
}
else if (iKeyIn < 790)
{
Delay(KEY_BOUNCE_DELAY); manejar claves de rebote...
volver btnSELECT;
}
otro retorno btnNONE; Si todo falla...
}
int Menu()
{
/*****************************************************/
/* */
/ * Módulo: menú * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Este módulo permite al usuario * /
/ * acceder a otras funciones dentro de la * /
/ * cocina de inmersión. Para la versión 1.0 es limitado * /
/ * para cambiar el modo de funcionamiento entre Farenheit * /
/ * y grados Celsius. Para el futuro, esto incluye * /
/ * acceder a las funciones del reloj. */
/ * Este módulo devuelve una vez el botón Select * /
/ * deprimido. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
int iKeyIn;
Boolean bSelected = false;
int iStartingTempMode = iTempMode;
DisplayLCD ("C", "Fahrenheit"); comenzar mostrando la configuración actual...
Si (iTempMode == CELSIUS)
{
lcd.setCursor (10, 0);
}
otra cosa
{
lcd.setCursor (10, 1);
}
LCD.Write(byte(1)); exhibición de la marca de verificación para la opción actual...
hacer
{
iKeyIn = ReadKeypad(); Haz la selección del usuario...
Switch(iKeyIn)
{
caso btnUP:
DisplayLCD ("C", "Fahrenheit");
lcd.setCursor (10, 0);
LCD.Write(byte(1)); exhibición de la marca de verificación para la opción seleccionada...
iTempMode = grados CELSIUS;
rotura;
btnDOWN caso:
DisplayLCD ("C", "Fahrenheit");
lcd.setCursor (10, 1);
LCD.Write(byte(1)); exhibición de la marca de verificación para la opción seleccionada...
iTempMode = FARENHEIT;
rotura;
caso btnSELECT: / / Esto termina el menú e implementa la acción solicitada...
bSelected = true;
rotura;
default: / / ignora otras teclas...
rotura;
}
Delay(KEY_BOUNCE_DELAY);
} mientras (! bSelected);
Si (iTempMode! = iStartingTempMode) / / si cambiamos los modos...
{
Si (iTempMode == CELSIUS)
{
iSetTemp = iSetTemp (int) ConvertFarenheitToCelsius((float)); convertir iSetTemp a Celsius para propósitos de la exhibición...
}
otra cosa
{
iSetTemp = iSetTemp (int) ConvertCelsiusToFarenheit((float)) ;// iSetTemp convertir a Farenheit para propósitos de la exhibición...
}
ConvertTempSmoothingArray(iTempMode); convertir al temps en la temperatura alisado gama...
}
Return(iSetTemp);
}
void ConvertTempSmoothingArray(int iNewTempMode)
{
/*****************************************************/
/* */
/ * Módulo: ConvertTempSmoothingArray * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Este módulo ciclos a través de la temperatura * /
/ * suavizar la matriz de conversión de temperaturas entre * /
/ * Farenheit y Celsius basados en el nuevo * /
/ * modo de operación seleccionado. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
iIndex int = 0;
Switch(iNewTempMode)
{
caso FARENHEIT:
para (iIndex int = 0; iIndex < TEMP_COUNT; iIndex ++) / / para cada temperatura de la matriz de suavizado...
{
fTemp [iIndex] = ConvertCelsiusToFarenheit(fTemp[iIndex]); convertir a Farenheit...
}
rotura;
caso c:
para (iIndex int = 0; iIndex < TEMP_COUNT; iIndex ++) / / para cada temperatura de la matriz de suavizado...
{
fTemp [iIndex] = ConvertFarenheitToCelsius(fTemp[iIndex]); convertir a Celsius...
}
rotura;
por defecto:
rotura;
}
}
flotador ConvertCelsiusToFarenheit(float fCelsiusTemp)
{
/*****************************************************/
/* */
/ * Módulo: ConvertCelsiusToFarenheit * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Este módulo convierte una temperatura en Celsius * /
/ * a Farenheit * /
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
volver ((fCelsiusTemp * 1.8) + 32.0);
}
flotador ConvertFarenheitToCelsius(float fFarenheitTemp)
{
/*****************************************************/
/* */
/ * Módulo: ConvertFarenheitToCelsius * /
/ * Versión: 1.0 * /
/ * Versión fecha: 01/05/2012 * /
/ * Autor: Edward A Ranzenbach * /
/ * Descripción: * /
/ * Este módulo convierte una temperatura de * /
/ * Farenheit a Celsius. */
/ * Historia: * /
/* */
/ * 2012-05-01 - Edward A Ranzenbach * /
/ * Codificación inicial * /
/* */
/*****************************************************/
volver ((fFarenheitTemp-32.0) *. 555);
}
