Mostrando entradas con la etiqueta sensor. Mostrar todas las entradas
Mostrando entradas con la etiqueta sensor. Mostrar todas las entradas

sábado, 18 de abril de 2026

Sensor de temperatura - Protocolo TFA - ESP32-C3 super mini

  Página principal

Sensor de temperatura
Protocolo  TFA

ESP32-C3 super mini


Esta es la continuación del sensor con el protocolo TFA realizado con un ATMEGA328, pero en este caso lo realizo con un ESP32_C3 super mini.


Que cada uno mire en su placa la configuración de pins.
Se puede encontrar en:
    /home/usuario/.arduino15/packages/esp32/hardware/esp32/3.3.0/variants/lolin_c3_mini

Se diseña el esquema y el circuito impreso en KICAD.




El circuito impreso se realizó con el método de transferencia de tinta tóner.
Quedando como se ve en la foto.


Como no me quería arriesgar en alimentar el ESP-C3 con los 4V que proporciona la batería 18650, he bajado el voltaje a 3.3V utilizando un diodo que tiene una caída de voltaje de 0.6V .

Quedando todo el conjunto ...


El 95% del código es el mismo que con el ATmega328, pero he tenido que cambiar la forma en que se duerme el microcontrolador.

    esp_sleep_enable_timer_wakeup(1000000); // 1 Segundo
    esp_light_sleep_start();


También he solucionado algún error, sobre todo el que siempre sonaba un pitido cuando mandaba datos, y solo lo tiene sonar la primera vez.

Como el micro se encuentra dormido el 98% del tiempo, cuando se programa por segunda vez, no responde a la programación.
Para poder programarlo, deberás pulsar los dos botones a la vez (BOOT y RESET), sin dejar de presionar el BOOT, soltar el RESET, y ahora mandar el código al microprocesador.
El consumo es el siguiente:
Alimentado a 5V en el pin de 5V -> 0.78mA (Dormido)        27mA(Despierto)
Alimentado a 3.3V en el pin de 3.3V -> 0.5mA        26mA(Despierto)




El próximo cambio será utilizar un 18B20 como sensor de temperatura, en este montaje se desaprovecha el AHT20.

Programa


Saludos.
Juan Galaz



Bibliografía:
http://seta43.duckdns.org/2026/tfa/tfa.html
http://seta43.duckdns.org/ard433.html
http://seta43.duckdns.org/termot.html
http://seta43.duckdns.org/temt3.html

martes, 7 de abril de 2026

Sensor de temperatura Protocolo TFA - Arduino

  Página principal

Sensor de temperatura
Protocolo  TFA

Arduino

 


Mi primera intención era hacer un sensor para una serie de estaciones meteorológicas que tenía sin sensor. Eran de la marca oregon cientific. Esta marca fue una referencia por su buena calidad, pero esta marca fue comprada por otra compañía, y es muy difícil de encontrar sensores, además si se encontraban eran de precio alto, por lo cual no merecía la pena.

Existe muchos modelos, más de 20, y unos no son compatibles con otros.

Hay 3 protocolos de transmisión, pero la documentación es escasa en cuanto a los diferentes sensores.

Existe una documentación que la sacó alguien con ingeniería inversa. Leyendo está documentación encontré que los sensores emiten un byte una variable aleatoria. Después de algunas pruebas, creo que esta variable aleatoria no es tan aleatoria como debería ser. Algunas estaciones base, leen durante algunas horas los sensores perfectamente al resetear los sensores y la estación base, para dejar de leer después, a pesar de que los sensores siguen mandando datos.
Mi sospecha es que la variable aleatoria es una secuencia de bytes que pertenece a un modelo concreto de base, después de ciertas lecturas si no corresponde a la base en concreta, deja de proporcionar dados de ese sensor. Es una forma de asegurarse de que ningún sensor de otra marca ajena funcione en su estación base. Por este motivo no existen sensores chinos compatibles. Desaparecida la marca, ya puedes tirar la estación base.
Como era muy difícil de realizar este tipo de sensores, empecé con otro.
Tengo 3 bases meteorológicas que funcionan con el protocolo TFA, es sencillo y solo transmite temperatura. Solo tengo 1 sensor que leen las 3 estaciones bases, por lo que en este montaje crearé un segundo sensor que funcione en el canal 2.


Existe un programa que lee muchos protocolos de diferentes sensores, desde coches hasta sensores de temperatura. Este programa se llama RTL_433 y utiliza un decodificador USB de televisión digital para la recepción de señales.

Mirando en su código fuente, se puede ver la estructura del protocolo  TFA.
Gracias Alexandre Coffignal (rtl_433) por su magnífico programa.
Data layout:
    CCCCIIII IIIITTTT TTTTTTTT DDBF
- C: checksum, sum of nibbles - 1
- I: device id (changing only after reset)
- T: temperature
- D: channel number
- B: battery status
- F: first transmission


Como me gusta investigar por mí mismo, voy grabar la señal mediante el programa Gqrx .
Lo analizo con el programa de audio Audacius para la medir los tiempos.
Descubro que los datos se repiten 7 veces y los tiempos son los que se ven en la imagen.

Se puede observar  que entre bits el pulso de separación es de 475 micro Segundos. Si se quiere mandar un cero la separación entre pulsos es de 2500 mS, y si es 1 la separación es  5000 mS. La separación entre las 7 repeticiones es de 10mS. Al inicio de la transmisión debe existir un pulso y una separación de 10mS.
Ahora comienza la programación en Arduino para generar este patrón de datos. Mediante un analizador digital barato (7€) compruebo la señal generada. Es un patrón de 7 grupos de 4bits, el primero es el la suma de los otros 6 grupos – 1 .



A final los diferentes tiempos de la señal son los siguientes.
#define SENAL_ALTA 500
#define SENAL_0 2400
#define SENAL_1 5000
#define SEPARACION 10000


El circuito utiliza el AHT20 como sensor, que utiliza la comunicación I2C. La parte de humedad de este sensor no se utiliza, por lo que me planteo para una revisión posterior el utilizar 18B20 como sensor de temperatura.

Por el pin 13 del arduino se manda la señal a un transmisor de radiofrecuencia en 433MHz  cada 36 segundos.
En los pines 3 y 4 se selecciona el canal y el pin 2 se puede utilizar para transmitir la señal cuando se quiera.

El programa está diseñado para la depuración por el puerto serie, aunque el que quiera puede eliminar todo lo relativo a la comunicación serie.
Todo está montado y probado en una protoboard utilizando el arduino nano.

Como lo importante en un sensor es la medición correcta de la temperatura y la autonomía de la batería, utilizo la librería LowPower para dormir el microprocesador mientras no hace nada.
Se puede ver en la imagen los diferentes consumos dependiendo de la alimentación, de cuando está despierto y dormido. Aún así el consumo es alto para un este tipo de sensores.
En este otro montaje solo monto el ATMEGA328 y los componente mínimos.

Esto es otra cosa, el consumo baja hasta los 0.10 mA cuando está dormido, y 7 mA cuando está despierto y transmitiendo.
Haciendo unos cálculo rápidos si demasiada precisión.
Con una batería de 1000mA/H y el micro siempre  dormido la autonomía sería de 10000 horas o lo que es lo mismo 416 días.
Como hay que ser más realista y pensando que cada 60 segundos está despierto 4 segundos podría durar la batería 90 días más o menos.
Ahora nos toca el diseño del Circuito integrado y su creación.
Utilizo el programa KIDcad para el diseño de la PCB. Y utilizo el método láser para la creación del circuito impreso.

Colocados los componentes, el prototipo queda bastante compacto, aunque si se soldarían  los componentes al circuito impreso directamente quedaría aún más pequeño.

Me lo he pasado bastante bien experimentando con señales, vosotros podéis probar otro tipo de sensores.

Programa

Saludos.
Juan Galaz



Bibliografía:

http://seta43.duckdns.org/ard433.html
http://seta43.duckdns.org/termot.html
http://seta43.duckdns.org/temt3.html

jueves, 22 de diciembre de 2022

Arduino Sensor VL53L0X Medidor de distancias

  Página principal

Arduino
Sensor  VL53L0X
Medidor de distancias


El sensor VL53L0X mide distancias mediante un mini laser.
Para medir distancias el sensor lanza un pulso de luz hacia una superficie, y mide el tiempo que tarda en rebotar la luz.




Usa el bus I2C para la comunicación de datos con el arduino.

A4->SDA
A5->SDL
GND->GND
5V->VIN


La alimentación del chip es de 2.8V con un consumo de 19mA cuando hace una medida, en modo normal consume 19uA.
Para poder funcionar con el arduino el módulo dispone de un adaptador de voltaje, por lo cual se puede alimentar a 5V.










Pulso de luz durante la medida, solo se puede ver mediante cámara de teléfono móvil.



He utilizado dos librerías:
   - Adafruit_VL53L0X
   - Pololu
Personalmente me gusta la de Pololu por ser sencilla, aunque las dos funcionan bien.
En la librería Pololu es muy fácil ajustar la máxima distancia, así como la exactitud de la medida.


En próximos artículos utilizaré este sensor en algún montaje.

PROGRAMA

LIBRERÍAS


Saludos.
Juan Galaz


Bibliografía:


https://github.com/pololu/vl53l0x-arduino

https://www.adafruit.com/product/3317


Arduino Sensor AHT2X

  Página principal

Arduino
Sensor  AHT2X



Existen multitud de sensores de temperatura, pero este modelo AHT2X también dispone de sensor de humedad.
Usa el bus I2C para la comunicación de datos con el arduino.
A4->SDA
A5->SDL
GND->GND
5V->VIN


Se puede alimentar desde 2.0 V hasta 5.5V, y su consumo es de 23uA en medida.









Este sensor no necesita ningún ajuste por lo que es muy fácil de programar.
He utilizado dos librerías:
   - Adafruit_AHTX0-master
   - GROVE-ATH-RESOURCES
Personalmente me gusta la de grove por ser sencilla, aunque las dos funcionan bien.

En próximos artículos utilizaré este sensor en algún montaje.

PROGRAMA

LIBRERÍAS


Saludos.
Juan Galaz


Bibliografía:


https://github.com/adafruit/Adafruit_AHTX0
https://github.com/Longan-Labs/GROVE-ATH-RESOURCES

lunes, 28 de noviembre de 2022

Arduino - Receptor comercial de temperatura

  Página principal

Arduino
Receptor comercial de temperatura

Después de antiguos montajes de receptores de temperatura comerciales, he decidido reescribir el código.
El mayor problema es que los sensores de humedad se estropean con el tiempo, y miden mal.
El circuito es parecido al ard433.html, aunque yo lo tengo realizado en circuito impreso.



Lo primero se estudian las hondas recibidas para ver la estructura de los datos.
Ya con cierta experiencia es fácil encontrar los bits que corresponde a cada dato de humedad, temperatura, y canal.
Lo difícil sin documentación, es encontrar la forma en que hace la comprobación de errores.









Para medir los tiempos de cada tipo de bit (0 - 1), utilizo la interrupción en el pin 2.


#define IN_READ 2

//---Interrupcion--------------

void InumPasos()
{
  time=micros();        
  diferencia=time-timeU;
  Adiferencia=diferencia>>7;
  estadoDato=1;
salto:
  timeU=time;
}
//-----------------------------

void setup()
{
pinMode(IN_READ, INPUT);
 .......
  attachInterrupt(digitalPinToInterrupt(IN_READ), InumPasos, RISING);
 ....... 
}



Espero que estudiando el código podáis realizar vuestros propios receptores.
 

PROGRAMA


Saludos.
Juan Galaz


Bibliografía:
ard433.html
termot.html
temt3.html

martes, 4 de octubre de 2022

Raspberry pi pico, Programación C, Sensores: LDR - DHT22 (AM2302) - BMP180 - 18B20 OLED DS1302

  Página principal

Raspberry pi pico
Programación C
Sensores:
LDR - DHT22 (AM2302) - BMP180 - 18B20
OLED DS1302


Anteriormente había realizado un visualizador de sensores con el ESP32.
Algún tiempo después lo hice en la Raspberry pi pico programándolo en
microPython - PICO4
En este artículo lo realizo con la Raspberry pi pico y programando en C.

El final del montaje queda de la siguiente forma:





sen_p1 y sen_p2
El primer paso es colocar un led a modo de piloto de alimentación, y hacer parpadear el led que viene en la placa.

#include <stdio.h>
#include <pico/stdlib.h>


#define OUTPUT 1
#define INPUT 0
#define HIGH 1
#define LOW 0

void pinMode(unsigned int port, char modo);
void digitalWrite(unsigned int port, char val);
void delay(long t);

#define MILED 25

int main()
{
    stdio_init_all();
    delay(1000);
    printf("-----------------------\n");
    printf("----Hola SENSORES------\n");
    pinMode(MILED, OUTPUT);
    while(1)
    {
      printf("Estado %d\n",0);
      digitalWrite(MILED, LOW);
      delay(1000);
      printf("Estado %d\n",1);
      digitalWrite(MILED, HIGH);
      delay(2000);
    }
}


//---------------I/O----------------
void pinMode(unsigned int port, char modo)
{
    gpio_init(port);
    if(modo==OUTPUT)
        gpio_set_dir(port, GPIO_OUT);
     else
        gpio_set_dir(port, GPIO_IN);
}

void digitalWrite(unsigned int port, char val)
{
    gpio_put(port, val);
}

void delay(long t)
{
    sleep_ms(t);
}

Como me parece más fácil el modo de configurar los puertos de la forma que loa hace arduino , he creado un par de funciones tipo arduino.
A partir de ahora, las funciones se meterán en un fichero ardu.h donde se incluirán las funciones.


sen_p3
En este paso colocamos un sensor de temperatura y humedad

El sensor es el DHT22 o su equivalente AM2302.


#include <stdio.h>
#include <pico/stdlib.h>

#include "ardu.h"

#define MILED 25

//----DHT-----------
#define PIN_DHT 15
unsigned int humedad,temperatura,control;
unsigned char dataSensor[5];
unsigned int ck;
void leerDHT(void);

int main()
{
    stdio_init_all();
    delay(1000);

    printf("----Hola SENSORES------\n");
    pinMode(MILED, OUTPUT);
    while(1)
    {
      leerDHT();
      printf("AM2302_H=%.1f%%   T=%.1f ºC   Control=%d\n",(float)humedad/10,(float)temperatura/10,control);
     
      digitalWrite(MILED, LOW);
      delay(1000);
      digitalWrite(MILED, HIGH);
      delay(2000);
      printf("-----------------------\n");
    }
}


//----------DHT--------------------
void leerDHT(void)
{
  unsigned char n,z,x;
  unsigned char contador1,contador0;
  unsigned char datos[45];
  control=temperatura=humedad=0;
 
  pinMode(PIN_DHT,OUTPUT);
  digitalWrite(PIN_DHT,LOW);
  delay(2);
  digitalWrite(PIN_DHT,HIGH);
  pinMode(PIN_DHT,INPUT);
 
  for(n=0;n<42;n++)
  {
    contador0=contador1=0;
    while(1==digitalRead(PIN_DHT))
    {
      delayMicroseconds(5);
      contador1++;
      if(contador1>250)goto salir;
    }
    while(0==digitalRead(PIN_DHT))
    {
      delayMicroseconds(5);
      contador0++;
      if(contador1>250)goto salir;     
    }
    datos[n]=contador1;   
  }

  z=0;
  x=0;
  for(n=2;n<42;n++)
    {
      dataSensor[z]<<=1;
      if(datos[n]>=contador0) { (dataSensor[z])|=1;}
      x++;
      if(x==8) { x=0;  z++;  }      
    }

  humedad=dataSensor[0];
  humedad<<=8;
  humedad|=dataSensor[1];
  temperatura=dataSensor[2];
  temperatura<<=8;
  temperatura|=dataSensor[3];
  control=dataSensor[4];
salir: 
;
}
//---------------------------------
En este caso he tenido que crear yo las funciones de lectura.
Primero la hice sobre arduino y luego trasladé el código a la Raspberry pi pico.
El paso de una placa a otra fue fácil, no tuve que hacer ningún cambio.



El protocolo
1-wire, es bastante sencillo de programar.

----Hola SENSORES------
AM2302_H=39.4%   T=22.5 ºC   Control=108
-----------------------
AM2302_H=40.7%   T=22.5 ºC   Control=121


sen_p4
En este paso ponemos un sensor de luz tipo LDR,
y leemos el valor mediante un conversor ADC.

...
#include "hardware/gpio.h"
#include "hardware/adc.h"
...

//---Voltios LDR---
uint16_t result;
...

main()
{
...
 //INIT --ADC-- 
    adc_init();
    adc_gpio_init(28);    // Select ADC input 0 (GPIO26)
    adc_select_input(2);
    const float conversion_factor = 3.3f / 4096;
...

while(1)
    {
....
      result = adc_read();
      printf("LDR-> RAW=%d, voltaje=%f V\n", result, result * conversion_factor);
...
    }
}
En este caso solo  muestro el código correspondiente a la conversión A/D.
Este código no tiene demasiado explicación, configuración pin 28, y lectura del valor.

----Hola SENSORES------
AM2302_H=38.8%   T=23.5 ºC   Control=112
LDR-> RAW=402, voltaje=0.323877 V
-----------------------
AM2302_H=40.1%   T=23.5 ºC   Control=125
LDR-> RAW=403, voltaje=0.324683 V
-----------------------


sen_p5
En este paso colocamos un sensor de presión que además dispone de un sensor de temperatura.

El sensor viene en un módulo BMP180, los datos se mandan mediante el bus I2C.


...
#include "pico/binary_info.h"
#include "hardware/i2c.h"

#include <math.h>
...

//----I2C-------
i2c_inst_t *XXi2c = i2c0;        //i2c1 para 26-27   12c0 para 0-1 ...
#define    SDA_PIN 0
#define    SCL_PIN 1
 
#define  BMP180_ADDR 0x77 // 7-bit address
#define  BMP180_WRITE_MODE _u(0xFE)
#define  BMP180_READ_MODE _u(0xFF)
#define     BMP180_REG_CONTROL 0xF4
#define     BMP180_REG_RESULT 0xF6
#define     BMP180_COMMAND_TEMPERATURE 0x2E

void bmpGetData(void);
void bmpComand(uint8_t cmd);
int bmpInput(char address);
void getVarBMP(void);
void scanI2C(void);

long Temperatura, Presion, PresionBase;
...

main()
{
...
//INIT --I2C--
    printf("SDA=%d  SDL=%d \n", SDA_PIN, SCL_PIN);
    i2c_init(i2c_default, 100000);
    gpio_set_function( SDA_PIN, GPIO_FUNC_I2C);
    gpio_set_function( SCL_PIN, GPIO_FUNC_I2C);
    gpio_pull_up( SDA_PIN);
    gpio_pull_up( SCL_PIN);
    bi_decl(bi_2pins_with_func( SDA_PIN,  SCL_PIN, GPIO_FUNC_I2C));
   
    scanI2C();  
    getVarBMP();
    delay(50);
    bmpGetData();    //Calcula la presión base......
    PresionBase=Presion;
...

while(1)
    {
....
     bmpGetData();
     printf("BMP_TempGRADOS=%0.2f ºC\n",(float)Temperatura/100);
     printf("BMP_Presion=%0.2f bares\n",(float)Presion/100); 
...
    }
}


Solo muestro el código correspondiente a la comunicación I2C y al cálculo de la presión.
En este caso el código del arduino es totalmente diferente al de la Raspberry.
Me costó mucho tiempo y trabajo el descubrir la diferencia entre los tipos de enteros.
En arduino el tamaño de int es de 16bit, en la raspberry es de 32bit.
Y se me ocurrió utilizar el tipo sort, y resulto erroneo su tamaño, por lo que lo mejor es utilizar int16_t o uint16_t.
Hay que tener en presente que existen varios I2C en la raspberry y debemos especificar el que usamos.
Por ejemplo: i2c1 para 26-27  e  12c0 para 0-1 .........
Aunque la librería es mia, he utilizado algún código de otros, en bibliografía  pongo las fuentes.
-----------------------
AM2302_H=41.0%   T=23.7 ºC   Control=136
LDR-> RAW=915, voltaje=0.737183 V
BMP_TempGRADOS=22.21 ºC
BMP_Presion=934.37 bares
-----------------------

Señales del bus I2C cuando lee datos, funcion void bmpGetData(void)

sen_p6
En este paso colocamos un sensor de temperatura 18B20.

Este chip se comunica mediante una sola línea de datos, y si se quiere se puede utilizar solo dos lineas para hacer funcionar el sensor.
Además se pueden colocar varios chip en paralelo, que se podrán leer sus temperaturas independientemente.


//----DS18B20------
#define ONE_WIRE_PIN 22
void onewire_reset();
void onewire_write(unsigned char data);
int onewire_read();
int ds1820_read();

float temp18B;
...

main()
{

while(1)
    {
....
      temp18B=ds1820_read();
      printf("DS18b20_Temp=%0.2f ºC\n",temp18B/10);
...
    }
}


//-------------ONEWIRE-------------
void onewire_reset()
{
    pinMode(ONE_WIRE_PIN,OUTPUT); digitalWrite(ONE_WIRE_PIN,LOW);  
    delayMicroseconds(500);
    digitalWrite(ONE_WIRE_PIN,HIGH);  pinMode(ONE_WIRE_PIN,INPUT);
    delayMicroseconds(500);                
    digitalWrite(ONE_WIRE_PIN,HIGH);  pinMode(ONE_WIRE_PIN,INPUT);
}


void onewire_write(unsigned char data)
{
    unsigned char count;
    for(count = 0; count < 8; ++count)
    {
        pinMode(ONE_WIRE_PIN,OUTPUT); digitalWrite(ONE_WIRE_PIN,LOW);
        delayMicroseconds(2);              
        if(data & 1)
          {  digitalWrite(ONE_WIRE_PIN,HIGH);  }
          else
          {  digitalWrite(ONE_WIRE_PIN,LOW);   }
        data>>=1;

        delayMicroseconds(60);               
        digitalWrite(ONE_WIRE_PIN,HIGH);  pinMode(ONE_WIRE_PIN,INPUT);
        delayMicroseconds(2);                // for more than 1us minimum.
    }
}


int onewire_read()
{
    unsigned char count;
    unsigned char data;
    for(count = 0; count < 8; ++count)
    {
        data>>=1;
        pinMode(ONE_WIRE_PIN,OUTPUT);
        digitalWrite(ONE_WIRE_PIN,LOW);
        delayMicroseconds(2);             
        pinMode(ONE_WIRE_PIN,INPUT);
        delayMicroseconds(10);              
        if(digitalRead(ONE_WIRE_PIN)&1 )  {  data|=128;  }
        delayMicroseconds(50); 
    }
    delayMicroseconds(100);
    return data;
}

int ds1820_read()
{
    unsigned char busy=0, tempL, tempH; 
    long  temp;
   
    onewire_reset();
    onewire_write(0xCC);              
    onewire_write(0x44);  
    delay(10);
    onewire_reset();
    onewire_write(0xCC);           
    onewire_write(0xBE);           
   
    tempL = onewire_read();
    tempH = onewire_read();
 
    temp=tempH; temp<<=8; temp|=tempL;
    //Serial.print(" HEX ");Serial.print(temp,HEX);
    temp=(temp*625)/1000;
  return(temp); 
}

1-Wire es un protocolo de comunicaciones en serie diseñado por Dallas Semiconductor.
Está basado en un bus, un maestro y varios esclavos de una sola línea de datos en la que se alimentan.
En este protocolo se pueden colocar varios 18B20 en paralelo, por lo cual debería colocar una función de detección de elementos.
Otra forma es saber la identificación en ROM de cada elemento.
En mi caso uno de los 18B20 tiene la siguiente dirección:  byte addr[8]={0x28,0xDC,0x5C,0x16,0xA8,1,0x3C,0x28};
Esto me hubiese costado mucho, además solo voy a colocar un 18B20, por lo que utilizo un modo de lectura diferente.

SKIP ROM [CCh] Este comando puede ahorrar tiempo en un sistema de bus de caída única al permitir que el bus maestro acceda al funciones de memoria sin proporcionar el código ROM de 64 bits. Si hay más de un esclavo presente en el bus y se emite un comando de lectura después del comando Saltar ROM, se producirá una colisión de datos en el bus como múltiples esclavos transmiten simultáneamente (los pulldowns de drenaje abierto producirán un resultado AND cableado). www.dalsemi.com

-----------------------

AM2302_H=42.3%   T=24.7 ºC   Control=159

LDR-> RAW=236, voltaje=0.190137 V
BMP_TempGRADOS=23.30 ºC
BMP_Presion=933.90 bares
-----------------------


sen_p7
Por último colocamos un visualizardor tipo OLED
, el modelo SSD1306.
Lo bueno de colocar este modelo es que se conecta en el bus I2C, lo que resulta muy práctico y sencillo.

...
#include "ole.h"
char miBuffer[40];
...
main()
{
...
while(1)
    {
...
      xclearDisplay();
      StringAT(0,0,"--SETA43--");
     
      sprintf(miBuffer,"LDR=%d  %0.3fV",result,result * conversion_factor);
      StringAT(0,1,miBuffer);
     
      sprintf(miBuffer,"DHT_Hum. %.1f %c",(float)humedad/10,37);
      StringAT(0,2,miBuffer);
     
      sprintf(miBuffer,"DHT_Temp. %.1f %cC",(float)temperatura/10,127);
      StringAT(0,3,miBuffer);
     
      sprintf(miBuffer,"DS18b20_=%0.2f %cC",temp18B/10,127);
      StringAT(0,4,miBuffer);
     
      sprintf(miBuffer,"BMP_Pres.=%0.1f b ",(float)Presion/100);
      StringAT(0,5,miBuffer);
      sprintf(miBuffer,"BMP_Temp.=%0.1f %cC",(float)Temperatura/100,127);
      StringAT(0,6,miBuffer);
...
    }
}
Para utilizar el OLED, he empleado una biblioteca mía que realicé en arduino hace años.
Es simple de utilizar, solo hay que añadir el fichero ole.h , no tiene muchas funciones, pero hace su trabajo.

Cuando empecé a programar la raspberry pi pico, pensé que la transición sería más fácil, pero no fue así.
La cantidad de bibliotecas que existe en arduino no existen en raspberry.
El paso de programas entre arduino y rasberry no es inmediata, y muchos de los programas y biblitecas no funcionan,
Debemos pensar que los int en arduino son de 16bit, y en raspberry es de 32bit, esto genera muchos problemas.
Si queremos utilizar enteror de 16bit en raspberry, se debe utilizar
int16_t o uint16_t.

PROGRAMAS

Espero que este montaje os haya parecido interesante.

Saludos.

Juan Galaz



Bibliografía:

https://datasheets.raspberrypi.com/pico/raspberry-pi-pico-c-sdk.pdf
https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf
https://www.puntoflotante.net/termometro.htm
espgrs.html

28/02/2016 - Arduino - Predicción del tiempo. GY-68 - BMP-180.  Predicción
21/02/2016 - Arduino power low - Termómetro máximos y mínimos con gráfica - DS18B20 LCD Nokia PCD8544. Tempe
09/02/2016 - Arduino -Barómetro - Termómetro. GY-68 -  BMP-180. Parte 2 (librería propia). ArduBer
03/02/2016 - Arduino -Barómetro - Termómetro. GY-68 -  BMP-180. Parte 1.  ArduBar