KAmodRPi Pico Prototyping Platform (PL)

Opis

KAmodRPi Pico Prototyping Platform - Uniwersalny System Prototypowy dla Raspberry Pi Pico

KAmodRPi Pico Prototyping Platform to wielofunkcyjna płyta rozszerzeń dla modułów z serii Raspberry Pi Pico, zaprojektowana w celu usprawnienia procesów prototypowania. Urządzenie integruje najczęściej używane komponenty elektroniczne z polem stykowym, tworząc uporządkowane środowisko pracy. Dzięki wyprowadzonym złączom GPIO i wbudowanym peryferiom, użytkownik może błyskawicznie budować i testować układy bez konieczności każdorazowego przygotowywania podstawowych elementów wejścia/wyjścia.

---

Podstawowe parametry

• Standardowe złącze żeńskie 2×20 pinów dla Raspberry Pi Pico, Pico W, Pico 2 (i inne pinowo zgodne z RP2040/RP2350)
• 20-pinowe złącza męskie z wyprowadzonymi wszystkimi sygnałami RPi Pico (raster 2,54 mm)
• Złącze I2C Qwire typu JST SH 4-pin 1 mm (kompatybilne z Qwiic / STEMMA QT)
• Prototypowa płytka stykowa 400 punktów
• 4 czerwone diody LED
• 8 adresowalnych diod LED WS2812
• 4 przyciski monostabilne
• Wbudowany potencjometr oraz fotorezystor do testów ADC
• Zintegrowany przetwornik piezoelektryczny do sygnalizacji dżwiękowej
• Diody LED dla każdej linii zasilającej (3.3V, 5V, VBUS)
• Wbudowany przycisk RESET połączony z pinem RUN mikrokontrolera
• Napięcie zasilania: 5V (z portu USB Raspberry Pi Pico).
• Wymiary: 85 × 140 mm

• Obsługa mikrokontrolerów:
  • Standardowe złącze żeńskie 2×20 pinów dla Raspberry Pi Pico, Pico W, Pico 2 oraz innych modułów pinowo zgodnych z układami RP2040/RP2350.
• Wyprowadzenia sygnałów:
  • 20-pinowe złącza męskie (goldpin) z wyprowadzonymi wszystkimi sygnałami RPi Pico (raster 2,54 mm).
• Ekosystem I2C:
  • Złącze I2C Qwire typu JST SH 4-pin 1 mm (kompatybilne ze standardem Qwiic oraz STEMMA QT).
• Przestrzeń prototypowa:
  • Wysokiej jakości płytka stykowa (400 punktów połączeniowych).
• Sygnalizacja wizualna:
  • 4 czerwone diody LED.
  • 8 adresowalnych diod RGB WS2812 (standard Neopixel).
  • Dedykowane diody LED dla każdej linii zasilającej (3.3V, 5V, VBUS).
• Interfejs użytkownika:
  • 4 przyciski monostabilne.
  • Wbudowany przycisk RESET połączony bezpośrednio z pinem RUN mikrokontrolera.
• Sekcja pomiarowa i audio:
  • Wbudowany potencjometr oraz fotorezystor do testów przetwornika ADC.
  • Zintegrowany przetwornik piezoelektryczny do sygnalizacji dźwiękowej.
• Zasilanie:
  • 5V (pobierane bezpośrednio z portu USB Raspberry Pi Pico).
• Wymiary płytki: 85 × 140 mm.

---

Wyposażenie standardowe

Kod	Opis
KAmodRPi Pico Prototyping Platform	Zmontowany i uruchomiony moduł 6 x gumowa nóżka
Prototypowa płytka stykowa	Prototypowa płytka stykowa 400 punktów o wymiarach 82x55x10 mm z taśmą klejącą dwustronną
Przewody połączeniowe	Zestaw 40 szt. przewodów połączeniowych żeńsko-żeńskich, w różnych kolorach o długości 17 cm
Symetryczne końcówki złącz 2,54 mm	Złącze goldpin 1×40, męsko-męskie, symetryczne idealne do tworzenia połączeń w płytkach stykowych.

---

Przyciski

Pamiętaj o skonfigurowaniu pinów w trybie PULL_UP w kodzie

---

Diody LED

Wymagają sygnału wysokiego (High), aby się zaświecić

---

Diody WS2812

Cały pasek 8 diod sterowany jest z jednego pinu za pomocą protokołu jednoprzewodowego.

---

Przycisk RESET

Ten przycisk jest połączony na stałe z pinem RUN Raspberry Pi Pico – naciśnięcie powoduje natychmiastowy restart mikrokontrolera.

Przykładowy program

Przykładowy program testowy został przygotowany zarówno w środowisku Arduino IDE jak i w MicroPythonie (uproszczona wersja), i służy do kompleksowego przetestowania wszystkich funkcji KAmodRPi Pico Prototyping Platform. Demonstruje on interakcję między czujnikami analogowymi a elementami wykonawczymi (LED, Buzzer, RGB).
Wymagania Arduino:

• Board Manager: Raspberry Pi Pico/RP2040/RP2350
• Biblioteki: Adafruit NeoPixel

Wymagania MicroPython:

• Skrypt wykorzystuje standardowe biblioteki MicroPythona (machine, neopixel)
  
  

Działanie programu:

1. Sekwencja startowa (Self-test)

• Po uruchomieniu i inicjalizacji portu szeregowego, program wykonuje charakterystyczną sekwencję dźwiękową za pomocą buzzera, sygnalizując gotowość do pracy.

2. Inteligentne sterowanie diodami LED (Sekcja Cyfrowa)

• Tryb automatyczny: Czerwone diody LED wykonują efekt płynnego "wędrowania" (knight rider). Prędkość animacji jest dynamicznie regulowana przez fotorezystor – im jaśniej, tym szybciej diody zmieniają stan.

• Tryb ręczny: Po naciśnięciu dowolnego z 4 przycisków, animacja zostaje wstrzymana, a diody LED odpowiadają bezpośrednio stanom przycisków.

3. Interaktywny Buzzer

• Każdy z czterech przycisków przypisany jest do innej częstotliwości dźwięku (od 500 Hz do 2000 Hz). Naciśnięcie przycisku generuje sygnał dźwiękowy o unikalnym tonie.

4. Pasek LED RGB (WS2812)

• Program cyklicznie wypełnia pasek 8 diod kolorami: czerwonym, zielonym i niebieskim.

• Szybkość wypełniania paska i zmiany kolorów jest kontrolowana w czasie rzeczywistym za pomocą wbudowanego potencjometru.

5. Monitor Szeregowy

• Program wysyła powitanie KAmodRPi Pico Prototyping Platform na port szeregowy (115200 bps) przy każdym restarcie, ułatwiając weryfikację połączenia z komputerem.

5. Mapowanie pinów w programie

• Diody LED: LED1-LED4 ▶ GP6, GP7, GP8, GP9

• Przyciski: SW1-SW4 ▶ GP10, GP11, GP12, GP13 (z podciąganiem PULLUP)

• Fotorezystor: LIGHT ▶ GP27 (ADC1)

• Buzzer: BUZZER ▶ GP15

• Potencjometr: POT ▶ GP26 (ADC0)

• Diody WS2812: WS2812 ▶ GP14

Program testowy w Arduino:

//board manager potrzebuje: "Raspberry Pi Pico/RP2040/RP2350" -> https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
//potrzebna biblioteka: Adafruit NeoPixel

#include <Adafruit_NeoPixel.h>
//#include <Wire.h>

//--------------------------------
#define LED1    6
#define LED2    7
#define LED3    8
#define LED4    9
#define LED_ON      1
#define LED_OFF     0
#define LED_ALL     4
#define LED_DELAY   8

#define SW1     10
#define SW2     11
#define SW3     12
#define SW4     13
#define SW_ON       0
#define SW_OFF      1
#define SW_ALL      4

#define POT_PIN     26
#define LIGHT_PIN   27

#define WS2812_PIN  14
#define NUMPIXELS   8
#define BUZZ_PIN    15

//--------------------------------
int led_sw_man(int delay);
int ws_man(int delay);
void buzz_show(int d);

int buttons;
int adj;
int buzz_time;


Adafruit_NeoPixel pixels(NUMPIXELS, WS2812_PIN, NEO_GRB + NEO_KHZ800);

//--------------------------------
void setup() {
  Serial.begin(115200);
  delay(2000);
  Serial.println("KAmodRPi Pico Prototyping Platform");

  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);

  pinMode(SW1, INPUT_PULLUP);
  pinMode(SW2, INPUT_PULLUP);
  pinMode(SW3, INPUT_PULLUP);
  pinMode(SW4, INPUT_PULLUP);

  pinMode(BUZZ_PIN, OUTPUT);

  pixels.begin();           // INITIALIZE NeoPixel strip object (REQUIRED)
  pixels.show();  
  buzz_show(200);
}

//--------------------------------
void loop() {

  adj = analogRead(LIGHT_PIN);
  buttons = led_sw_man(adj/16);

  if (buttons > 0) {
    buzz_time = 10;
    //digitalWrite(BUZZ_PIN, 1);
    if (buttons == 1) tone(BUZZ_PIN, 500);
    if (buttons == 2) tone(BUZZ_PIN, 1000);
    if (buttons == 4) tone(BUZZ_PIN, 1500);
    if (buttons == 8) tone(BUZZ_PIN, 2000);
    
  }
  if (buzz_time > 0){
      buzz_time--;
      //if (buzz_time == 0) digitalWrite(BUZZ_PIN, 0);
      if (buzz_time == 0) noTone(BUZZ_PIN);
  }

  adj = analogRead(POT_PIN);
  ws_man(adj/16);

  delay(10);
}

//--------------------------------
int ws_man(int delay){
  static int ws_i = 0;
  static int ws_led = 0;
  static int ws_color = 0;

  if (ws_i < delay){
    ws_i++;
  } else {
    ws_i=0;
        
    for (uint l = 0; l<NUMPIXELS; l++){
      if (ws_led >= l){
        if (ws_color == 0) pixels.setPixelColor(l, 255, 0, 0);
        if (ws_color == 1) pixels.setPixelColor(l, 0, 255, 0);
        if (ws_color == 2) pixels.setPixelColor(l, 0, 0, 255);
      }
    }
    pixels.show();   

    ws_led++;
    if (ws_led >= NUMPIXELS) {
      ws_led = 0;
      ws_color++;
      if (ws_color > 2) ws_color = 0;
    }
  }
  return 1;
}

//--------------------------------
int led_sw_man(int delay){
  static int led_i = 0;
  static int led_pos = 0;
  static int led_dir = 0;
  static int led_map[LED_ALL] = {LED1, LED2, LED3, LED4};
  
  int push_map;
  static int sw_map[SW_ALL] = {SW1, SW2, SW3, SW4};

  push_map = 0;
  for (int i=0; i<SW_ALL; i++){
    if (digitalRead(sw_map[i]) == SW_ON){
      push_map |= (1<<i);
    }
  }

  if (push_map > 0){
    for (int i=0; i<SW_ALL; i++){
      if ((push_map & (1<<i)) > 0){
        digitalWrite(led_map[i], LED_ON);
      } else {
        digitalWrite(led_map[i], LED_OFF);
      }
    }

  //no any push
  } else {
    if (led_i < delay){
      led_i++;
    } else {
      led_i=0;
      if (led_pos >= 0 && led_pos < LED_ALL)
        digitalWrite(led_map[led_pos], LED_OFF);

      if (led_dir == 0){
        led_pos++;
        if (led_pos >= LED_ALL){
          led_pos = (LED_ALL - 2);
          led_dir = 1;
        }
        
      } else {
        led_pos--;
        if (led_pos < 0){
          led_pos = 1;
          led_dir = 0;
        }
      }

      if (led_pos >= 0 && led_pos < LED_ALL){
        digitalWrite(led_map[led_pos], LED_ON);
      }
    }
  }

  return push_map;
}

//--------------------------------
void buzz_show(int d){
  tone(BUZZ_PIN, 1000); delay(d);
  noTone(BUZZ_PIN); delay(d);

  tone(BUZZ_PIN, 1000); delay(d);
  noTone(BUZZ_PIN); delay(d);

  tone(BUZZ_PIN, 1000); delay(d/4);
  noTone(BUZZ_PIN); delay(d/4);
  tone(BUZZ_PIN, 1000); delay(d);
  noTone(BUZZ_PIN); delay(d);

  tone(BUZZ_PIN, 1200); delay(d);
  noTone(BUZZ_PIN); delay(d);

  tone(BUZZ_PIN, 1100); delay(d/4);
  noTone(BUZZ_PIN); delay(d/4);
  tone(BUZZ_PIN, 1100); delay(d);
  noTone(BUZZ_PIN); delay(d);

  tone(BUZZ_PIN, 1000); delay(d/4);
  noTone(BUZZ_PIN); delay(d/4);
  tone(BUZZ_PIN, 1000); delay(d);
  noTone(BUZZ_PIN); delay(d);

  tone(BUZZ_PIN, 900); delay(d/4);
  noTone(BUZZ_PIN); delay(d/4);
  tone(BUZZ_PIN, 1000); delay(d);
  noTone(BUZZ_PIN); delay(d);
}

Uproszczona wersja przykładowego programu testowego w MicroPythonie:

import machine
import utime
import neopixel

# --- Konfiguracja PINów ---
# Diody LED i Przyciski
led_pins = [6, 7, 8, 9]
leds = [machine.Pin(p, machine.Pin.OUT) for p in led_pins]

sw_pins = [10, 11, 12, 13]
buttons = [machine.Pin(p, machine.Pin.IN, machine.Pin.PULL_UP) for p in sw_pins]

# Analogowe (Potencjometr i Fotorezystor)
pot = machine.ADC(26)
ldr = machine.ADC(27)

# Buzzer i WS2812
buzzer = machine.PWM(machine.Pin(15))
pixels = neopixel.NeoPixel(machine.Pin(14), 8)

def play_tone(freq, duration):
    if freq > 0:
        buzzer.freq(freq)
        buzzer.duty_u16(32768) # 50% wypełnienia
    utime.sleep_ms(duration)
    buzzer.duty_u16(0) # Wyłącz dźwięk

print("RPi Pico Prototyping Platform - Start Test")
play_tone(1000, 100) # Sygnał startowy

while True:
    # 1. Odczyt fotorezystora i sterowanie diodami LED
    light_val = ldr.read_u16()
    # Im ciemniej, tym szybciej mrugają diody (prosta logika testowa)
    speed = max(50, light_val // 100)
    
    # 2. Obsługa przycisków i buzzera
    for i in range(4):
        if buttons[i].value() == 0: # Przycisk wciśnięty
            leds[i].value(1)
            buzzer.freq(500 * (i + 1))
            buzzer.duty_u16(1000) # Cichy dźwięk przycisku
        else:
            leds[i].value(0)
            
    if all(b.value() == 1 for b in buttons):
        buzzer.duty_u16(0)

    # 3. Odczyt potencjometru i sterowanie RGB (WS2812)
    pot_val = pot.read_u16()
    brightness = pot_val // 256 # Skalowanie do 0-255
    
    # Ustawienie wszystkich diod na kolor zależny od potencjometru
    for i in range(8):
        pixels[i] = (brightness, 0, 255 - brightness)
    pixels.write()

    utime.sleep_ms(10)

---