# THE SOFTWARE. import time import digitalio import board import adafruit_ssd1306 import urllib, json import socket from PIL import Image from PIL import ImageDraw from PIL import ImageFont import subprocess # Raspberry Pi pin configuration: oled_reset = digitalio.DigitalInOut(board.D4) # Change these # to the right size for your display! WIDTH = 128 HEIGHT = 64 # Change to 64 if needed BORDER = 5 i2c = board.I2C() disp = adafruit_ssd1306.SSD1306_I2C(WIDTH, HEIGHT, i2c, addr=0x3C, reset=oled_reset) # Initialize library. url = "http://oeebox/fsm/monitor.dal"
# Simple example to send a message and then wait indefinitely for messages # to be received. This uses the default RadioHead compatible GFSK_Rb250_Fd250 # modulation and packet format for the radio. import board import busio import digitalio import adafruit_rfm69 # Define radio parameters. RADIO_FREQ_MHZ = 915.0 # Frequency of the radio in Mhz. Must match your # module! Can be a value like 915.0, 433.0, etc. # Define pins connected to the chip, use these if wiring up the breakout according to the guide: CS = digitalio.DigitalInOut(board.CE1) RESET = digitalio.DigitalInOut(board.D25) # Or uncomment and instead use these if using a Feather M0 RFM69 board # and the appropriate CircuitPython build: # CS = digitalio.DigitalInOut(board.RFM69_CS) # RESET = digitalio.DigitalInOut(board.RFM69_RST) # Initialize SPI bus. spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) # Initialze RFM radio rfm69 = adafruit_rfm69.RFM69(spi, CS, RESET, RADIO_FREQ_MHZ) # Optionally set an encryption key (16 byte AES key). MUST match both # on the transmitter and receiver (or be set to None to disable/the default). rfm69.encryption_key = (
import time
import board
import busio
import digitalio
from adafruit_max7219 import bcddigits
spi_mosi = board.GP3
spi_clk = board.GP2
pin_cs = board.GP5
bt_left = board.GP7 # GPIO 17 = GP7 (11)
bt_right = board.GP14 # GPIO 26 = GP14 (37)
button_l = digitalio.DigitalInOut(bt_left)
button_l.direction = digitalio.Direction.INPUT
button_l.pull = digitalio.Pull.UP
button_r = digitalio.DigitalInOut(bt_right)
button_r.direction = digitalio.Direction.INPUT
button_r.pull = digitalio.Pull.UP
spi = busio.SPI(spi_clk, MOSI=spi_mosi)
cs = digitalio.DigitalInOut(pin_cs)
display = bcddigits.BCDDigits(spi, cs, nDigits=8)
display.clear_all()
display.show_str(0,'8.8.8.8.8.8.8.8.')
#display.show_str(0,'{:9.3f}'.format(-1234.567))
display.show()
old0 = button_l.value
def getLed(pin):
led = digitalio.DigitalInOut(pin)
led.direction = digitalio.Direction.OUTPUT
led.value = True
return led
def main():
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
i2c = busio.I2C(board.SCL, board.SDA)
ecs = digitalio.DigitalInOut(board.CE0)
dc = digitalio.DigitalInOut(board.D22)
rst = digitalio.DigitalInOut(board.D27)
busy = digitalio.DigitalInOut(board.D17)
# You'll need to get a token from openweathermap.org, looks like:
# 'b6907d289e10d714a6e88b30761fae22'
OPEN_WEATHER_TOKEN = 'f1525c6af313ad137fea6d36606822c9'
# Use cityname, country code where countrycode is ISO3166 format.
# E.g. "New York, US" or "London, GB"
LOCATION = "Wenatchee, US"
DATA_SOURCE_URL = "http://api.openweathermap.org/data/2.5/weather"
if len(OPEN_WEATHER_TOKEN) == 0:
raise RuntimeError(
"You need to set your token first. If you don't already have one, you can register for a free account at https://home.openweathermap.org/users/sign_up"
)
# Set up where we'll be fetching data from
params = {"q": LOCATION, "appid": OPEN_WEATHER_TOKEN}
data_source = DATA_SOURCE_URL + "?" + urllib.parse.urlencode(params)
# Initialize the Display
display = Adafruit_SSD1675(
122,
250,
spi,
cs_pin=ecs,
dc_pin=dc,
sramcs_pin=None,
rst_pin=rst,
busy_pin=busy,
)
display.rotation = 1
gfx = Weather_Graphics(display, am_pm=True, celsius=False)
weather_refresh = None
# Try to read from the weather device
try:
bme280 = Adafruit_BME280_I2C(i2c)
except InputError as e: #TODO actually catch the proper exception and handle it
pass
while not exit.is_set():
try:
# only query the weather every 10 minutes (and on first run)
if (not weather_refresh) or (time.monotonic() -
weather_refresh) > 300:
response = urllib.request.urlopen(data_source)
if response.getcode() == 200:
value = response.read()
print("Response is", value)
gfx.display_weather(value, bme280)
weather_refresh = time.monotonic()
else:
print("Unable to retrieve data at {}".format(url))
gfx.update_time()
print('gonna wait for 3 mins')
exit.wait(180) # wait 5 minutes before updating anything again
print('done waiting for 3 mins')
except subprocess.CalledProcessError as e:
print('caught error in subprocess')
print(e)
else:
print('exiting')
gfx.clear_display()
time.sleep(1)
sys.exit(0)
import busio
import digitalio
import adafruit_max31855
import RPi.GPIO as gpio
zones = np.array([17, 27,
23]) #pin number on pi that controls each zone (1,2,3)
#setup to turn on off the gpio to control relays
gpio.setmode(gpio.BCM)
for z in zones:
gpio.setup(int(z), gpio.OUT)
#setup for themocoulple boards
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
cs1 = digitalio.DigitalInOut(board.D4)
cs2 = digitalio.DigitalInOut(board.D25)
cs3 = digitalio.DigitalInOut(board.D12)
thermo1 = adafruit_max31855.MAX31855(spi, cs1)
thermo2 = adafruit_max31855.MAX31855(spi, cs2)
thermo3 = adafruit_max31855.MAX31855(spi, cs3)
#################################################################################################
#inputs
#gets the file name of the firing shcedule to use
#if nothin is typed it allow you to enter a fixed setpoint value
setFileName = input(
"Enter file name of the firing schedule(press enter to use fixed value)\n")
if setFileName == "":
setFile = False
#!/usr/bin/python3
import board
import digitalio
import busio
print("Hello blinka!")
# Try to great a Digital input
pin = digitalio.DigitalInOut(board.D4)
print("Digital IO ok!")
# Try to create an I2C device
i2c = busio.I2C(board.SCL, board.SDA)
print("I2C ok!")
# Try to create an SPI device
#spi = busio.SPI(board.SCLK, board.MOSI, board.MISO)
#print("SPI ok!")
print("done!")
ret_value["stale_shares"] = stale_shares
return ret_value
if len(sys.argv) != 3 or (sys.argv[1] != "ethermine" and sys.argv[1] != "flexpool" and sys.argv[1] != "hiveon"):
print("Usage: sudo python3 miner.py ethermine|flexpool|hiveon wallet")
exit
pool = sys.argv[1]
wallet = sys.argv[2]
if wallet.startswith("0x"):
wallet = wallet[2:]
value_api_url = "https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd"
# Configuration for CS and DC pins (these are FeatherWing defaults on M0/M4):
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.CE1)
reset_pin = None
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 24000000
# Setup SPI bus using hardware SPI:
spi = busio.SPI(clock=SCK, MOSI=MOSI, MISO=MISO)
# Create the ST7789 display:
disp = hx8357.HX8357(spi, cs=cs_pin, dc=dc_pin, rst=reset_pin, baudrate=BAUDRATE,
width=99, height=99)
# Create blank image for drawing.
# set an initial color to use in case the user uses arrows before choosing a color.
color = [0, 0, 255] # Bright Blue
fade_color = [0, 0, 64] # Deeper Blue
# Declare a NeoPixel object on led_pin with num_leds as pixels
# No auto-write.
# Set brightness to max.
# We will be using FancyLED's brightness control.
# "pixels" will refer to the cpx's 10 onboard neopixels
# pixel = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=0.2, auto_write=False)
# "strip" will refer to neopixel strand attached to the cpx, with data pin at A1
strip = neopixel.NeoPixel(led_pin, num_leds, brightness=1, auto_write=False)
ledmode = 0 # button press counter, switch color palettes
button = digitalio.DigitalInOut(board.BUTTON_A)
button.switch_to_input(pull=digitalio.Pull.DOWN)
# FancyLED allows for assigning a color palette using these formats:
# * The first (5) palettes here are mixing between 2-elements
# * The last (3) palettes use a format identical to the FastLED Arduino Library
# see FastLED - colorpalettes.cpp
# Erin St. Blaine offers these colors in her tutorial
# https://learn.adafruit.com/animated-neopixel-gemma-glow-fur-scarf/circuitpython-code
# I don't use them all, so feel free to experiment.
blue = [fancy.CRGB(0, 0, 0), fancy.CRGB(75, 25, 255)]
forest = [
fancy.CRGB(0, 255, 0), # green
@classmethod
def _print_sta(cls, rep):
pass
@classmethod
def _print_per(cls, rep):
pass
@classmethod
def print_hex(cls, hexs):
return '0x' + ''.join([hex(h).strip('0x').zfill(2) for h in hexs])
if __name__ == '__main__':
# reset to start with a clean buffer
rst = digitalio.DigitalInOut(board.D22)
rst.direction = digitalio.Direction.OUTPUT
rst.value = False
time.sleep(1)
rst.value = True
time.sleep(1)
imu = BNO080_I2C(0x4a, 3)
imu.get_shtp_errors()
prod_inf = imu.get_prod_inf()
print(
f"Product info: {imu.print_hex(prod_inf[0])}\n{imu.print_hex(prod_inf[1])}"
)
# imu.start_calib()
Adafruit Playground Bluefruit board with busio and custom lib/adafruit_apds9960/apds9960.py file sending WASD and ENTER commands to Adobe Xd prototype """ import board import time import digitalio import busio import usb_hid from adafruit_apds9960.apds9960 import APDS9960 from adafruit_hid.keyboard import Keyboard from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS from adafruit_hid.keycode import Keycode killswitch = digitalio.DigitalInOut(board.SLIDE_SWITCH) killswitch.direction = digitalio.Direction.INPUT killswitch.pull = digitalio.Pull.UP i2cA = busio.I2C(board.A1, board.A2) apdsG = APDS9960(i2cA) apdsG.enable_gesture = True apdsG.enable_proximity = True # default gesture_proximity_threshold = 50 (range 0-255)""" apdsG.gesture_proximity_threshold = 0 # default gesture_gain = 2 (range 0-3)""" apdsG.gesture_gain = 3 # default gesture_fifo_threshold = 1 (range 0-3)""" apdsG.gesture_fifo_threshold = 3 # default gesture_dimensions = 1 (range 0-3)"""
import board
import digitalio
killpin = digitalio.DigitalInOut(
board.D17) #assign killcmd to GPIO pin 18 on Raspberry Pi
killpin.direction = digitalio.Direction.OUTPUT #assign direction of pin to output/write
killpin.value = False #initialize pin value to 0
#wait for user input to either activate/deactivate switch
def kill_reboot():
cmd = input()
if cmd == "k":
return True
elif cmd == "r":
return False
def main():
killpin = digitalio.DigitalInOut(board.D17)
killpin.direction = digitalio.Direction.OUTPUT
killpin.value = False
print("k = kill\nr = reboot")
while True:
switch = kill_reboot()
killpin.value = switch
main()
from PIL import Image, ImageDraw, ImageFont
import adafruit_ssd1306
# This function allows us to grab any of our IP addresses
def get_ip_address(ifname):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(
fcntl.ioctl(
s.fileno(),
0x8915, # SIOCGIFADDR
struct.pack('256s', str.encode(ifname[:15])))[20:24])
# Setting some variables for our reset pin etc.
RESET_PIN = digitalio.DigitalInOut(board.D4)
TEXT = ''
# Very important... This lets py-gaugette 'know' what pins to use in order to reset the display
i2c = board.I2C()
oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3d, reset=RESET_PIN)
# This sets TEXT equal to whatever your IP address is, or isn't
try:
TEXT = get_ip_address(
'wlan0') # WiFi address of WiFi adapter. NOT ETHERNET
except IOError:
try:
TEXT = get_ip_address(
'eth0') # WiFi address of Ethernet cable. NOT ADAPTER
except IOError:
# This example is for use on (Linux) computers that are using CPython with # Adafruit Blinka to support CircuitPython libraries. CircuitPython does # not support PIL/pillow (python imaging library)! import time import subprocess from board import SCL, SDA, D4 import busio import digitalio from PIL import Image, ImageDraw, ImageFont import adafruit_ssd1305 # Define the Reset Pin oled_reset = digitalio.DigitalInOut(D4) # Create the I2C interface. i2c = busio.I2C(SCL, SDA) # Create the SSD1305 OLED class. # The first two parameters are the pixel width and pixel height. Change these # to the right size for your display! disp = adafruit_ssd1305.SSD1305_I2C(128, 32, i2c, reset=oled_reset) # Clear display. disp.fill(0) disp.show() # Create blank image for drawing. # Make sure to create image with mode '1' for 1-bit color.
] # Mandalorian charater sequence that is shown on the display
glyphdelays = [
0.50, 0.50, 0.50, 0.50, 0.50
] # Time that each character group is shown 0.50 is 500 milliseconds, or 1/2 of a second
graphiclist = []
#graphiclist = [ "m1.jpg", "m2.jpg", "m3.jpg", "m4.jpg", "m5.jpg"]
graphicdelays = [1.0, 1.0, 1.0, 1.0, 1.0]
# Config for display baudrate (default max is 24mhz):
BAUDRATE = 64000000
#BAUDRATE = 24000000
# Setup SPI bus using hardware SPI:
spi = board.SPI()
# Configuration for CS and DC pins (these are PiTFT defaults):
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D25)
reset_pin = digitalio.DigitalInOut(board.D24)
# pylint: disable=line-too-long
# Create the display:
if DISPLAY == "1.14 LCD":
FONTSIZE = 124
disp = st7789.ST7789(spi,
rotation=90,
width=135,
height=240,
x_offset=53,
y_offset=40,
cs=cs_pin,
dc=dc_pin,
P1: value
(and so on, same for MCP13)
}
...
IMU_1: {
ax: value
ay: value
...
}
'''
# INITIALIZE MCPs #
spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI)
cs5 = digitalio.DigitalInOut(board.D5)
cs6 = digitalio.DigitalInOut(board.D6)
cs13 = digitalio.DigitalInOut(board.D13)
mcp5 = MCP.MCP3008(spi, cs5)
mcp6 = MCP.MCP3008(spi, cs6)
mcp13 = MCP.MCP3008(spi, cs13)
# INITIALIZE IMUs #
channel = 1
imu_address_1 = 0x69
imu_address_2 = 0x68
bus = SMBus(channel)
bus.write_byte_data(imu_address_1, 0x06, 0x01)
bus.write_byte_data(imu_address_2, 0x06, 0x01)
time.sleep(0.5)
"""
'button_press_on_off.py'.
=================================================
lightswitch-like operation with two buttons and a led
"""
import board
import digitalio
led = digitalio.DigitalInOut(board.D13)
led.switch_to_output()
btn1 = digitalio.DigitalInOut(board.D2)
btn1.switch_to_input()
btn2 = digitalio.DigitalInOut(board.D3)
btn2.switch_to_input()
while True:
if not btn1.value:
led.value = False
elif not btn2.value:
led.value = True
# The pins we'll use, each will have an internal pullup
keypress_pins = [board.A1, board.A2]
# Our array of key objects
key_pin_array = []
# The Keycode sent for each button, will be paired with a control key
keys_pressed = [Keycode.A, "Hello World!\n"]
control_key = Keycode.SHIFT
# The keyboard object!
time.sleep(1) # Sleep for a bit to avoid a race condition on some systems
keyboard = Keyboard(usb_hid.devices)
keyboard_layout = KeyboardLayoutUS(keyboard) # We're in the US :)
# Make all pin objects inputs with pullups
for pin in keypress_pins:
key_pin = digitalio.DigitalInOut(pin)
key_pin.direction = digitalio.Direction.INPUT
key_pin.pull = digitalio.Pull.UP
key_pin_array.append(key_pin)
# For most CircuitPython boards:
led = digitalio.DigitalInOut(board.LED)
# For QT Py M0:
# led = digitalio.DigitalInOut(board.SCK)
led.direction = digitalio.Direction.OUTPUT
print("Waiting for key pin...")
while True:
# Check each pin
for key_pin in key_pin_array:
import audioio
import board
import digitalio
import time
import neopixel
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.2)
pixels.fill((0, 0, 0))
pixels.show()
# enable the speaker
spkrenable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)
spkrenable.direction = digitalio.Direction.OUTPUT
spkrenable.value = True
# make the 2 input buttons
buttonA = digitalio.DigitalInOut(board.BUTTON_A)
buttonA.direction = digitalio.Direction.INPUT
buttonA.pull = digitalio.Pull.DOWN
buttonB = digitalio.DigitalInOut(board.BUTTON_B)
buttonB.direction = digitalio.Direction.INPUT
buttonB.pull = digitalio.Pull.DOWN
# The two files assigned to buttons A & B
audiofiles = ["no-thats-not-gonna-do-it.wav"]
def flash(wait):
pixels.fill((0, 255, 255))
pixels.show()
import board
import digitalio
import time
import busio
import adafruit_ina219
i2c_bus = busio.I2C(board.SCL, board.SDA)
led = digitalio.DigitalInOut(board.LED)
led.direction = digitalio.Direction.OUTPUT
# Create library object on our I2C port
ina219 = adafruit_ina219.INA219(i2c_bus, 0x41)
while True:
led.value = True
time.sleep(1)
print("Bus Voltage: {} V".format(ina219.bus_voltage))
print("Shunt Voltage: {} mV".format(ina219.shunt_voltage / 1000))
print("Load Voltage: {} V".format(ina219.bus_voltage +
ina219.shunt_voltage))
print("Current: {} mA".format(ina219.current))
print("")
led.value = False
time.sleep(4)
import board
import busio
import digitalio
import adafruit_requests as requests
from adafruit_wiznet5k.adafruit_wiznet5k import WIZNET5K
import adafruit_wiznet5k.adafruit_wiznet5k_socket as socket
print("Wiznet5k WebClient Test")
TEXT_URL = "http://wifitest.adafruit.com/testwifi/index.html"
JSON_URL = "http://api.coindesk.com/v1/bpi/currentprice/USD.json"
cs = digitalio.DigitalInOut(board.D10)
spi_bus = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
# Initialize ethernet interface with DHCP
eth = WIZNET5K(spi_bus, cs)
# Initialize a requests object with a socket and ethernet interface
requests.set_socket(socket, eth)
print("Chip Version:", eth.chip)
print("MAC Address:", [hex(i) for i in eth.mac_address])
print("My IP address is:", eth.pretty_ip(eth.ip_address))
print("IP lookup adafruit.com: %s" %
eth.pretty_ip(eth.get_host_by_name("adafruit.com")))
#eth._debug = True
print("Fetching text from", TEXT_URL)
r = requests.get(TEXT_URL)
print('-' * 40)
def __init__(
self,
cols,
rows,
diode_orientation=DiodeOrientation.COLUMNS,
rollover_cols_every_rows=None,
):
self.len_cols = len(cols)
self.len_rows = len(rows)
# A pin cannot be both a row and column, detect this by combining the
# two tuples into a set and validating that the length did not drop
#
# repr() hackery is because CircuitPython Pin objects are not hashable
unique_pins = {repr(c) for c in cols} | {repr(r) for r in rows}
assert (len(unique_pins) == self.len_cols +
self.len_rows), 'Cannot use a pin as both a column and row'
del unique_pins
gc.collect()
self.diode_orientation = diode_orientation
# __class__.__name__ is used instead of isinstance as the MCP230xx lib
# does not use the digitalio.DigitalInOut, but rather a self defined one:
# https://github.com/adafruit/Adafruit_CircuitPython_MCP230xx/blob/3f04abbd65ba5fa938fcb04b99e92ae48a8c9406/adafruit_mcp230xx/digital_inout.py#L33
if self.diode_orientation == DiodeOrientation.COLUMNS:
self.outputs = [
x if x.__class__.__name__ is 'DigitalInOut' else
digitalio.DigitalInOut(x) for x in cols
]
self.inputs = [
x if x.__class__.__name__ is 'DigitalInOut' else
digitalio.DigitalInOut(x) for x in rows
]
self.translate_coords = True
elif self.diode_orientation == DiodeOrientation.ROWS:
self.outputs = [
x if x.__class__.__name__ is 'DigitalInOut' else
digitalio.DigitalInOut(x) for x in rows
]
self.inputs = [
x if x.__class__.__name__ is 'DigitalInOut' else
digitalio.DigitalInOut(x) for x in cols
]
self.translate_coords = False
else:
raise ValueError('Invalid DiodeOrientation: {}'.format(
self.diode_orientation))
for pin in self.outputs:
pin.switch_to_output()
for pin in self.inputs:
pin.switch_to_input(pull=digitalio.Pull.DOWN)
self.rollover_cols_every_rows = rollover_cols_every_rows
if self.rollover_cols_every_rows is None:
self.rollover_cols_every_rows = self.len_rows
self.len_state_arrays = self.len_cols * self.len_rows
self.state = bytearray(self.len_state_arrays)
self.report = bytearray(3)
import board
import digitalio
import time
led = digitalio.DigitalInOut(board.D3)
led.direction = digitalio.Direction.OUTPUT
print("Idle Mode is enabled...")
while True:
led.Value = False
strumUP.pull = Pull.UP
strumDOWN = DigitalInOut(board.D23)
strumDOWN.direction = Direction.INPUT
strumDOWN.pull = Pull.UP
# setup for cherry mx switches on neck
note_pins = [
board.D14, board.D2, board.D3, board.D4, board.D5, board.D6, board.D7,
board.D8, board.D9, board.D10, board.D11, board.D12
]
note_buttons = []
for pin in note_pins:
note_pin = digitalio.DigitalInOut(pin)
note_pin.direction = digitalio.Direction.INPUT
note_pin.pull = digitalio.Pull.UP
note_buttons.append(note_pin)
# setup for rotary switch
oct_sel_pins = [
board.D24, board.D25, board.D26, board.D27, board.D28, board.D29,
board.D30, board.D31
]
octave_selector = []
for pin in oct_sel_pins:
sel_pin = digitalio.DigitalInOut(pin)
sel_pin.direction = digitalio.Direction.INPUT
"""Simple test for RGB character LCD"""
import time
import board
import digitalio
import pulseio
import adafruit_character_lcd.character_lcd as characterlcd
# Modify this if you have a different sized character LCD
lcd_columns = 16
lcd_rows = 2
# Metro M0/M4 Pin Config:
lcd_rs = digitalio.DigitalInOut(board.D7)
lcd_en = digitalio.DigitalInOut(board.D8)
lcd_d7 = digitalio.DigitalInOut(board.D12)
lcd_d6 = digitalio.DigitalInOut(board.D11)
lcd_d5 = digitalio.DigitalInOut(board.D10)
lcd_d4 = digitalio.DigitalInOut(board.D9)
red = pulseio.PWMOut(board.D3)
green = pulseio.PWMOut(board.D5)
blue = pulseio.PWMOut(board.D6)
# Initialise the LCD class
lcd = characterlcd.Character_LCD_RGB(
lcd_rs,
lcd_en,
lcd_d4,
lcd_d5,
lcd_d6,
lcd_d7,
lcd_columns,
""" Example of using the library manually send Acknowledgement (ACK) messages without using the nRF24L01's ACK payloads feature. """ import time import board import digitalio # if running this on a ATSAMD21 M0 based board # from circuitpython_nrf24l01.rf24_lite import RF24 from circuitpython_nrf24l01.rf24 import RF24 # change these (digital output) pins accordingly ce = digitalio.DigitalInOut(board.D4) csn = digitalio.DigitalInOut(board.D5) # using board.SPI() automatically selects the MCU's # available SPI pins, board.SCK, board.MOSI, board.MISO spi = board.SPI() # init spi bus object # initialize the nRF24L01 on the spi bus object nrf = RF24(spi, csn, ce) # set the Power Amplifier level to -12 dBm since this test example is # usually run with nRF24L01 transceivers in close proximity nrf.pa_level = -12 # addresses needs to be in a buffer protocol object (bytearray) address = [b"1Node", b"2Node"] # to use different addresses on a pair of radios, we need a variable to
# Write the time for the Adafruit DS3231 real-time clock.
# Limor Fried/Anne Barela for Adafruit Industries
import time
import board
import busio as io
import digitalio
import adafruit_ds3231
i2c = io.I2C(board.SCL, board.SDA)
# Create the RTC instance:
rtc = adafruit_ds3231.DS3231(i2c)
LED13 = digitalio.DigitalInOut(board.D13)
LED13.direction = digitalio.Direction.OUTPUT
# pylint: disable-msg=using-constant-test
if True:
# year, mon, date, hour, min, sec, wday, yday, isdst
t = time.struct_time((2019, 7, 10, 17, 00, 0, 0, -1, -1))
# you must set year, mon, date, hour, min, sec and weekday
# yearday is not supported
# isdst can be set but we don't do anything with it at this time
print("Setting time to:", t) # uncomment for debugging
rtc.datetime = t
print("Done!")
LED13.value = True
# pylint: enable-msg=using-constant-test
"""Rotary Trinkey NeoPixel color picker example"""
import rotaryio
import digitalio
import board
from rainbowio import colorwheel
import neopixel
print("Rotary Trinkey color picker example")
pixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.5)
encoder = rotaryio.IncrementalEncoder(board.ROTA, board.ROTB)
switch = digitalio.DigitalInOut(board.SWITCH)
switch.switch_to_input(pull=digitalio.Pull.DOWN)
last_position = -1
color = 0 # start at red
while True:
position = encoder.position
if last_position is None or position != last_position:
print(position)
if not switch.value:
# change the color
if position > last_position: # increase
color += 1
else:
color -= 1
color = (color + 256) % 256 # wrap around to 0-256
pixel.fill(colorwheel(color))
else:
# change the brightness
if position > last_position: # increase
import board
import digitalio
import os
import subprocess
import time
button = digitalio.DigitalInOut(board.D4)
button.direction = digitalio.Direction.INPUT
prev_value = True
print("inital button value:", button.value)
while 1:
button = digitalio.DigitalInOut(board.D4)
button.direction = digitalio.Direction.INPUT
x = button.value
if x and prev_value != x:
#subprocess.Popen("sudo python3 /home/tobiasravn/Desktop/code_pc/main.py 1", shell=True)
#subprocess.call(['xterm', '-e', 'python bb.py'], cwd='/home/tobiasravn/Desktop/code/', shell =True)
subprocess.call([
"gnome-terminal", "-e",
"sudo python3 /home/tobiasravn/Desktop/code_pc/main.py"
])
while button.value:
pass
print("Whaiting to clean up the program...")
time.sleep(3)
prev_value = x
"""Simple example to print acceleration data to console"""
import time
import digitalio
import board
import busio
import adafruit_lis3dh
# Set up accelerometer on I2C bus, 4G range:
i2c = busio.I2C(board.SCL, board.SDA)
int1 = digitalio.DigitalInOut(board.D5)
accel = adafruit_lis3dh.LIS3DH_I2C(i2c, int1=int1)
accel.range = adafruit_lis3dh.RANGE_4_G
accel.set_tap(1, 100)
while True:
x, y, z = accel.acceleration
print(x, y, z)
time.sleep(0.1)
if accel.tapped:
print("Tapped!")
