Skip to content

Promake Raspberry Pico Kit

Description

"ProMake® Raspberry® Pico Kit" is a Compact, cost effective & Flexible solution for Raspberry Pico MCU Module and other pin compatible products. It Provides 3 ProMake® module slots and can be used in a wide range of different applications.

RPi Pico is based on a powerful dual core ARM Cortex M0+ RP2024 microcontroller, with the high clock frequency that can operate at up to 133 MHz, which is several times higher than many competing microcontrollers based on this architecture. It can be used in the small embedded systems segment. It also allows creating projects based on C/C++ and MicroPython programming languages.

Features

  • Easy Mounted Promake Modules , No need to Soldering.
  • Supports up to three ProMake Modules
    • SPI,Serial,I2C Interface and 3 GPIO to First Module
    • SPI & I2C Interface and one GPIO to Second Module
    • I2C, Serial Interface and 4 GPIO to third Module
  • Supporting RTC Chip with Backup Battery
  • One Buzzer
  • Two RGB Leds
  • One IR Receiver Led
  • Two Push button
  • SparkFun QWIIC & Seeed Studio Grove Expansion Connectors
  • Special header for I2C OLED Display support

Specification

  • Board Dimensions : 90cm x 72cm
  • POWER Options :
  • On board USB Type-C Connector
  • External Power Connector
  • PICO Module USB Port
  • 3.3V OnBoard LDO Maximum Current: 600mA

Resources

Board Schematic

Board Versions

Software

RGB RainBOW LEDs

# Example using PIO to drive a set of WS2812 LEDs.

import array, time
from machine import Pin
import rp2

# Configure the number of WS2812 LEDs.
NUM_LEDS = 2
PIN_NUM = 14
brightness = 0.2

@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=24)
def ws2812():
    T1 = 2
    T2 = 5
    T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()


# Create the StateMachine with the ws2812 program, outputting on pin
sm = rp2.StateMachine(0, ws2812, freq=8_000_000, sideset_base=Pin(PIN_NUM))

# Start the StateMachine, it will wait for data on its FIFO.
sm.active(1)

# Display a pattern on the LEDs via an array of LED RGB values.
ar = array.array("I", [0 for _ in range(NUM_LEDS)])

##########################################################################
def pixels_show():
    dimmer_ar = array.array("I", [0 for _ in range(NUM_LEDS)])
    for i,c in enumerate(ar):
        r = int(((c >> 8) & 0xFF) * brightness)
        g = int(((c >> 16) & 0xFF) * brightness)
        b = int((c & 0xFF) * brightness)
        dimmer_ar[i] = (g<<16) + (r<<8) + b
    sm.put(dimmer_ar, 8)
    time.sleep_ms(10)

def pixels_set(i, color):
    ar[i] = (color[1]<<16) + (color[0]<<8) + color[2]

def pixels_fill(color):
    for i in range(len(ar)):
        pixels_set(i, color)

def color_chase(color, wait):
    for i in range(NUM_LEDS):
        pixels_set(i, color)
        time.sleep(wait)
        pixels_show()
    time.sleep(0.2)

def wheel(pos):
    # Input a value 0 to 255 to get a color value.
    # The colours are a transition r - g - b - back to r.
    if pos < 0 or pos > 255:
        return (0, 0, 0)
    if pos < 85:
        return (255 - pos * 3, pos * 3, 0)
    if pos < 170:
        pos -= 85
        return (0, 255 - pos * 3, pos * 3)
    pos -= 170
    return (pos * 3, 0, 255 - pos * 3)


def rainbow_cycle(wait):
    for j in range(255):
        for i in range(NUM_LEDS):
            rc_index = (i * 256 // NUM_LEDS) + j
            pixels_set(i, wheel(rc_index & 255))
        pixels_show()
        time.sleep(wait)

BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)
WHITE = (255, 255, 255)
COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)

print("fills")
for color in COLORS:
    pixels_fill(color)
    pixels_show()
    time.sleep(0.2)

print("chases")
for color in COLORS:
    color_chase(color, 0.01)

while(True):
    print("rainbow")
    rainbow_cycle(0)

RTC(DS1307) and I2C LCD

import machine
from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
import framebuf,sys
import ds1307

#############################################################

i2c_dev = I2C(0,scl=Pin(17),sda=Pin(16),freq=200000)  # start I2C on I2C1 (GPIO 16/17)

print('Scan i2c bus...')
devices = i2c_dev.scan()

if len(devices) == 0:
  print("No i2c device !")
else:
  print('i2c devices found:',len(devices))

  for device in devices:  
    print("Decimal address: ",device," | Hexa address: ",hex(device))

#############################################################

ds = ds1307.DS1307(i2c_dev)
print(ds.datetime())

#now = (2022, 2, 4, 6, 13, 52, 00, 0)
#ds.datetime(now)
print(ds.datetime())

real_time = ds.datetime()
#print(type(real_time))
Year = real_time[0]
Month = real_time[1]
Day = real_time[2]
Hour = real_time[4]
Minute = real_time[5]
Second = real_time[6]

#print(Year)

########################################################################

pix_res_x  = 128 # SSD1306 horizontal resolution
pix_res_y = 32   # SSD1306 vertical resolution

oled = SSD1306_I2C(pix_res_x, pix_res_y, i2c_dev) # oled controller

oled.fill(0) # clear the OLED

start_x = 0 # start point for text in x-dir
start_y = 2 # start point for text in y-dir
lineskip = 20 # space between text in y-dir

while(True):
    real_time = ds.datetime()
#print(type(real_time))
    #Year = real_time[0]
    #Month = real_time[1],Day = real_time[2]
    #Hour = real_time[4],Minute = real_time[5],Second = real_time[6]
    txt_array = [str(real_time[0])+str(real_time[1])+''+str(real_time[2])+' '+
                 str(real_time[4])+':'+str(real_time[5])+':'+str(real_time[6]),'DS1307 RTC Test PICO'] # text array
    for iter_ii,txt in enumerate(txt_array):
        oled.text(txt,start_x,start_y+(iter_ii*lineskip)) # add text at (start_x,start_y)

    oled.show() # show the new text and image

    # other functions
    # oled.poweron() # power on the OLED
    # oled.poweroff() # power off the OLED (save power)
    oled.invert(0) # invert the colors from dark -> light, and light -> dark
    oled.fill(0) # clear the OLED

    # oled.contrast(1) # lower brightness
    oled.contrast(255) # increase brightness
    #ds.datetime(now)

Buzzer and IR and I2C OLED

from machine import Pin, I2C,ADC
from time import sleep
import ssd1306


i2c = I2C(0, sda=Pin(16), scl=Pin(17))

display = ssd1306.SSD1306_I2C(128, 32, i2c)

ir = machine.Pin(28, machine.Pin.IN)

Buzzer = machine.Pin(20, machine.Pin.OUT)

LED = machine.Pin(14,machine.Pin.OUT)

while(True):
    if ir.value() == 0:
        #value = ir.read_u16()
        display.fill(0)
        #display.text(str(ir), 0, 1, 1)
        display.text(str(ir.value()),0,10,1)
        display.show()
        Buzzer.toggle()
        sleep(.05)

Sounding Buzzer


from machine import Pin, PWM
from utime import sleep

buzzer = PWM(Pin(20))

frequency = 100
Counter = 0 
while(Counter < 12 ):
    Counter = Counter + 1
    buzzer.freq(frequency*Counter)
    buzzer.duty_u16(5000)
    sleep(0.5)

buzzer.duty_u16(0)