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


domingo, 10 de julio de 2022

Arduino - Motores paso a paso Bipolares y Unipolares - DRV8825 - ULN2003

  Página principal

Arduino
Motores paso a paso Bipolares y Unipolares
DRV8825 - ULN2003

Había trabajado hace tiempo con este tipo de motores paso a paso, pero no había realizado ningún artículo.



Motores Bipolares




Control de paso a paso con DRV8825
//SETA43
//http: / / seta43.duckdns.org
//http: / / seta43.blogspot.com

#define dirPin 2
#define stepPin 3
#define enablePin 13

void setup()
{
  pinMode(enablePin, OUTPUT);
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop()
{
  Pasos(200,1,1000);
  delay(500); 
  Pasos(200,0,1000);
  delay(500); 
}

void Pasos(int pasos,bool direccion,int timePaso)
{ 
  digitalWrite(dirPin, direccion);
  digitalWrite(enablePin, LOW);
  for(int i = 0; i < pasos; i++)
    {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(timePaso);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(timePaso);
    }
  digitalWrite(enablePin, HIGH);
}


Motores Unipolares





El modelo 28byj48 tiene engranajes para producir mas fuerza.




-Relación de reducción de engranajes
Según la hoja de datos, cuando el motor 28BYJ-48 funciona en modo de paso completo, cada paso corresponde a una rotación de 11,25°. Esto significa que hay 32 pasos por revolución (360°/11,25° = 32).

Aparte de esto, el motor tiene un juego de engranajes reductores de 1/64. (en realidad es 1/63.68395 pero para la mayoría de los propósitos 1/64 es una aproximación lo suficientemente buena)

Esto significa que en realidad hay 2038 pasos (32*63,68395 pasos por revolución = 2037,8864 aproximadamente 2038 pasos).

-El consumo de energía
El 28BYJ-48 normalmente consume alrededor de 240 mA.

Dado que el motor consume mucha energía, es mejor alimentarlo directamente desde una fuente de alimentación externa de 5 V en lugar de extraer esa energía del Arduino.
Fuente:  https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/

//modificado por SETA43
//http: / / seta43.duckdns.org
//http: / / seta43.blogspot.com
//https://www.luisllamas.es/motor-paso-paso-28byj-48-arduino-driver-uln2003/


//definicion de pins
const int motorPin1 = 2;    // 28BYJ48 In1
const int motorPin2 = 3;    // 28BYJ48 In2
const int motorPin3 = 4;   // 28BYJ48 In3
const int motorPin4 = 5;   // 28BYJ48 In4
                  

int stepCounter = 0;     // contador para los pasos
int stepsPerRev = 4076;  // pasos para una vuelta completa


#define FASE3

#ifdef FASE1
//secuencia 1-fase
const int numSteps = 4;
const int stepsLookup[4] = { B1000, B0100, B0010, B0001 };
#endif

#ifdef FASE2
//secuencia 2-fases
const int numSteps = 4;
const int stepsLookup[4] = { B1100, B0110, B0011, B1001 };
#endif

#ifdef FASE3
//secuencia media fase
const int numSteps = 8;
const int stepsLookup[8] = { B1000, B1100, B0100, B0110, B0010, B0011, B0001, B1001 };
#endif

void setup()
{
  //declarar pines como salida
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop()
{
  Pasos(1000,1,1000);
  delay(500); 
  Pasos(1000,0,1000);
  delay(500);
}



void Pasos(int pasos,bool direccion,int timePaso)
{
  for(int i = 0; i < pasos; i++)
    {
    if(direccion==1)
      {
        stepCounter++;
        if (stepCounter >= numSteps) stepCounter = 0;
        setOutput(stepCounter);
        delayMicroseconds(timePaso);
      }
      else
      {
        stepCounter--;
        if (stepCounter < 0) stepCounter = numSteps - 1;
        setOutput(stepCounter);
        delayMicroseconds(timePaso);
      }
    }
  digitalWrite(motorPin1, 0);
  digitalWrite(motorPin2, 0);
  digitalWrite(motorPin3, 0);
  digitalWrite(motorPin4, 0);
}

void setOutput(int step)
{
  digitalWrite(motorPin1, bitRead(stepsLookup[step], 0));
  digitalWrite(motorPin2, bitRead(stepsLookup[step], 1));
  digitalWrite(motorPin3, bitRead(stepsLookup[step], 2));
  digitalWrite(motorPin4, bitRead(stepsLookup[step], 3));
}

AVISO:
En muchos de los montajes que he visto, al parar el motor se sigue alimentando la bobinas.
Esto produce un alto consumo de intensidad, por lo cual se calienta tanto el driver como los motores.
Por lo cual, cuando están parados los motores, deshabilito el paso de corriente por los bobinados de los motores.
En el caso de los unipolares:

  digitalWrite(motorPin1, 0);
  digitalWrite(motorPin2, 0);
  digitalWrite(motorPin3, 0);
  digitalWrite(motorPin4, 0);
Los bipolares con:

  digitalWrite(enablePin, HIGH);


VIDEO

Saludos.
Juan Galaz



Bibliografía:

https://www.luisllamas.es/motores-paso-paso-arduino-driver-a4988-drv8825/
https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/

lunes, 4 de julio de 2022

El Tiempo - Forecast - Gambas

  Página principal

El Tiempo - Forecast
Gambas

Con el lenguaje Gambas hacer programas es fácil, y como muestra es este.
Son dos programas:
-El uno toma la IP y localiza el lugar de donde se pide la información del tiempo.
-El segundo programa nos pide el lugar de donde queremos que muestre el tiempo atmosférico
Los datos se toman de la página:
        http://wttr.in/?lang=es
Es una página que muestra la información en modo texto.
Para extraer los datos que usará nuestro programa hacemos uso del comando curl , este programa normalmente se encuentra de serie instalado en Linux




He añadido también los programas compilados en Debian9 32Bits, que funcionan bien en Debian11 64Bits.
En versiones antiguas de gambas, no funcionaba bien las transparencias ni las fuentes en modo gráfico.
Los datos que proporciona wttr.in proceden de diferentes sitios, por lo que deberemos seleccionar el mejor vd que se adapte a nuestra zona.
Otra posibilidad es de colocar los códigos de los aeropuertos, en : http://www.airportsinspain.net/list-of-all-airports-in-spain se pueden encontrar.
Como ejemplo:  Barajas Airport ->MAD,  Barcelona->  BCN

VIDEO

PROGRAMAS

Saludos.
Juan Galaz




martes, 14 de junio de 2022

Arduino nano ,Radio RDA5807, Representación OLED con RDS

  Página principal

Arduino nano
Radio RDA5807
Representación OLED con RDS

Hace uno años hice  rards.html  con  la visualización en un LCD 3310 y decodificación del RDS.
Me habían pedido que lo hiciera con
OLED SSD1306Z y botones pulsadores tipo TOUCH (sin contacto).



Como no tengo símbolos de los TOUCH los he sustituido en el esquema por botones normales, aunque el diseño está realizado con TOUCH.








Espero que este montaje os haya parecido interesante.

PROGRAMAS

Saludos.
Juan Galaz



Bibliografía:

radiofm.html
rards.html
ardura.html
 
http://arduino.vom-kuhberg.de/index.php
RADIO DATA SYSTEM- RDS- Por: Aitzol Zuloaga Izaguirre.
http://www.rds.org.uk/2010/Overview.htm

viernes, 10 de junio de 2022

Crear circuitos impresos (PCB) con CNC

  Página principal


Crear circuitos impresos (PCB)
con
KICAD, FlatCAM, Candle, y CNC 3018.
II
xsetaseta@gmail.com


Otro tutorial de como hacer PCB con CNC.
Muestro todos los pasos realizados, desde el esquema hasta el resultado final.

























Vídeo:

https://youtu.be/oUpfkn4eOkU


Otros vídeos mios:

https://www.youtube.com/watch?v=hiIxWf1nPQ4

Grabado láser:

https://www.youtube.com/watch?v=DcGGs8mYizI


Saludos.
Juan Galaz



Bibliografía:

https://www.youtube.com/watch?v=rDLayMgCDao&t=1920s
https://www.youtube.com/watch?v=OVI79Wyxb7g
https://www.youtube.com/watch?v=3CxX6W2Vp10
https://www.youtube.com/watch?v=gPt6krMi-pE