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/
Publicado por en No hay comentarios:
Etiquetas: , , , , , , , ,

jueves, 25 de agosto de 2022

Raspberry pi pico IDE Arduino, BLINK, Semáforo

  Página principal

Raspberry pi pico
IDE Arduino
Práctica 1 y 2

Anteriormente se realizó estos dos montaje programando en python, ahora lo realizo con el interface de arduino.
En estos dos primeros montajes realizaré un parpadeo de un LED y en el segundo un semáforo.
Para añadir esta tarjeta a la interface de arduino debemos realizar una serie de pasos.
He realizado un pequeño tutorial en vídeo de como instalar la tarjeta en arduino sobre Linux.
Video tutorial.

Enlace para instalar la placa en arduino.

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

Para los que les guste una explicación mas completa os dejo 3 enlaces:

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/


En la propia placa de Raspberry se incluye un LED en el pin GP25, aunque externamente no se puede acceder al pin GP25.



/*
  Blink
*/

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop()
{
  digitalWrite(LED_BUILTIN, HIGH); 
  delay(100);                     
  digitalWrite(LED_BUILTIN, LOW); 
  delay(100);                    
}


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.
/*
# SEMÁFORO PARA RASPBERRY PI PICO
# 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;

void setup()
{
  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(2);

}


void loop()
{
  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);
 
}






VÍDEOS
En cuestión de consumo, la placa Raspberry pi pico alimentada con 4V en el pin VSYS, el consumo es de entre 23 y 30 mA.

En cuanto a velocidad de programar en python a programar en C el resultado es el siguiente;
#python
# 74 KHz

import machine

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

while True:
    led.value(0)
    led.value(1)

//  IDE arduino
//  sin goto 606 KHz
//  con goto 798 KHz

void setup()
{
  pinMode(17, OUTPUT);
}

void loop()
{
volver:
  digitalWrite(17, HIGH);                     
  digitalWrite(17, LOW);                      
  goto volver;
}

Debemos saber que se sube a la placa el programa mucho más rápido con el entorno de Python.
Vemos también que es 10 veces más rápido el programa en C.
Para casos que no se necesite mucha rapidez, como el caso del semáforo, es más cómodo programar en Python.

Espero que este montaje os haya parecido interesante.
 
 Saludos.
 Juan Galaz


Bibliografía:
seta_PIA
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/

Publicado por en No hay comentarios:
Etiquetas: , , , , ,

miércoles, 24 de agosto de 2022

Raspberry pi pico Python Práctica 1 y 2, Blink, Semáforo

  Página principal

Raspberry pi pico
Python
Práctica 1 y 2


Este es mi primer contacto con la Raspberry pi pico, además de su programación en python.
En estos dos primeros montajes realizaré un parpadeo de un LED y en el segundo un semáforo.
Para programar en python debemos realizar unos pasos previos. He realizado un pequeño tutorial en vídeo de como instalar el entorno python sobre Linux.
Video tutorial.
Para los que les guste una explicación mas completa os dejo dos enlaces:

https://www.electroniclinic.com/raspberry-pi-pico-rp2040-programming-in-micropython-with-examples/
https://www.youtube.com/watch?v=2gihPgEkvL8

En la propia placa de Raspberry se incluye un LED en el pin GP25, aunque externamente no se puede acceder al pin GP25.
También he colocado un LED externo conectado al pin GP26 mediante una resistencia de 1K.
import machine
import utime

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

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



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.
# SEMÁFORO PARA RASPBERRY PI PICO
# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 24-08-2022

import machine
import utime


sROJO = machine.Pin(18, machine.Pin.OUT)
sAMARILLO = machine.Pin(19, machine.Pin.OUT)
sVERDE = machine.Pin(20, machine.Pin.OUT)

pROJO = machine.Pin(16, machine.Pin.OUT)
pVERDE = machine.Pin(17, machine.Pin.OUT)

tPARPADEO=0.4
tSEMAFORO=10
tAMARILLO=3
tPEATON=6

#INICIALIZAR
sAMARILLO.value(1)
sROJO.value(1)
sVERDE.value(0)
pROJO.value(1)
pVERDE.value(0)
utime.sleep(2)

while True:
    sAMARILLO.value(0)
    sROJO.value(1)
    pROJO.value(0)
    pVERDE.value(1)
    utime.sleep(tPEATON)
   
    #PARPADEO VERDE PEATON
    for i in range(0, 7):
        pVERDE.value(0)
        utime.sleep(tPARPADEO)
        pVERDE.value(1)
        utime.sleep(tPARPADEO)  
    pROJO.value(1)
    utime.sleep(1)
   
    sVERDE.value(1)
    sROJO.value(0)
    utime.sleep(tSEMAFORO)   
    sAMARILLO.value(1)
    sVERDE.value(0)
    utime.sleep(tAMARILLO)






VÍDEO SEMÁFORO

Espero que este montaje os haya parecido interesante.


 Saludos.
 Juan Galaz


Bibliografía:
https://www.electroniclinic.com/raspberry-pi-pico-rp2040-programming-in-micropython-with-examples/
https://www.youtube.com/watch?v=2gihPgEkvL8


Publicado por en No hay comentarios:
Etiquetas: , , , ,
Suscribirse a: Entradas (Atom)