Mostrando entradas con la etiqueta semáforo. Mostrar todas las entradas
Mostrando entradas con la etiqueta semáforo. Mostrar todas las entradas

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/


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/

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


jueves, 9 de noviembre de 2017

Creador de programas para Arduino con interface gráfica hecha con Gambas

Página principal


Creador de programas
para
Arduino
con interface gráfica hecha
con
 Gambas

xsetaseta@gmail.com


En un anterior artículo había descubierto Visualino , una curiosa aplicación para hacer programas de arduino en forma gráfica. En este artículo había realizado un semáforo, y la verdad me gusto hacerlo de esta manera, gráficamente.
Picado por la curiosidad, y preguntándome si yo podía hacer este tipo de programa, me puse manos a la obra.
En un principio pensé hacerlo en C, pero como tenía Gambas una especie de VB para Linux elegí la forma fácil, realizarlo en el Basic de Gambas.
Se realizo mediante Gambas 3.5.4  bajo Debian 8 ,no he probado si funciona en otras versiones.
Fueron días y días de pruebas, de creación de bloques enlazados. Tuve que rehacer completamente el programa por problemas de diseño.
Como conclusión puedo decir que me quedó un programa digno, sin mas ambiciones.
Se podría haber añadido muchas mas funciones y librerías, pero lo he dejado en las funciones básicas.
Si queremos añadir alguna orden mas, podemos emplear el texto literal, que nos dará la posibilidad de hacer lo que queramos.
Como prueba práctica he realizado un semáforo, se puede ver el vídeo de su creación.
Espero que le guste a alguien y que le de ideas para hacer otros programas.
Mi idea es realizar el programa en C con las librerías wxwidgets , pero ahora tengo que recuperarme de este complicado programa.
El programa está limitado a 100 bloques, por lo que se puede quedar un poco corto para algunos programas. El que quiera puede aumentarlo todo lo que quiera cambiando las líneas de FMain.class  donde figuran la creación del numero de bloques:
Public Const MaxBloque As Integer = 99
Public Braiz[100] As Integer
.........
No arrastrar mas de un bloque sobre otro, aún no está implementado y produce errores.


Interface gráfico


Comandos posibles




VIDEO


 En el fichero del programa se encuentra el fichero fuente, la versión binaria ejecutable, y el paquete DEB por si quieres instalarlo.
Programa


Saludos.
Juan Galaz