- Puedes pasar a votar a los participantes -
Enviar respuesta 
 
Calificación:
  • 0 voto(s) - 0 Media
  • 1
  • 2
  • 3
  • 4
  • 5
Programación C desde Cero.
08-02-2016, 11:37 PM
Mensaje: #121
RE: Programación C desde Cero.
entendido....gracias


a otra linea...a la que la estoy dando vueltas es a : while(!pc);
a si esta en el programa.
******************************************************
//Prepara la conexion Serial al PC
pc.begin(9600);
while(!pc);
pc.println("Comunicacion Serial iniciada");
*********************************************************
por lo que he leído. while es un bucle de ejecución continua.
mientras se cumpla continua ejecutandose.

! (operador lógico) NOT

no entiendo su función dentro del programa.
he quitado la linea. la he modificado (while(!Serial);
y no veo cambios
¿puede ser que este puesta para futuros cambios en el programa?
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
09-02-2016, 11:51 AM
Mensaje: #122
RE: Programación C desde Cero.
Eso es esquivalente a
while (!Serial) ;

Totalmente innecesario en la mayoría de los Arduinos pero no así en Arduino Leonardo o Arduino Micro.

En la mayoría de los programas el Arduino vuelve a empezar la ejecucion del programa desde el principio cuando el puerto Serial se abre, pero no en Arduino Leonardo y los que usan su procesador atmega 32u4.

Si no pones la espera perderás parte de la salida porque el puerto se abrirá mas tarde ignorando las ordenes destinadas al puerto hasta que logre abrirlo poco después.
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
09-02-2016, 03:01 PM
Mensaje: #123
RE: Programación C desde Cero.
como siempre muchas gracias
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
10-02-2016, 09:11 PM
Mensaje: #124
RE: Programación C desde Cero.
Voy a comentar un poco sobre un tipo de dato que se construye reservando memoria para un número de elementos sencillos del mismo tipo.

Vamos a usar el término inglés array porque en español se ha traducido por diferentes palabras tales como arreglos, matrices o vectores y cuando el tipo de los elementos del array es un caracter se le suele denominar cadena de caracteres.

El array es una construcción que consiste en crear una estructura con un tipo de dato que se repite tantas veces como nosotros queramos.

La forma de declarar un array es la siguiente:

tipo_de_dato nombre_del_array[ dimensión ];

Ejemplos:

char Linea[81];
int Temp[20];

Tomemos la última declaración. Es como si creáramos 20 variables de tipo entero y en lugar de tener que guardar los 20 valores uno por uno en una variable, cada una con un nombre diferente, podemos usar el nombre del array y un índice entre corchetes [ ].

El primer elemento siempre será en elemento 0, y el último será el tamaño del array -1. Es decir que en nuestra variable Temp (de tipo array de 20 enteros) podremos guardar el primer valor en Temp[0] y el último en Temp[19].

Imaginemos que tenemos un bucle de lectura para el pin A2.

Código:
#define TAM_ARRAY 20
int Temp[TAM_ARRAY];
for (int i=0; i<TAM_ARRAY; i++){
        Temp[i]=analogRead(A2);
}

Con ello ya tenemos los 20 valores guardados en el Array.
Para tratarlos o visualizarlos podemos hacerlo tambien usando

Código:
for (int i=0; i<TAM_ARRAY; i++){
       // Hacemos lo que sea con Temp[i]
}

Por ejemplo podemos calcular el valor promedio, la desviación estándar, podemos localizar el valor máximo y el valor mínimo, podemos usar algún algoritmo para ordenar el array, etc.

Con esto estaría dicho lo principal, pero como es lógico hay bastante más y un sitio en el que viene bien explicado es en: http://www.elrincondelc.com/cursoc/cursoc10.html#intro

Si alguno se anima a hacer alguna prueba con arrays podemos seguir profundizando en el tema y resolviendo duda porque solo leyendo es complicado aprender programación.
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
21-03-2016, 08:56 AM
Mensaje: #125
RE: Programación C desde Cero.
tengo barias dudas sobre como conseguir meter mas datos
e lcaso es que estoy utilizando el CaoSeta v1.0 (zip 2.5Mb)
que nos paso Antonio en este post y me gustaría ir poco a poco complicando.
He comenzado tratando de meter una sonda de temperatura dallas18b20 y me han surgido un montón de dudasfasConfused

voy a empezar a dar la tabarra-pardon.gif

preguntas :
-¿Las librerías se ponen antes de las que ya están, después o da igual mientras estén al principio del código?
Cita:¿¿¿¿¿¿?????
#include <Arduino.h>
#include <Wire.h> // I2C
// #include "ProgChar.h"
#include "CaoSeta_RTC_DS3231.h"
#include "CaoSeta_ProgPins.h"
#include "CaoSeta_Turn.h
¿¿¿¿????

- ¿donde debemos declarar los pines en esta parte?
Cita:void SetPinsProgram(){
ProgPins.ConfigurarPin(4, LOW);
ProgPins.ConfigurarPin(5, HIGH);
¿¿¿¿¿?????

Supongo que ¿no es necesario iniciar la comunicación serial para poder luego leer la temperatura? porque eso ya esta echo para el resto del código.
Visita su sitio web Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
21-03-2016, 11:04 AM (Este mensaje fue modificado por última vez en: 21-03-2016 11:08 AM por Antonio Castro.)
Mensaje: #126
RE: Programación C desde Cero.

(21-03-2016 08:56 AM)pedmar escribió:  tengo barias dudas sobre como conseguir meter mas datos
e lcaso es que estoy utilizando el CaoSeta v1.0 (zip 2.5Mb)
que nos paso Antonio en este post y me gustaría ir poco a poco complicando.
He comenzado tratando de meter una sonda de temperatura dallas18b20 y me han surgido un montón de dudasfasConfused

voy a empezar a dar la tabarra-pardon.gif

preguntas :
-¿Las librerías se ponen antes de las que ya están, después o da igual mientras estén al principio del código?
Cita:¿¿¿¿¿¿?????
#include <Arduino.h>
#include <Wire.h> // I2C
// #include "ProgChar.h"
#include "CaoSeta_RTC_DS3231.h"
#include "CaoSeta_ProgPins.h"
#include "CaoSeta_Turn.h
¿¿¿¿????

Los includes expanden el código del fichero en el lugar del programa donde lo coloquemos. Los ficheros *.h son headers (cabeceras). Contienen declaraciones de cosas que van a usarse. (declaraciones de variables u objetos, de definicines de constante de prototipos de funciones, etc.)

Dado que las librerías suelen ser independientes entre sí, da igual el orden donde se incluyan. El lugar siempre antes de usar algo de ellas, así que habitualmente, salvo algunos comentarios de cabecera se ponen los includes antes de cualquier otra cosa y así además nos sirve para conocer las dependencias.

En Arduino, estos includes en el módulo principal cumplen una segunda función. Hay que poner todos los módulos que van a ser necesarios. De esa forma el IDE sabrá que es lo que tiene que compilar y enlazar con el programa principal. En Arduino la única salida de la compilación es un código que será cargado directamente en el Arduino. Aunque en el módulo principal no se usen todos los módulos, estos deberán ser incluidos para que el IDE tanga la lista completa de lo que necesita compilar.


(21-03-2016 08:56 AM)pedmar escribió:  - ¿donde debemos declarar los pines en esta parte?
Cita:void SetPinsProgram(){
ProgPins.ConfigurarPin(4, LOW);
ProgPins.ConfigurarPin(5, HIGH);
¿¿¿¿¿?????

Ese uso lo que hace es incluir en la tabla de ProgPins los pines que vamos a programar con pulsos. Los pines que no se usen para eso conviene darles un identificador mediante un #define al comienzo del programa. Por ejemplo justo después de los includes.

El primer uso será definir en que modo vamos a usar el pin (modo entrada o modo salida). Esto suele hacerse en la función setup(). Luego se usarán en cualquier parte.

Si el pin va a ser usado por un módulo. Puede que el propio módulo se encarge de colocar el pin en el modo que necesita. Conviene ver un ejemplito de uso de módulo.



(21-03-2016 08:56 AM)pedmar escribió:  Supongo que ¿no es necesario iniciar la comunicación serial para poder luego leer la temperatura? porque eso ya esta echo para el resto del código.


Una vez que se inicia la conexión serial, esta queda abierta durante todo el programa, así que no hace falta volver a hacerlo.

La base de aprendizaje de programación es leer algo de teoría y sobretodo ir leyendo código de pequeños ejemplos y también ir realizando pruebas independientes con programas pequeños que hagan pocas cosas, para resolver las dudas de programación que surjan.

Este es el camino largo, pero también es el más rápido con gran diferencia.

Los problemas hay que dividirlos continuamente en problemas más sencillos e ir resolviéndolos uno a uno.
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
24-03-2016, 08:10 PM
Mensaje: #127
RE: Programación C desde Cero.
por fin estoy otra vez al lio:
he descargado las librerias y las he colocado en el principio del código.
luego habia declarado el pin con la sentencia que me dijiste define, primero lo en el setup pero me decía que no habia declarado el sensors.
por lo que decidi poner todas las definiciones justo detras de las librerias y parecia que si estaba bién:
Cita:#include <DallasTemperature.h>
#include <OneWire.h>
#include <Arduino.h>

#include <Wire.h> // I2C
// #include "ProgChar.h"
#include "CaoSeta_RTC_DS3231.h"
#include "CaoSeta_ProgPins.h"
#include "CaoSeta_Turn.h"
#define Pin 2
OneWire ourWire(Pin);

DallasTemperature sensors(&ourWire);

y en la parte final creo que he cometido algún fallo por que no lee correctamente -no2.gif

Cita:void setup() {
Wire.begin();
Serial.begin(9600);
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);
sensors.begin();
sensors.requestTemperatures();

}
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();
Serial.println();
sensors.requestTemperatures();
Serial.print(sensors.getTempCByIndex(0));
Serial.println(" Grados Centigrados");

}

}
}

marca -127 grados centígrados
Visita su sitio web Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
24-03-2016, 10:57 PM
Mensaje: #128
RE: Programación C desde Cero.
Parece que estas usando la librería de un tal Miles Burton. No sé si es buena o mala, si es fácil de usar o no, ya que nunca la he usado. He mirado el código de demo https://milesburton.com/Dallas_Temperatu...ol_Library

A simple vista no detecto nada raro en lo que tú has hecho:

1) Has definido el Pin
2) Con ese pin instancias un objeto OnWire que se llama OureWire.
3) Luego pasas la dirección de la instancia de ese objeto para instanciar un objeto DallasTemperature de Tim Burton. Como nombre de esta segunda instancia eliges sensors.
4) Por último usas las funcionalidades de la instancia sensors.

Todo lo veo lógico y está realizado en el orden correcto. Por una cuestión de legibilidad los identificador deben de describir las cosas con mayor precisión.

"Pin" podría llamarse PinOneWire o algo parecido.
"sensors" podría llamarse DsTemp o algo parecido.

Para saber qué falla, tendría que investigar leyéndome el código. Lo que yo uso es mi propia librería. La basé en programitas muy sencillos de un sitio enlazado desde las páginas oficiales de Arduino (playground.arduino). Esta es la Wiki comunitaria de Arduino en Españo

Concretamente me basé en la información recogida en
http://playground.arduino.cc/Learning/OneWire

Aparte de eso me miré algunos datasheets, me compré varias sondas y me templé de hacer toda clase de pruebas. Lo que quiero decir es que la conozco muy bien. (Como si la hubiera parido).

Con mis módulos te puedo ayudar sin el esfuerzo de intentar averiguar porque el código del señor Miles Burton no te funciona. Debe de ser alguna tontería. Si no das con el problema. Me lo dices y te paso mi módulo con una demo sencillita, para mí eso me lleva mucho menos tiempo que mirarme el código de otro.

Si yo tuviera que enfrentarme a un caso parecido metería una línea de código dentro de la funcion begin() del módulo DallasTemperature.

Concretamente una función Serial.println("*TRAZA* en DallasTemperature.begin() **");

Es evidente que si todo va como debe, la traza tendría que aparecer al usar la función begin() y si la traza, efectivamente sale, se pueden ir añadiendo trazas para perseguir el problema.
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
26-03-2016, 11:09 AM
Mensaje: #129
RE: Programación C desde Cero.
El jueves, cambie la caja de conexiones para tener mejor acceso, donde se vea bien todos los pines, por que le queda muchos componentes y mucho cableado futuro...

İmage

Y ayer me tire toda la mañana y parte de la tarde intentando hacer funcionar una puñetera sonda de temperatura, dentro del código CAO_SETAv1_0 y no fui capaz ni copiando de internet.
Si la montaba en el otro arduino sola sin mas código que la sonda marca perfectamente. me siento un inútil.-mega_shok.gif

He vuelto atrás intentado entender códigos sencillos ayudándome de los dos pdf que me descargue hace tiempo. uno de ellos hace una descripción sencilla de variables constantes operadores etc. y el otro son ejercicios sencillos ya resueltos. Huh
Pero no me resigno a saber como añadir cosas al CAO_SETA.
Visita su sitio web Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
26-03-2016, 11:38 PM (Este mensaje fue modificado por última vez en: 27-03-2016 10:21 AM por Antonio Castro.)
Mensaje: #130
RE: Programación C desde Cero.
Esta mañana te contesté con un mensaje que incluía un fichero adjunto. Básicamente te dije que el diseño de tu caja es muy chulo, que eres un artista y un manitas y que es normal que tengas problemas con CAO1 porque ha ido evolucionando y n es el mejor proyecto para princiantes. Necesita ser configurado.

El fichero adjunto que te mandaba es de la primera versión del refrigerador que hice. Es muy sencillo, pocas líneas y sin modulos. Usa un relé para activar el ventilador. Las versiones posteriores dimean el ventilador. Creo que te será más sencillo empezar con esa versión.

Ahora no puedo ponerme con ello. Te lo mando mañana.
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
27-03-2016, 10:38 AM
Mensaje: #131
RE: Programación C desde Cero.
Te mando el fichero adjunto.
.zip  CaoRefrigV1.zip (Tamaño: 80.89 KB / Descargas: 3)

Y te mando un par de enlaces de artículos que escribí en su dia.

Refrigerador para acuarios realizado con Arduino (Versión 1 de 2013).
En 2013 escribí un artículo comentando este montaje. El código es un único fichoro con un programa principal de menos de 300 líneas de código. Te puede venir muy bien.

Sensor digital de temperatura DS18x20
Es un artículo tambien del 2013 sobre el sensor de temperatura. He continuado averiguando cosas de este sensor y en particular he mejorado mucho la fiabilidad del sellado de las sondas que es un asunto delicado.
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
27-03-2016, 09:26 PM
Mensaje: #132
RE: Programación C desde Cero.
por fin-yahoo.gif se que es una tontería pero he conseguido que lea el sensor a través del puerto serial dentro de CAO_01.
me ha costado dios y ayuda (mucha ayuda:blushSmile



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 -pardon.gif
Visita su sitio web Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
29-03-2016, 10:20 AM
Mensaje: #133
RE: Programación C desde Cero.
(27-03-2016 09:26 PM)pedmar escribió:  por fin-yahoo.gif se que es una tontería pero he conseguido que lea el sensor a través del puerto serial dentro de CAO_01.
me ha costado dios y ayuda (mucha ayuda:blushSmile
[...]
muchas gracias Antonio, aunque en ocasiones no entiendo muy bien las explicaciones -pardon.gif

No sé a qué explicaciones te refieres. Si no entiendes algo de lo que he explicado en alguna parte puede ser culpa mía. Vuelve a preguntar y me esforzaré un poco más.

Solo comentarte que la librería que usas parece dar prioridad a la precisión de la lectura. En mi caso, consideré que una décima de grado era suficiente y dado que el sensor se usaría a intervalos de pocos segundos utilicé un truco. Hice que el chip de la sonda consumiera el tiempo para medir temperatura entre llamada y llamada para que no estorbara al programa que en mi caso tenía que hacer bastantes cosas a la vez.

La monitorización en un acuario, comparados con otros sistemas que tienen que reaccionar con más rapidez, se puede hacer usando ciclos relativamente lentos.

Es deci, se puede refrescar la información entre cada 2 y cada 10 segundos. En CAO1 lo hago cada 5 segundos. En esos 5 segundos tiene que dar tiempo a hacer un montón de cosas y muchas librerías desperdician un tiempo bastante valioso.

En tu caso, tu programa no hace tantas cosas y no necesitas tanta rapidez, así que la librería de "DallasTemperature" de Miles Burton te vendrá bien.
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
16-06-2016, 01:35 PM
Mensaje: #134
RE: Programación C desde Cero.
Muy buenas estoy empezando en la programación en c como ya le he dicho a Antonio en el otro post. Me gustaría que pusierais más ejercicios y más información me he quedado con la miel en los labios. Graciaaaas
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
16-06-2016, 07:52 PM
Mensaje: #135
RE: Programación C desde Cero.
Si se quiere ser un poco sistemático a la hora de aprender un lenguaje, no hay nada como partir de un manual de referencia.
Curso básico de programacion en C

Lo que ocurre es que si se trata del primer lenguaje de programación todo suena a chino y resulta complicado. En ese caso es mjor empezar mediante tanteos con pequeños ejemplos sencillos. De esta forma se avanza con muchas lagunas, pero se avanza y cuando decides dar el paso a estudiarte el manual las cosas ya te suenan y se va entendiendo mejor. Empiezan a encenderse la bombillitas de las zonas que se quedaron a oscuras.

Cursos enfocados a la práctica hay muchos.

13 webs y cursos para saber por donde empezar

En particular he visto que incluye un listado de TUTORIALES ARDUINO BÁSICO (De Luis Llamas) que vienen perfectamente ordenados para empezar desde cero.

Los tutoriales de PROMETEC son muy completos. Vienen muy bien estructurados. Cada uno de ellos empieza con una exposición de las nociones básicas de teoría.
Encuentra todos sus mensajes
Cita este mensaje en tu respuesta
Enviar respuesta 


Compartir

Salto de foro:


Usuario(s) navegando en este tema:
1 invitado(s)

Volver arribaVolver al contenido