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

jueves, 23 de febrero de 2023

Raspberry Pi Pico Interprete BASIC con VGA

  Página principal

Raspberry Pi Pico
Interprete BASIC
 con VGA



Buscando montaje curiosos con la Raspberry Pi Pico encontré la página https://geoffg.net/picomitevga.html.
En esta página habían instalado un interprete de Basic, mmBasic, en la Raspberry Pi Pico, y además habían programado una salida de VGA.
El MMBasic es un intérprete Basic libre para microcontroladores de 32 bits. https://mmbasic.com/
Existen intérpretes MMBasic  para DOS, Linux y PIC32.


En el montaje original tiene una SD para almacenar diferentes programas, en mi caso solo quiero que exista un programa, por lo que se la he quitado.

Para la conexión del teclado el montaje original coloca una serie de transistores, yo los he eliminado conectando 4 resistencias.
Como dice el montaje original se puede eliminar la conexión del teclado a 5V y conectarlo a los 3.3V, la mayoría de los teclados funciona lo he probado personalmente.

En el montaje original de la segunda línea del color verde se conectan varias resistencias junto con una resistencia variable.
En mi montaje coloco 2 resistencias junto con un diodo. El ajuste fino del color blanco se ha eliminado.

He añadido dos diodos led, el primero a modo de test de alimentación, y otro de test colocado a GP5.

También he colocado un pulsador para la programación inicial de la Raspberry pi pico.

Se puede añadir una salida de audio, podéis ver la forma en la buena documentación proporcionada en la página web.


Esquema modificado.




Primer montaje.


Circuito montado.

' Colour Bars

Mode 2
CLS
Font 7
For y = 0 To 240 - 240/15 Step 240/16
  Read s$, c
  Text 0, y + 4, s$ + " = RGB(" + Str$(c>>16) + "," + Str$((c>>8) And &B11111111) + "," + Str$(c And &B11111111) + ")"
  Box 155, y, 320 - 155, 240/16, 1, c, c
Next y

Data "white", RGB(white)
Data "yellow", RGB(yellow)
Data "lilac", RGB(lilac)
Data "brown", RGB(brown)
Data "fuchsia", RGB(fuchsia)
Data "rust", RGB(rust)
Data "magenta", RGB(magenta)
Data "red", RGB(red)
Data "cyan", RGB(cyan)
Data "green", RGB(green)
Data "cerulean", RGB(cerulean)
Data "midgreen", RGB(midgreen)
Data "cobalt", RGB(cobalt)
Data "myrtle", RGB(myrtle)
Data "blue", RGB(blue)
Print @(0,y);

PLAY TONE 500, 500
PAUSE 2000
PLAY TONE 300, 300
PAUSE 5000
PLAY STOP



Visión en un televisor con entrada VGA.

Para subir los programas desde el PC a la placa Raspberry pi pico utilizo un par de programas: MMCC y MMEdit.

Terminal serie de programación y ejecución.


Programa de edición y subida a la placa.

El numero de colores máximos representados en la resolución de 320x240 es de 16 colores. En modo de 640x480 es monocromo.
En una de las pruebas he añadido un sensor de temperatura 18B20, para representar en pantalla la temperatura.
Recomiendo este montaje por su sencillez, y por la sensación de estar en los ordenadores de los años 80.

VIDEO

________________________________________________________




16/03/2023
Después de unos días probando la placa, descubrí que los módulos clónicos de esta tarjeta, no son iguales que la original.
Para que funcionase debía cambiar la toma de 5V para el teclado, desde el pin VSYS al pin VBUS.
También decidí colocar una tarjeta SD y el conector de audio.



Para configurar los pins donde esta conectada la tarjeta SD debemos ejecutar la siguiente orden:
     OPTION SDCARD GP13, GP10, GP11, GP12
La tarjeta SD esta en el disco B: por lo que si queremos trabajar en este disco deberemos ejecutar la orden:
     DRIVE "B:"
Para ver los fichero de este disco se teclea :
     FILES
Si queremos cargar un programa tecleamos:
     LOAD programa.bas
Si queremos cargar el programa tecleamos:
    LOAD programa.bas
    o
    RUN programa.bas
Existen muchas mas ordenes que vienen muy bien documentadas en el manual como:

 MKDIR dname$
Creates a sub directory in the current directory on the current drive.
 CHDIR dname$
Change into to the directory $dname. $dname can also be "." (dot dot) for up one directory or "\" for the
root directory. The starting point is the current directory on the current drive.
RMDIR dir$
Remove, or delete, the directory ‘dir$’ in the current directory on the current drive.
 SEEK #fnbr, pos
Will position the read/write pointer in a file that has been opened for RANDOM access to the 'pos' byte.
 RENAME fromname$ AS toname$
Will rename the file fromname$ to have the name toname$ in the current directory on the current drive
 COPY [mode] fromname$ TO toname$
Will copy the file fromname$ to have the file toname$. See the command reference for more details on the
optional mode.



En cuando a reproducir sonidos, lo primero es configurar los pin de salida:
    OPTION AUDIO GP6, GP7
y luego reproducir un fichero WAV con la orden.
    PLAY WAV demo.wav
Me sorprendió para bien la calidad del sonido reproducido, y probé con diferente tipos de muestreo.
Además se puede generar tonos con la orden:
    PLAY TONE left, right, duration, interrupt
    PLAY TONE 500, 500, 2000

 

Saludos.
Juan Galaz



Bibliografía:

https://geoffg.net/picomitevga.html
https://mmbasic.com/

viernes, 27 de enero de 2023

Comunicación entre arduino y Raspberry pi pico con LORA

  Página principal

LORA (LoRaWAN) SX1278
Raspberry pi pico

IDE Arduino
Transmision temperatura desde ATMEGA a Raspberry pi pico
Módulo AHT20 - OLED


Tenía una raspberry pi pico, y mi idea era comunicar el arduino con la raspberry pi pico a través de LORA (LoRaWAN).
En primer lugar monto el transmisor con un arduino junto con el sensor de temperatura y humedad (AHT20).
En anteriores montajes ya había realizado varios montajes, en este lo junto todo.

EMISOR




El sensor AHT20 se comunica mediante el bus I2C, funciona a 5V.
Module AHT20 // Arduino UNO/NANO   
    A4->SDA
    A5->SDL
    GND->GND
    5V->VIN

El transmisor LORA SX1278 se comunica mediante el bus SPI, funciona a 3.3V .
Module SX1278 // Arduino UNO/NANO   
    GND         ->   GND
    Vcc         ->   3.3V
    MISO        ->   D12
    MOSI        ->   D11    
    SLCK        ->   D13
    Nss         ->   D10
    Di00        ->   D2
    RST         ->   D9    

Los datos de temperatura y humedad se envían cada 1500 mS.
El formato es:
Num=23  Temperatura=20.34  Humedad=50.34


RECEPTOR





El OLED se comunica mediante el bus I2C.
OLED ->  PICO
    SLC->1
    SDA->0
    VCC->3V3
    GND->GND

Como en la Raspberry pi pico se pueden utilizar diferentes PINS para el bus I2C, debemos indicar que PINS se deben utilizar.
Esto se realiza en la configuración con:
    Wire.setSDA(0);
    Wire.setSCL(1);
    Wire.begin();
 
Nos falta conectar el receptor LORA SX1278 al raspberry mediante el bus SPI.
Module SX1278 // Raspberry pico pi
    GND         ->   GND
    Vcc         ->   3.3V
    MISO        ->   16
    MOSI        ->   19
    SLCK        ->   18
    Nss         ->   17
La configuración en la parte del programa fue difícil, es lo que mas me costó.
#define M_MISO  16
#define M_CS  17
#define M_SCK 18
#define M_MOSI  19

const uint8_t SPI_MISO = M_MISO;
const uint8_t SPI_CS = M_CS;
const uint8_t SPI_SCK = M_SCK;
const uint8_t SPI_MOSI = M_MOSI;

 LoRa.setPins(M_CS);

La conexión del pin de interrupción DIO0 no se hace debido a que no está implementada en la librería, además tampoco se utiliza el pin de RESET.

He creado una función que lee la cadena recibida y extrae el valor de una cadena pedida.
Esta función es muy útil para cualquier otro montaje.
/* busca en una cadena (*in), una cadena (*busqueda), y devuelve el valor en (*valor) */
int busqueda(char* in, char* busqueda, char* valor)

Ejemplo:
    if (1 == busqueda(buffer, (char*)"Num=", bufferS))
        {
            Serial.print(" valorNum=");
            Serial.println(bufferS);
            nums=atoi(bufferS);
        }


VIDEO DEL FUNCIONAMIENTO

PROGRAMA Y LIBRERÍAS



Saludos.
Juan Galaz



Bibliografía:

https://how2electronics.com/interfacing-sx1278-lora-module-with-arduino/
https://www.electroschematics.com/rf-radio-frequency/
https://electronoobs.com/eng_arduino_tut97.php
https://cdn-shop.adafruit.com/product-files/3179/sx1276_77_78_79.pdf
https://www.semtech.com/products/wireless-rf/lora-connect/sx1278
https://oa.upm.es/44890/1/TFM_JOSE_DANIEL_RODRIGUEZ_MUNCA.pdf
https://www.2cigroup.com/es/conceptos-de-actualidad-lora-y-lorawan/


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

viernes, 20 de enero de 2023

Raspberry pi pico - IDE Arduino - Módulo AHT20

  Página principal


Raspberry pi pico
IDE Arduino
Módulo AHT20

Había realizado algunos proyectos con la Raspberry pi pico programando en C, ahora lo realizo con la IDE de Arduino.
En un anterior artículo explico como configurar la IDE de arduino para programar la Raspberry pi pico.

En este montaje utilizo el sensor de temperatura y humedad AHT20, para luego representarlo en el OLED SSD1306Z.
Al utilizar la comunicación en ambos casos el bus I2C , el montaje es muy sencillo.





El código utilizado es el mismo utilizado para la versión de ATMEGA salvo la configuración de los PINS utilizados para el bus I2C.
Como en la Raspberry pi pico se pueden utilizar diferentes PINS para el bus I2C, debemos indicar que PINS se deben utilizar.
Esto se realiza en la configuración con:

      Wire.setSDA(0);
    Wire.setSCL(1);
    Wire.begin(); // Wire communication begin


Este montaje es fácil y rápido de hacer, manos a la obra.

PROGRAMA Y LIBRERÍAS


Saludos.
Juan Galaz


Bibliografía:



miércoles, 12 de octubre de 2022

Raspberry pi pico - Programación C - Vídeo-tutorial.

 

Raspberry pi pico
Programación C
Vídeo-tutorial.



 

Es simplemente un video-tutorial de un montaje de sensores en la placa Raspberry pi pico.
Aunque veréis que se hace las conexiones con la alimentación puesta, yo recomiendo que se la quitéis.
Para mas detalle sobre las librerías, recomiendo ver mi anterior montaje. pidc.html

VÍDEO

PROGRAMAS



Saludos.

Juan Galaz

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

viernes, 2 de septiembre de 2022

Raspberry pi pico - Programación microPython - Sensores

  Página principal

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



Anteriormente había realizado un visualizador de sensores con el ESP32.
En este artículo lo realizo con la Raspberry pi pico y programando en microPython.
Todo el montaje lo realizo en pasos, y grabado en vídeo, paso a paso.

El final del montaje queda de la siguiente forma:



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

# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 31-08-2022

import machine
import utime

led = machine.Pin(25, machine.Pin.OUT)

while True:
    led.value(0)
    utime.sleep(0.5)
    led.value(1)
    utime.sleep(0.5)


En este paso colocamos un sensor de temperatura y humedad
El sensor es el DHT22 o su equivalente AM2302.

# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 31-08-2022

import machine
import utime

led = machine.Pin(25, machine.Pin.OUT)

from DHT22 import DHT22
from machine import Pin

dht_sensor=DHT22(Pin(15),dht11=False)

while True:
    #--DHT22--------------------------------------------   
    T, H = dht_sensor.read()
    if T is None:
        print("Error en el sensor!")
    else:
        print("Sensor DHT22->","{}ºC  {}%".format(T,H))

    led.value(0)
    utime.sleep(0.5)
    led.value(1)
    utime.sleep(0.5)


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

# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 31-08-2022

import machine
import utime

led = machine.Pin(25, machine.Pin.OUT)

from DHT22 import DHT22
from machine import Pin

dht_sensor=DHT22(Pin(15),dht11=False)

analog_value = machine.ADC(28)


while True:
    #--DHT22--------------------------------------------   
    T, H = dht_sensor.read()
    if T is None:
        print("Error en el sensor!")
    else:
        print("Sensor DHT22->","{}ºC  {}%".format(T,H))
       
    #--LDR--------------------------------------------
    reading = analog_value.read_u16()    
    print("LDR-> ADC: ",reading)   

    led.value(0)
    utime.sleep(0.5)
    led.value(1)
    utime.sleep(0.5)


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.
Con este sensor se puede calcular la altura.

# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 31-08-2022

import machine
import utime
from bmp180 import BMP180
from machine import I2C, Pin

led = machine.Pin(25, machine.Pin.OUT)

from DHT22 import DHT22
from machine import Pin

dht_sensor=DHT22(Pin(15),dht11=False)

analog_value = machine.ADC(28)

i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=200000) 
bmp180 = BMP180(i2c)
bmp180.oversample_sett = 2
baseline = bmp180.pressure/100
ALTURA = 790

print ("Doble sensor DHT22 y DS18x20")
#Write in cmd found addresses

i2cScan = i2c.scan()
counter = 0
for i in i2cScan:
    print('I2C Address ' + str(counter) + '      : '+hex(i).upper())
print ("**************************")
#---------------


while True:
    #--DHT22--------------------------------------------   
    T, H = dht_sensor.read()
    if T is None:
        print("Error en el sensor!")
    else:
        print("Sensor DHT22->","{}ºC  {}%".format(T,H))
       
    #--LDR--------------------------------------------
    reading = analog_value.read_u16()    
    print("LDR-> ADC: ",reading)
   
    #..BMP180---------------------------------------------   
    temperatura = bmp180.temperature
    presion = bmp180.pressure/100
    alt2=44330.0* (1-pow(presion/baseline,1/5.255) )   
    alt2=ALTURA+alt2
       
    alt2=round(alt2)
    temperatura=round(temperatura,1)
    presion=round(presion)
           
    print("Tem_BMP180=",temperatura,"ºC Presion=", presion," ALTITUD=",alt2)

    led.value(0)
    utime.sleep(0.5)
    led.value(1)
    utime.sleep(0.5)


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.
El esquema solo utilizo un sensor, en la practica utilizo 2 chip con sus respectivas lecturas.

# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 31-08-2022

import machine
import utime
from bmp180 import BMP180
from machine import I2C, Pin
import onewire, ds18x20, time

led = machine.Pin(25, machine.Pin.OUT)

from DHT22 import DHT22
from machine import Pin

dht_sensor=DHT22(Pin(15),dht11=False)

analog_value = machine.ADC(28)

i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=200000) 
bmp180 = BMP180(i2c)
bmp180.oversample_sett = 2
baseline = bmp180.pressure/100
ALTURA = 790

print ("Doble sensor DHT22 y DS18x20")
#Write in cmd found addresses

i2cScan = i2c.scan()
counter = 0
for i in i2cScan:
    print('I2C Address ' + str(counter) + '      : '+hex(i).upper())
print ("**************************")
#---------------

ds_pin = machine.Pin(22)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
roms = ds_sensor.scan()

while True:
    #--DHT22--------------------------------------------   
    T, H = dht_sensor.read()
    if T is None:
        print("Error en el sensor!")
    else:
        print("Sensor DHT22->","{}ºC  {}%".format(T,H))
       
    #--LDR--------------------------------------------
    reading = analog_value.read_u16()    
    print("LDR-> ADC: ",reading)
   
    #..BMP180---------------------------------------------   
    temperatura = bmp180.temperature
    presion = bmp180.pressure/100
    alt2=44330.0* (1-pow(presion/baseline,1/5.255) )   
    alt2=ALTURA+alt2
       
    alt2=round(alt2)
    temperatura=round(temperatura,1)
    presion=round(presion)
           
    print("Tem_BMP180=",temperatura,"ºC Presion=", presion," ALTITUD=",alt2)
   
    #--DS18B20--------------------------------------------
    ds_sensor.convert_temp()
    time.sleep_ms(750)
    x=0
    for rom in roms:
        #print ("Sensor=",x,"  ",rom,"  Temperatura=",ds_sensor.read_temp(rom))
        print ("Sensor_DS18B20_nº",x,"  ","  Temperatura=",ds_sensor.read_temp(rom))
        x=x+1
   
    print("---------------------")
    led.value(0)
    utime.sleep(0.5)
    led.value(1)
    utime.sleep(0.5)


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.

# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 31-08-2022

import machine
import utime
from bmp180 import BMP180
from machine import I2C, Pin
import onewire, ds18x20, time

from DHT22 import DHT22
from machine import Pin
from ssd1306 import SSD1306_I2C

led = machine.Pin(25, machine.Pin.OUT)

dht_sensor=DHT22(Pin(15),dht11=False)

analog_value = machine.ADC(28)

i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=200000) 
bmp180 = BMP180(i2c)
bmp180.oversample_sett = 2
baseline = bmp180.pressure/100
ALTURA = 790

WIDTH  = 128                                            # oled display width
HEIGHT = 64
oled = SSD1306_I2C(WIDTH, HEIGHT, i2c)

print ("Doble sensor DHT22 y DS18x20")
#Write in cmd found addresses

i2cScan = i2c.scan()
counter = 0
for i in i2cScan:
    print('I2C Address ' + str(counter) + '      : '+hex(i).upper())
print ("**************************")
#---------------

ds_pin = machine.Pin(22)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
roms = ds_sensor.scan()

while True:
    #--DHT22--------------------------------------------   
    T, H = dht_sensor.read()
    if T is None:
        print("Error en el sensor!")
    else:
        print("Sensor DHT22->","{}ºC  {}%".format(T,H))
       
    #--LDR--------------------------------------------
    reading = analog_value.read_u16()    
    print("LDR-> ADC: ",reading)
   
    #..BMP180---------------------------------------------   
    temperatura = bmp180.temperature
    presion = bmp180.pressure/100
    alt2=44330.0* (1-pow(presion/baseline,1/5.255) )   
    alt2=ALTURA+alt2
       
    alt2=round(alt2)
    temperatura=round(temperatura,1)
    presion=round(presion)
           
    print("Tem_BMP180=",temperatura,"ºC Presion=", presion," ALTITUD=",alt2)
   
    #--DS18B20--------------------------------------------
    ds_sensor.convert_temp()
    time.sleep_ms(750)
    x=0
    for rom in roms:
        #print ("Sensor=",x,"  ",rom,"  Temperatura=",ds_sensor.read_temp(rom))
        print ("Sensor_DS18B20_nº",x,"  ","  Temperatura=",ds_sensor.read_temp(rom))
        x=x+1
   
    oled.fill(0)
    oled.text("-Seta43- ",0,8)
    tmp=str(T)+" C  DHT22"
    oled.text(tmp,0,16)
    tmp=str(H)+" %  DHT22"
    oled.text(tmp,0,24)
    tmp=str(presion)+" mBa BMP180"
    oled.text(tmp,0,32)
    tmp=str(alt2)+   " m   BMP180"
    oled.text(tmp,0,40)
    tmp=str(reading)+" luz LDR"
    oled.text(tmp,0,48)
    oled.show()

   
    print("---------------------")
    led.value(0)
    utime.sleep(0.5)
    led.value(1)
    utime.sleep(0.5)


Como se puede entender, para el funcionamiento de todo, se hace uso de varias librerías.
Para que funcione las librerías deben ser copiadas a la raspberry pi pico.

 

PROGRAMAS Y LIBRERÍAS

VÍDEO


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
seta_PIB
seta_PIA
https://lindevs.com/set-up-raspberry-pi-pico-sdk-on-ubuntu
https://www.electroniclinic.com/raspberry-pi-pico-rp2040-programming-in-micropython-with-examples/
https://www.youtube.com/watch?v=2gihPgEkvL8
https://picockpit.com/raspberry-pi/es/todo-sobre-la-frambuesa-pi-pico/


sábado, 27 de agosto de 2022

Raspberry pi pico programación C Semáforo

  Página principal

Raspberry pi pico
programación C
Semáforo



Anteriormente se realizó estos dos montaje programando en python y IDE arduino, ahora lo realizo en C.
En estos dos primeros montajes realizaré un parpadeo de un LED y en el segundo un semáforo.
Para programar en C debemos instalar una SDK.

https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf

He realizado un pequeño tutorial en vídeo de como instalar el SDK sobre Linux - Debian11.



Estos son los pasos para instalar y compilar con la SDK

Fuente capítulo 2 de "Getting started with Raspberry Pi Pico"


ROOT
====
sudo apt update
sudo apt install cmake gcc-arm-none-eabi libnewlib-arm-none-eabi build-essential


USUARIO
=======
cd ~/
mkdir pico
cd pico

git clone -b master https://github.com/raspberrypi/pico-sdk.git
cd pico-sdk
git submodule update --init
cd ..
git clone -b master https://github.com/raspberrypi/pico-examples.git

----Update----
cd pico-sdk
git pull
git submodule update


----Compilar ejemplos ---

cd pico-examples
mkdir build
cd build
export PICO_SDK_PATH=../../pico-sdk
cmake ..


cd blink
make -j4

---Encende la Raspberry pi pico mientras está pulsado botón BOOT--
cp blink.uf2 /media/USUARIO/RPI-RP2/


Para que no tenga que desconectar y conectar el usb cada vez que cargo un programa la raspberry pi pico, he colocado un pulsador en el pin 3v3_ENABLE.
Ahora cada vez que tengo que probar un programa, solo tengo que pulsar a la vez los botones BOOT y 3v3_ENABLE, y soltar 3v3_ENABLE y BOOT, por este orden.
Inmediatamente se pondrá en el modo de carga de programa.



En la propia placa de Raspberry se incluye un LED en el pin GP25, aunque externamente no se puede acceder al pin GP25.
He utilizado el programa de Blink que viene en ejemplos.


/*
 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include "pico/stdlib.h"

int main() {
#ifndef PICO_DEFAULT_LED_PIN
#warning blink example requires a board with a regular LED
#else
    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
    while (true) {
        gpio_put(LED_PIN, 1);
        sleep_ms(100);
        gpio_put(LED_PIN, 0);
        sleep_ms(400);
    }
#endif
}
blink.c

add_executable(blink
        blink.c
        )

# pull in common dependencies
target_link_libraries(blink pico_stdlib)

# create map/bin/hex file etc.
pico_add_extra_outputs(blink)

# add url via pico_set_program_url
example_auto_set_url(blink)
CMakeLists.txt




En el segundo montaje realizo un simple semáforo.
Se utilizan 5 pin de la Raspberry, 3 son para las luces de los coches, y 2 para las luces de los peatones.

Entorno para compilar Semaforo
#!/bin/sh
export PICO_SDK_PATH=~/pico/pico-sdk
echo ======ENTORNO============
echo ENTORNO
echo $PICO_SDK_PATH
echo ======COMPILAR===========
echo 'mkdir build && cd build'
echo cmake ..
echo make 
echo 'make -j$(nproc)'
echo 'cp programaPI.uf2 /media/usuario/RPI-RP2/'
echo




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


/*
# SEMÁFORO PARA RASPBERRY PI PICO en C
# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 25-08-2022
*/

#define sROJO 18
#define sAMARILLO 19
#define sVERDE 20

#define pVERDE 17
#define pROJO 16

int tPARPADEO=400;
int tSEMAFORO=10000;
int tAMARILLO=3000;
long tPEATON=6000;

int main()
{
    stdio_init_all();
    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
   
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
   
    gpio_init(sROJO);
    gpio_set_dir(sROJO, GPIO_OUT);
    gpio_init(sAMARILLO);
    gpio_set_dir(sAMARILLO, GPIO_OUT);
    gpio_init(sVERDE);
    gpio_set_dir(sVERDE, GPIO_OUT);
   
    gpio_init(pROJO);
    gpio_set_dir(pROJO, GPIO_OUT);
    gpio_init(pVERDE);
    gpio_set_dir(pVERDE, GPIO_OUT);
 
   
    printf("Hello world %d\n",LED_PIN);

    while (true)
    {
      gpio_put(sAMARILLO, 0);
      gpio_put(sROJO, 1);
      gpio_put(pROJO, 0);
      gpio_put(pVERDE, 1);
      sleep_ms(tPEATON);
     
      for(int z=0;z<=7;++z)
          {
            gpio_put(pVERDE, 0);
            sleep_ms(tPARPADEO);
            gpio_put(pVERDE, 1);
            sleep_ms(tPARPADEO);
          }
      gpio_put(pROJO, 1);
      sleep_ms(1000);

      gpio_put(sVERDE, 1);
      gpio_put(sROJO, 0);
      sleep_ms(tSEMAFORO);
      gpio_put(sAMARILLO, 1);
      gpio_put(sVERDE, 0);
      sleep_ms(tAMARILLO);
     
    }
}

main.c

cmake_minimum_required(VERSION 3.13)

include($ENV{PICO_SDK_PATH}/external/pico_sdk_import.cmake)

project(programaPI C CXX ASM)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

pico_sdk_init()

add_executable(${PROJECT_NAME} main.c)

pico_add_extra_outputs(${PROJECT_NAME})

target_link_libraries(${PROJECT_NAME} pico_stdlib)

pico_enable_stdio_usb(${PROJECT_NAME} 1)
pico_enable_stdio_uart(${PROJECT_NAME} 0)

CMakeLists.txt

He realizado el mismo programa pero creando funciones tipo arduino.

/*
# SEMÁFORO PARA RASPBERRY PI PICO en C
# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 25-08-2022
*/

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

#define sROJO 18
#define sAMARILLO 19
#define sVERDE 20

#define pVERDE 17
#define pROJO 16

int tPARPADEO=400;
int tSEMAFORO=10000;
int tAMARILLO=3000;
long tPEATON=6000;


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

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);
}



int main()
{
      stdio_init_all();
      pinMode(sROJO, OUTPUT);
      pinMode(sAMARILLO, OUTPUT);
      pinMode(sVERDE, OUTPUT);

      pinMode(pVERDE, OUTPUT);
      pinMode(pROJO, OUTPUT);

      //#INICIALIZAR
      digitalWrite(sAMARILLO, HIGH);
      digitalWrite(sROJO, HIGH);
      digitalWrite(sVERDE, LOW);
      digitalWrite(pROJO, HIGH);
      digitalWrite(pVERDE, LOW);
      delay(1000);
   
    while(1)
    {
      digitalWrite(sAMARILLO, LOW);
      digitalWrite(sROJO, HIGH);
      digitalWrite(pROJO, LOW);
      digitalWrite(pVERDE, HIGH);
      delay(tPEATON);

      //Parpadeo verde peatón
      for(int z=0;z<=7;++z)
      {
        digitalWrite(pVERDE, LOW);
        delay(tPARPADEO);
        digitalWrite(pVERDE, HIGH);
        delay(tPARPADEO);
      }
      digitalWrite(pROJO, HIGH);
      delay(1000);

      digitalWrite(sVERDE, HIGH);
      digitalWrite(sROJO, LOW);
      delay(tSEMAFORO);
      digitalWrite(sAMARILLO, HIGH);
      digitalWrite(sVERDE, LOW);
      delay(tAMARILLO);
    }
   
}

main.c


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
seta_PIB
seta_PIA
https://lindevs.com/set-up-raspberry-pi-pico-sdk-on-ubuntu
https://www.electroniclinic.com/raspberry-pi-pico-rp2040-programming-in-micropython-with-examples/
https://www.youtube.com/watch?v=2gihPgEkvL8
https://picockpit.com/raspberry-pi/es/todo-sobre-la-frambuesa-pi-pico/