se que es una tontería pero he conseguido que lea el sensor a través del puerto serial dentro de CAO_01.
Código:
/**** CAO_SETA.ino ****/
/*******************************************************************************************************
* CaoSeta: CAO (S)imple (E)lectric (T)imer (A)rduino
* (C) Antonio Castro Snurmacher (15-feb-2016) (http://ciberdroide.com/cao/)
* Licencia de uso: Creative Commons Attribution-NonCommercial-ShareAlike
* (Versión BETA: probada en Linux con el IDE 1.6.7 de Arduino)
*******************************************************************************************************/
/*********************************************************************************************************
CaoSeta fue diseñado para funcionar como un programador electrico básico para acuarios basado en Arduino
Foro de CaoSeta:
http://acuariofiliamadrid.org/Thread-Dise%C3%B1o-de-un-programador-b%C3%A1sico-de-acuario-con-arduino
Se trata de un programador para 8 salidas digitales. La programación de las salidas se realizará editando
la función "SetPinsProgram()":
Primero hay que configurar el Pin de la salida estableciendo:
1) El tipo de funcionamiento inticando EstadoPorDefecto=LOW para un
funcionamiento normal. (En reposo estado a Low)
2) Los dias de la semana hábiles. (lo habitual es que todos los días de la semana sean hábiles)
En segundo lugar se definen los pulsos indicando el Pin, momento de comienzo del pulso, y duración del mismo.
Para poner en hora el sistema o para hacer pruebas ha de arrancarse el programa abriendo el terminal Serial
que mostrará un menú de opciones. Este puede ser visualizado siempre que queramos introduciendo 'H'
*********************************************************************************************************/
#include <Arduino.h>
#include <Wire.h> // I2C
// #include "ProgChar.h"
#include "CaoSeta_RTC_DS3231.h"
#include "CaoSeta_ProgPins.h"
#include "CaoSeta_Turn.h"
#include <OneWire.h>
#include <DallasTemperature.h>
// Variables globales para leer el RTC
bool verano;
byte year, month, dayOfMonth, dayOfWeek, hour, minute, second;
#define Pin 2 //Se declara el pin donde enviaré los datos d18b20
OneWire ourWire(Pin); //Se establece el pin declar
DallasTemperature sensors(&ourWire); //Se instancia la librería DallasTemperature
// *****************************************************************************************
// MODIFIQUE ESTE EJEMPLO PARA ESTABLECER UNA PROGRAMACION DIFERENTE.
// Consulte los comentarios de las funciones ConfigurarPin() y CrearPulso() en el fuente
// del modulo CaoSeta_ProgPins.cpp.
// *****************************************************************************************
// Aquí hay que programar los pulsos sobre los pines. (tiempo a estado activo)
// Salvo casos especiales los Pines deben configurarse para que su estado por defecto
// (estado en ausencia pulso activo) sea el estado LOW.
//
// Originalmente el código de esta funcion viene con un ejemplo para hacer pruebas.
// *****************************************************************************************
void SetPinsProgram(){
ProgPins.ConfigurarPin(4, HIGH);
ProgPins.ConfigurarPin(5, HIGH);
ProgPins.ConfigurarPin(6, HIGH);
ProgPins.ConfigurarPin(7, HIGH);
ProgPins.CrearPulso(4, 13, 54, 0, 8, 5, 40); // Activar rele INT1 21:59
ProgPins.CrearPulso(5, 13, 55, 0, 8, 15, 40); // Activar rele INT1 22:10
ProgPins.CrearPulso(6, 13, 57, 0, 8, 40, 0); // Activar rele INT3 22:37
ProgPins.CrearPulso(7, 13, 58, 0, 8, 0, 0);// Activar rele INT4 - 21:58
}
// ************ freeMemory() ***********************
extern unsigned int __heap_start;
extern void *__brkval;
/*
* The free list structure as maintained by the
* avr-libc memory allocation routines.
*/
struct __freelist {
size_t sz;
struct __freelist *nx;
};
/* The head of the free list structure */
extern struct __freelist *__flp;
/* Calculates the size of the free list */
int freeListSize() {
struct __freelist* current;
int total = 0;
for (current = __flp; current; current = current->nx) {
total += 2; /* Add two bytes for the memory block's header */
total += (int) current->sz;
}
return total;
}
// ****************************************************
// Informa de la cantidad de memoria SRAM disponible
// ****************************************************
int freeMemory() {
int free_memory;
if ((int)__brkval == 0) {
free_memory = ((int)&free_memory) - ((int)&__heap_start);
} else {
free_memory = ((int)&free_memory) - ((int)__brkval);
free_memory += freeListSize();
}
return free_memory;
}
// *****************************************************************************************
// Mostrar fecha hora en formato ES 'DD/MM/YYYY hh:mm:ss' por el puerto Serial
// *****************************************************************************************
void Serial_DDMMYYhhmmss(int DD, int MM, int YY, int hh, int mm, int ss){
char Cad[24];
snprintf(Cad, sizeof(Cad), "%02d/%02d/20%02d %02d:%02d:%02d ",
DD, MM, YY, hh, mm, ss);
Serial.print(Cad);
}
// *****************************************************************************************
void SerialPrintLnAsteriscos(){
for (int i=0; i<71; i++){
Serial.print('*');
}
Serial.println();
}
// *****************************************************************************************
// Ayuda a la introduccion de datos para puesta en hora
// *****************************************************************************************
void HelpIntro(){
Serial.println();
SerialPrintLnAsteriscos(); // ************************************************************
Serial.print(F("CaoSeta: V1.0 (Beta). Ultima compilacion: "));
Serial.print(__DATE__);
Serial.print(' ');
Serial.println(__TIME__);
Serial.print(F("PRIMER_PIN="));
Serial.print(PRIMER_PIN);
Serial.print(F(", MAXNUM_PINS="));
Serial.print(MAXNUM_PINS);
Serial.print(F(", MAXNUM_PULSOS="));
Serial.print(MAXNUM_PULSOS);
Serial.print(F(", Memoria libre="));
Serial.println(freeMemory());
SerialPrintLnAsteriscos(); // ************************************************************
Serial.println(F("**** M E N U ****"));
SerialPrintLnAsteriscos(); // ************************************************************
Serial.println(F("1) Para visualizar esta ayuda introduzca una 'H'."));
Serial.println(F("2) Para (A)justar fecha y hora del reloj interno introduzca una 'A'"));
Serial.println(F(" seguida de un blanco y seis numeros separados por blancos. Por ejemplo:"));
Serial.println(F(" 'A 31 12 15 23 59 59' para 31/12/2015 23:59:59."));
Serial.println(F("3) Para visualizar un (I)nforme de diagnostico introduzca una 'I'."));
Serial.println(F("4) Para pasar de modo (V)erbose a noVerbose y viceversa introduzca 'V'."));
SerialPrintLnAsteriscos(); // ************************************************************
Serial.println(F("temperatura d18b20"));//
Serial.print(sensors.getTempCByIndex(0)); //Se lee e imprime la temperatura en grados Celsius
Serial.println(" grados Centigrados");
delay (1000);
}
// *****************************************************************************************
// Permite poner en hora el RTC.
// *****************************************************************************************
void SetDateTime(){
bool ErrIntro;
byte second, minute, hour, dayOfMonth, month, year;
dayOfMonth = Serial.parseInt();
month = Serial.parseInt();
year = Serial.parseInt(); // los dos últimos dígitos de año 20XX
hour = Serial.parseInt();
minute = Serial.parseInt();
second = Serial.parseInt();
while( Serial.available() > 0 && Serial.read() != -1 ); // leer el sobrante de la entrada Serial
if ((second+minute+hour+dayOfMonth+month+year)==0){ // Si pulsó directamente <Intro>
return; // salir
}
// En caso contrario tenemos datos que hay que validar.
ErrIntro=false;
if (!RTC.LegalDate(year, month, dayOfMonth )){
Serial.print(F("Fecha erronea: "));
ErrIntro=true;
}
if(!RTC.LegalTime(hour, minute,second)){
Serial.print(F("Hora erronea: "));
ErrIntro=true;
}
Serial_DDMMYYhhmmss(dayOfMonth, month, year, hour, minute, second);
Serial.println();
if (ErrIntro){
Serial.print(F("\nNo se hizo ajuste del RTC. Vuelva a intentarlo\n"));
HelpIntro();
}
else{ // Entrada Ok
Serial.print(F("\nFecha y hora Ok. Ajustamos RTC.\n\n"));
RTC.setDateTime(year, month, dayOfMonth, hour, minute, second ); // Actualizar fecha y hora
}
}
// *****************************************************************************************
// Muestra la lista de configuracion de salidas, la hora actual, indica el estado de cada
// una de las salidas y en caso de estar activa indica cual es el pulso que la mantiene
// activa y su definición.
// *****************************************************************************************
void Informe(){
Serial.println();
Serial.println(F("------------------------"));
Serial.println(F("---- Informe ----"));
Serial.println(F("-----------------------"));
RTC.readDateTime(&verano, &year, &month, &dayOfMonth, &dayOfWeek, &hour, &minute, &second);
Serial_DDMMYYhhmmss(dayOfMonth, month, year, hour, minute, second);
ProgPins.Serial_OutputStatus();
Serial.println();
ProgPins.ListConfPins();
Serial.println();
Serial.println(F("------------------------"));
Serial.println();
}
// *****************************************************************************************
// Mira si hay algo en la entrada del monitor Serial y procesa la entrada.
// *****************************************************************************************
void GetMonitorSerial(){
if( Serial.available() > 0 ) {
char ch=Serial.read();
switch(ch){
case 'h':
case 'H':
HelpIntro(); // Mesaje de ayuda
break;
case 'a':
case 'A':
SetDateTime(); // Poner en hora
break;
case 'i':
case 'I':
Informe(); // Sacar informe
break;
case 'v':
case 'V':
ProgPins.SwitchVerbose(); // Pasar de veerbose a no verbise y viceversa
break;
default:
Serial.print(F("Error: Comando '"));
Serial.print(ch);
Serial.println(F("' desconocido. Pruebe con el comando 'H' ('H'=help)."));
Serial.println();
}
while (Serial.available()) Serial.read(); // El resto de la entrada es basura y se descarta.
}
}
// ********************************************************************************************
// Si el RTC no contiene datos válidos hay que introducir al gún dato válido.
// ********************************************************************************************
bool VerificarRTC(){
RTC.readDateTime(&verano, &year, &month, &dayOfMonth, &dayOfWeek, &hour, &minute, &second);
bool ErrDate= !RTC.LegalDate(year, month, dayOfMonth) ;
bool ErrTime= !RTC.LegalTime(hour, minute, second) ;
bool ErrDWeek= ((dayOfWeek<1) || (dayOfWeek>7)) ;
// Si no hay ningun error ya hemos terminado
if (!ErrDate && !ErrTime && !ErrDWeek){
return true;
}
// Informamos del tipo de errores encontrados en el RTC.
if ( ErrDate){
Serial.print(F("year="));
Serial.print(year);
Serial.print(F(" month="));
Serial.print(month);
Serial.print(F(" dayOfMonth="));
Serial.println(dayOfMonth);
Serial.println(F(" RTC contiene una fecha invalida."));
}
if (ErrTime) {
Serial.print(hour);
Serial.print(':');
Serial.print(minute);
Serial.print(':');
Serial.print(second);
Serial.println(F(" RTC contiene una hora invalida."));
}
if ( ErrDWeek ){
Serial.print(F("Dia de la semana="));
Serial.print(dayOfWeek);
Serial.println(F(" invalido."));
}
// Si la fecha y la hora son le gales pero el día de la semana no lo es, solo
// modificaremos el dia de la semana y retornamos false
if (!ErrDate && !ErrTime && ErrDWeek){
Serial.println(F("AVISO: Se ha recalculado el dia de la semana."));
RTC.setDateTime(year, month, dayOfMonth, hour, minute, second ); // Actualizar fecha y hora
return false; // para forzar una nueva verificación
}
// En caso contrario, como último recurso, vamos a cargar la fecha y hora de compilación.
Serial.println(F("AVISO: En ausencia de datos validos., Se toma como fecha y hora la"));
Serial.println(F("que figura como momento de la ultima compilacion del programa."));
RTC.SetCompilerDateTime();
return false; // para forzar una nueva verificación
}
// *****************************************************************************************
// **** SETUP ****
// *****************************************************************************************
void setup() {
Wire.begin();
Serial.begin(9600);
sensors.begin(); //Se inician los sensores
while (!Serial) ; // Necesario esperar para Arduino leonardo y Arduino Pro Micro.
// Verificamos el RTC y si no viene con fecha y hora válidas, forzaremos su inicio
// con una fecha y hora válidas.
while (! VerificarRTC()){
delay(5000);
}
SetPinsProgram();
Turn.EveryMillis(1000);
HelpIntro();
}
// *****************************************************************************************
// **** MAIN LOOP ****
// *****************************************************************************************
void loop(){
GetMonitorSerial(); // Si hay conexion serial permite ajuste
if (Turn.Shoot(1)){ // Si ya le toca el turno (cada segundo)...
// ... actualizar estado de las salidas
RTC.readDateTime(&verano, &year, &month, &dayOfMonth, &dayOfWeek, &hour, &minute, &second);
ProgPins.ActualizarEstadoPins(dayOfWeek, hour, minute, second);
if (Turn.Shoot(15)){ // Si ya le toca el turno (cada 15 seg)...
// ... mostrar Fecha Hora y estado salidas.
Serial_DDMMYYhhmmss(dayOfMonth, month, year, hour, minute, second);
ProgPins.Serial_OutputStatus();
delay (500); //espera 3 segundos para la siguiente medicion
sensors.requestTemperatures(); //Prepara el sensor para la lectura
Serial.print(sensors.getTempCByIndex(0)); //Se lee e imprime la temperatura en grados Celsius
Serial.println(" grados Centigrados");
delay (500); //espera 3 segundos para la siguiente medicion
}
}
}
muchas gracias Antonio, aunque en ocasiones no entiendo muy bien las explicaciones
![[Imagen: Xw22Dve.jpg]](https://i.imgur.com/Xw22Dve.jpg)
se que es una tontería pero he conseguido que lea el sensor a través del puerto serial dentro de CAO_01.
)