def run(self):
if self.delay != 0:
sleep(self.delay)
if self.on == 0:
Led(self.led_id).off()
elif self.on == 100:
Led(self.led_id).on()
else:
Led(self.led_id).blink(self.on, self.freq)
def __init__(self, ds, sett):
print("[LIGC] Initialized")
self.ds = ds
self.sett = sett
self.led1 = Led(2)
self.led2 = Led(3)
self.isNight = False
self.startTime = time.time()
self.lastValue = None
self.override = False
rpwm.rpwm_init()
def __init__(self, master):
# create GUI
self.master = master
self.master.title('JoyStick Test')
label = tk.Label(root, text='Joystick')
label.pack()
self.gui = GuiJs(master=root)
self.gui.createCordinateLabelJs1()
self.gui.createCordinateLabelJs2()
self.gui.createCircleJs1(200, 200, 220, 220, 'red')
self.gui.createButton(btn_name='Finish', callback=self.cleanup)
self.gui.createCircleJs2(200, 200, 220, 220, 'blue')
#JoyStick instanse
self.js1 = JoyStick(0, 3, 27)
self.val_vert1 = 0
self.val_horz1 = 0
self.move_vert1 = 0
self.move_horz1 = 0
self.js2 = JoyStick(7, 4, 22)
self.val_vert2 = 0
self.val_horz2 = 0
self.move_vert2 = 0
self.move_horz2 = 0
#ServMotor
#self.servo= ServMotor(18,180,0)
#self.servo = I2cServo()
# Led instance
self.Led = Led(17)
def __init__(self, red_led_pin, green_led_pin, left_servo_pin,
right_servo_pin, left_motor_forward, left_motor_backward,
right_motor_forward, right_motor_backward):
# Input
self.imu = Imu()
self.camera = Camera()
# Output
self.red_led = Led(red_led_pin)
self.green_led = Led(green_led_pin)
self.left_servo = Servo(left_servo_pin, min_angle=-90, max_angle=90)
self.right_servo = Servo(right_servo_pin, min_angle=-90, max_angle=90)
self.left_motor = Motor(forward=left_motor_forward,
backward=left_motor_backward)
self.right_servo = Motor(forward=right_motor_forward,
backward=right_motor_backward)
def __init__(self):
#Pin Num assain -> Connect assain
GPIO.setmode(GPIO.BOARD)
#create GUI
root = tk.Tk()
root.title('LED & Switch')
label = tk.Label(root, text='Led Test')
label.pack()
self.gui = GUILed(master=root)
self.gui.createCircle(50, 50, 150, 150, 'black')
self.gui.createSlidebar(callback=self.callback_changeDuty,
fromval=0,
toval=100)
#create instances
self.gui.createButton(btn_name='Led', callback=self.callback_BtnLed)
self.gui.createButton(btn_name='Finish', callback=self.cleanup)
self.Sw = Sw(pin_no=7)
#self.LedPwm = LedPwm(pin_no=11)
self.Led = Led(11)
GPIO.add_event_detect(self.Sw.getPinNo(),
GPIO.BOTH,
callback=self.callback_detectSwLed)
# display GUI
root.mainloop()
self.cleanup()
def __init__(self, master):
# create GUI
self.gpio = pigpio.pi()
self.master = master
self.master.title('JoyStick Test')
label = tk.Label(root, text='Joystick')
label.pack()
self.gui = GuiRarm(master=root)
self.gui.createCordinateLabelServo()
self.gui.createButton(btn_name='Finish', callback=self.cleanup)
#self.gui.createCircleJs2(200,200,220,220,'blue')
#JoyStick instanse
self.jsR = JoyStick(-1, 4, 27)
self.val_horz = 0
#self.jsL = JoyStick(7,4,22)
self.jsL = JoyStick(2, -1, 22)
self.val_vert = 0
#Volume instance
self.vol = Volume(6)
self.val_vol = 0
self.vol_sum = 0
self.sampleCount = 0
#ServMotor
#self.servo= ServMotor(18,180,0)
self.servo = I2cServo()
#PWM Freq: 60Hz
self.servo.setPWMFreq(60)
# Led instance
self.Led = Led(4)
self.Led.setLedOn()
# PowrSw
self.PowSw = Sw(17, pud='pudup')
self.PowSwCont = 0
def __init__(self, registerfile, shiftregister, reset=0, load_file=None):
self.registerfile = registerfile
self.shiftregister = shiftregister
# add control units
self._units = {}
self.led = Led(self.registerfile)
self._units['LEDs'] = self.led
self.hitlogic = HitLogic(self.registerfile)
self._units['Hit logic'] = self.hitlogic
self.filter = Filter(self.registerfile)
self._units['Filter'] = self.filter
self.monitor = Monitor(self.shiftregister)
self._units['Monitor'] = self.monitor
self.frontend = Frontend(self.shiftregister)
self._units['Frontend'] = self.frontend
self.adcbias = AdcBias(self.shiftregister)
self._units['ADC bias'] = self.adcbias
self.digital = Digital(self.registerfile)
self._units['Digital'] = self.digital
if reset:
self.reset()
self.apply()
if load_file:
self.load(load_file)
self.update()
async def main() -> None:
async with grpc.aio.insecure_channel(target='localhost:50051') as channel:
stub = wedge_pb2_grpc.WedgeStub(channel)
uplink = Uplink(stub, node_id)
button = Button(uplink)
led = Led(uplink)
# Example of Model, which identical to Seluxit data Model.
model = wedge_pb2.Model(
node=node_id,
device=[wedge_pb2.Device(
id=1,
name="LED_Button2",
version="0.1.2",
value=[
button.value,
led.value
]
)]
)
resp = await uplink.SetModel(model)
logging.info("Response: {}".format(resp))
# data = button.pin.read()
# logging.info("Current button status: {}".format(data))
# button.update(data)
await asyncio.gather(led.listen(node_id))
def __init__(self, strip_number:int, led_number:int):
self.strip_number = strip_number
self.led_nuber = led_number
self.led = Led(led_number=led_number, strip_number=strip_number)
self.notes = Notes()
self.has_been_assigned = False
def main():
leds = list()
a_led_effects = LedEffects(leds)
try:
led_11 = Led(16)
leds.append(led_11)
led_12 = Led(18)
leds.append(led_12)
led_15 = Led(22)
leds.append(led_15)
start(a_led_effects)
except SystemExit:
print('Quiting program')
finally:
for led in leds:
led.clean_up()
def __init__(self,
red: float,
green: float,
blue: float,
rate: float = 0.02) -> None:
super().__init__()
self.target = Led(red, green, blue)
self.rate = rate
def main():
logging.info("rpi dashcam ready to record!")
button_pin = 8
led_pin = 10
button = Button(button_pin)
led = Led(led_pin)
recording_folder = "/mnt/hdd"
with picamera.PiCamera(resolution="1280x960", framerate=24) as camera:
recorder = CameraRecorder(camera, button, led, recording_folder)
recorder.run()
def __init__(self, config, verbose=0):
self.verbose = verbose
# ------------------------------------------------------------------------------------------------------------ #
self.exit = False
self.config = config
# ------------------------------------------------------------------------------------------------------------ #
self.sleep_ms = self.SLEEP_MS_DEFAULT
# ------------------------------------------------------------------------------------------------------------ #
# Initialise required services
# ------------------------------------------------------------------------------------------------------------ #
if self.config['pinout']['led'] is None:
from led import MockLed
self.led = MockLed()
else:
from led import Led
self.led = Led(self.config['pinout']['led']['pin'],
self.config['pinout']['led']['on_level'])
# ------------------------------------------------------------------------------------------------------------ #
if self.config['pinout']['button'] is None:
from button import MockButton
self.button = MockButton()
else:
from button import Button
self.button = Button(self.config['pinout']['button']['pin'],
self.config['pinout']['button']['on_level'])
# ------------------------------------------------------------------------------------------------------------ #
if self.config['pinout']['relay'] is None:
from relay import MockRelay
self.relay = MockRelay()
else:
from relay import Relay
self.relay = Relay(self.config['pinout']['relay']['pin'],
self.config['pinout']['relay']['on_level'])
# ------------------------------------------------------------------------------------------------------------ #
self.wifi = WiFi(self.config) # , verbose=self.verbose)
self.device_id = self.wifi.device_id()
self.messaging = Messaging(self.config, self.device_id)
# ------------------------------------------------------------------------------------------------------------ #
# Application ready feedback --------------------------------------------------------------------------------- #
self.led.on(poll=True)
sleep(2)
self.led.off(poll=True)
# ------------------------------------------------------------------------------------------------------------ #
if self.wifi.connected():
self.on_wifi_connected(be_verbose=False)
# ------------------------------------------------------------------------------------------------------------ #
if self.verbose:
print('<{} with id {}>'.format(self.config['device']['type'],
self.device_id))
print(self.led)
print(self.button)
print(self.relay)
print(self.wifi)
print(self.messaging)
def __init__(self,master = 0):
#create GUI
self.master = master
root.title('LED & Switch')
label = tk.Label(root,text='Led Test')
label.pack()
self.gui = GUILed(master=root)
self.gui.createCircle(50,50,150,150,'black')
#create instances
self.gui.createButton(btn_name='Led',callback = self.callback_BtnLed)
self.gui.createButton(btn_name='Finish',callback = self.cleanup)
self.Sw = Sw(4,'either',self.callback_Sw)
self.Led = Led(17)
async def main():
parser = argparse.ArgumentParser(
description=
"Data collector which sends sensor measurements to Azure IoT HUB")
parser.add_argument("--nolcd",
action='store_true',
help="Skip LCD printout")
args = parser.parse_args()
if args.nolcd:
print("No LCD")
try:
bme280 = BME280()
led = Led()
lcd = None
if not args.nolcd:
lcd = LCD()
(chip_id, chip_version) = bme280.readID()
print(f"Started, chip_id={chip_id}, chip_version={chip_version}")
conn_str = os.getenv("DEV_BME_CONN_STR")
device_client = IoTHubDeviceClient.create_from_connection_string(
conn_str)
await device_client.connect()
while True:
temperature, pressure, humidity = bme280.readAll()
measTime = datetime.now().isoformat()
measRow = f'{{"Temperature":{temperature:0.2f},"Pressure":{pressure:0.2f},"Humidity":{humidity:0.2f}}}'
print(f"Sending message: {measRow}")
await device_client.send_message(measRow)
if not args.nolcd:
lcdOut = f"T:{temperature:0.1f}C {pressure:0.1f}hPa\nH:{humidity:0.1f}%"
lcd.clear()
lcd.setCursor(0, 0)
lcd.message(lcdOut)
led.blinkLed()
sleep(2 * 60)
except KeyboardInterrupt:
print("exiting...")
await device_client.disconnect()
led.close()
if not args.nolcd:
lcd.clear()
lcd.setCursor(0, 0)
lcd.destroy()
def __init__(self):
super(Car, self).__init__()
# 使用前先清理一遍GPIO
GPIO.cleanup()
# 设置gpio口的模式
GPIO.setmode(GPIO.BOARD)
# 设置gpio口为输出
GPIO.setup(INT1, GPIO.OUT)
GPIO.setup(INT2, GPIO.OUT)
GPIO.setup(INT3, GPIO.OUT)
GPIO.setup(INT4, GPIO.OUT)
# 当前运行状态 -1 后退 0 静止 1 前进 2 原地转圈
self.status = 0
# 构造距离感应器实例和警报灯实例
self.frontDetector = DistanceDetector(FTRIG, FECHO, u"Front")
self.frontLed = Led(FLED)
self.backDetector = DistanceDetector(BTRIG, BECHO, u"Back")
self.backLed = Led(BLED)
# 开启距离检测和警报灯
self.frontDetector.start()
self.frontLed.light()
self.backDetector.start()
self.backLed.light()
while True:
# 每隔 0.1s 检测前后距离
time.sleep(0.1)
if self.frontDetector.tooclose and self.backDetector.tooclose:
self.stop()
self.frontLed.flashing()
self.backLed.flashing()
elif self.frontDetector.tooclose:
self.stop()
self.frontLed.flashing()
self.backLed.light()
elif self.backDetector.tooclose:
self.stop()
self.frontLed.light()
self.backLed.flashing()
def __init__(self, config_path):
self.logger = logging.getLogger(__name__)
with open(config_path, "r") as f:
config = json.load(f)
f.close()
self.leds = dict()
pizw = pigpio.pi()
for led_group in config.get("leds"):
self.leds[led_group.get("name")] = Led(led_group.get("name"), pizw,
led_group.get("pins"))
self.web_config = dict()
self.web_config["leds"] = list(self.leds.keys())
self.logger.info("Configuration from {} loaded with {} LED(s)".format(
config_path, len(self.leds)))
def setup(self):
import WhereforeGUI
self.ui = WhereforeGUI.Ui_MainWindow()
self.ui.setupUi(self)
self.ui.startAtSelector.addItems(
["beginning", "end", "offset", "timestamp"])
self.ui.startAtSelector.setCurrentIndex(1)
self.ui.endAtSelector.addItems(["never", "end", "offset", "timestamp"])
self.ui.enableDefaultComboBox.addItems(["Enable new", "Disable new"])
self.ui.startTimeEdit.hide()
self.ui.startOffsetEdit.hide()
self.ui.endOffsetEdit.hide()
self.ui.endTimeEdit.hide()
self.ui.startAtSelector.currentIndexChanged.connect(
self.on_change_start_at)
self.ui.endAtSelector.currentIndexChanged.connect(
self.on_change_end_at)
self.ui.brokerLed = Led(self)
self.ui.consumerBarLayout.insertWidget(1, self.ui.brokerLed)
self.ui.brokerAddressEdit.textEdited.connect(self.startTextEditedTimer)
self.ui.enableAllButton.clicked.connect(self.onEnableAllPartitions)
self.ui.disableAllButton.clicked.connect(self.onDisableAllPartitions)
self.ui.topicPartitionSourceTree.setModel(self.topicPartitionModel)
self.ui.startOffsetEdit.textEdited.connect(
self.onRestartStartStopTimer)
self.ui.endOffsetEdit.textEdited.connect(self.onRestartStartStopTimer)
self.ui.startTimeEdit.editingFinished.connect(
self.onRestartStartStopTimer)
self.ui.endTimeEdit.editingFinished.connect(
self.onRestartStartStopTimer)
header_view = self.ui.topicPartitionSourceTree.header()
header_view.setSectionResizeMode(0, QtWidgets.QHeaderView.Stretch)
header_view.setStretchLastSection(False)
header_view.resizeSection(1, 50)
self.ui.topicPartitionSourceTree.setHeader(header_view)
self.ui.topicPartitionSourceTree.selectionModel(
).selectionChanged.connect(self.on_tree_node_selection)
self.ui.brokerAddressEdit.setText(
self.config.value("kafka_address", type=str))
if len(self.ui.brokerAddressEdit.text()) > 0:
self.onBrokerEditTimer()
self.ui.enableDefaultComboBox.setCurrentIndex(
self.config.value("enable_default", type=int, defaultValue=0))
self.show()
def __init__(self):
self.iot = Startiot()
self.iot.connect(False)
self.py = Pysense()
"""
self.gps = L76GNSS(py, timeout = 30)
(self.lat, self.lng) = self.gps.coordinates()
self.counter = 0
"""
self.state = STATE_IDLE
self.rightpir = Pir("P11")
self.centerpir = Pir("P2")
self.leftpir = Pir("P9")
self.led = Led("P10")
self.i2c = I2C(1, I2C.MASTER, baudrate=100000, pins=("P4", "P8"))
self.uv_sensor = VEML6070.VEML6070_UV(self.i2c)
self.baseline = []
pycom.heartbeat(False) # disable the blue blinking
def main():
# Ginger robot pin out
# servo_direction = machine.PWM(machine.Pin(12), freq=50)
# servo_head_x = machine.PWM(machine.Pin(14), freq=50)
# servo_hand_y = machine.PWM(machine.Pin(13), freq=50)
# servo_catch = machine.PWM(machine.Pin(15), freq=50)
ginger = Ginger(motor=DCDrive(name='motor', letter='A'),
servo_direction=Servo(name='servo_dir', pin=12),
servo_head_x=Servo(name='servo_head_x', pin=14),
servo_hand_y=Servo(name='servo_hand_y', pin=13),
servo_catch=Servo(name='servo_catch', pin=15),
sensor_hall=Hall(pin=4),
led=Led(
name='led',
pin=2,
))
# print(ginger)
# print(dir(ginger.motor))
# print(ginger.motor.echo())
# print(ginger.motor.echo(71))
# print(ginger.motor.duty(71))
# print(ginger.motor.echo('string71'))
#
# print(ginger.servo_catch.echo())
# print(ginger.servo_catch.echo(72))
# print(ginger.servo_catch.duty(72))
# print(ginger.servo_catch.echo('string 72'))
# print(ginger.servo_catch.duty('string 72')) # duty should be int or float
# print(ginger.sensor_hall.sensor)
# print(ginger.led.light)
print('--test--')
# for i in range(50):
while True:
if ginger.sensor_hall.hall() == 0:
ginger.led.light = 0
else:
ginger.led.light = 1
print('sensor:{}, light:{}'.format(ginger.sensor_hall.sensor,
ginger.led.light))
def build_page(layout, page):
layout.clear_widgets()
links.clear() # TODO: will prevent iframe functionality to work
for id, item in page.iteritems():
if item['type'] == 'button':
wgt = Button()
elif item['type'] == 'label':
wgt = Label()
elif item['type'] == 'var-label':
wgt = VariableLabel()
wgt.set_var(item['variable'])
elif item['type'] == 'led':
wgt = Led()
wgt.set_var(item['variable'])
elif item['type'] == 'thermometer':
wgt = Thermometer()
wgt.set_var(item['variable'])
elif item['type'] == 'manometer':
wgt = Manometer()
wgt.set_var(item['variable'])
elif item['type'] == 'edit-grid':
wgt = EditGrid()
wgt.set_dimenstion(item['rows'], item['cols'])
wgt.id = id
if 'text' in item:
wgt.text = item['text']
if 'font-size' in item:
wgt.font_size = item['font-size']
if 'pos' in item:
wgt.pos = eval(item['pos'])
if 'size' in item:
wgt.size = eval(item['size'])
if 'pos_hint' in item:
wgt.pos_hint = item['pos_hint']
if 'size_hint' in item:
wgt.size_hint = eval(item['size_hint'])
if 'link' in item:
links[wgt.id] = item['link']
wgt.bind(on_press=navigate)
if 'click' in item:
wgt.bind(on_press=eval(item['click']))
layout.add_widget(wgt)
def __init__(self,master):
# create GUI
self.master = master
self.master.title('JoyStick Test')
label = tk.Label(root,text='Joystick')
label.pack()
self.gui = GuiJs(master=root)
self.gui.createCordinateLabel()
self.gui.createCircle(200,200,220,220,'red')
self.gui.createButton(btn_name='Finish',callback=self.cleanup)
#JoyStick instanse
self.js = JoyStick()
self.val_vert = 0
self.val_horz = 0
self.move_vert = 0
self.move_horz = 0
#ServMotor
self.sm= ServMotor(18,180,0)
# Led instance
self.Led = Led(17)
self.Sw = Sw(4,'either',self.callback_Sw)
def __init__(self):
# Create the strip
self.strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ,
LED_DMA, LED_INVERT, LED_BRIGHTNESS,
LED_CHANNEL)
# Attach LEDs to the strip
self.my_leds = list()
for a_led in range(0, LED_COUNT):
self.my_leds.append(Led(self.strip, a_led))
self.strip.begin()
# Turn off the strip
for a_led in self.my_leds:
a_led.update()
self.strip.show()
self.my_keys = list()
# Create keys
for a_key in globales.keys:
self.my_keys.append(Key(a_key, self))
class StreamingServer(socketserver.ThreadingMixIn, server.HTTPServer):
allow_reuse_address = True
daemon_threads = True
def switch_to_record_mode_on_reboot(channel):
bashCommand = "sudo cp rpicam-record-proccess.conf /etc/supervisor/conf.d/rpicam-record-proccess.conf"
process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE)
output, error = process.communicate()
bashCommand = "sudo reboot"
process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE)
output, error = process.communicate()
with picamera.PiCamera(resolution="1280x960", framerate=24) as camera:
button_pin = 8
led_pin = 10
button = Button(button_pin)
led = Led(led_pin)
button.add_pressed_cb(switch_to_record_mode_on_reboot)
output = StreamingOutput()
camera.start_recording(output, format="mjpeg")
try:
address = ("", 8000)
server = StreamingServer(address, StreamingHandler)
server.serve_forever()
finally:
camera.stop_recording()
print('Init Electrical Lock with ESP32/ESP8622...')
# init rtc
rtc = machine.RTC()
# init mfrc reader
if uname()[0] == 'esp8266':
rdr = mfrc522.MFRC522(0, 2, 4, 5, 14)
elif uname()[0] == 'esp32':
rdr = mfrc522.MFRC522(18, 23, 19, 4, 2)
else:
raise RuntimeError("Unsupported platform")
# init led, button etc
led = Led(LED_PIN, debug=IS_DEBUG)
btn = BtnSwitch(BTN_PIN, debug=IS_DEBUG)
delay = Led(DELAY_PIN, name='DELAY', debug=IS_DEBUG)
beeper = Led(BEEPER, name='BEEPER', debug=IS_DEBUG)
# init Key DB
key_db = KeyDB()
# init wlan
init_wlan()
lock = _thread.allocate_lock()
# create udp server thread
_thread.start_new_thread(udp_ser, (ip, port))
import sys
sys.path.append('../src')
from led import Led
import json
import time
myled = Led(21)
fname = './web/led.json'
try:
while True:
try:
f = open(fname, 'r')
json_dict = json.load(f)
if json_dict['status'] == 'on':
myled.on()
else:
myled.off()
except ValueError:
print('ValueError')
time.sleep(0.2)
except KeyboardInterrupt:
pass
def __init__(self, red: float, green: float, blue: float) -> None:
super().__init__()
self.target = Led(red, green, blue)
from led import Led
from t9_keypad import Keypad
from keyboard import Keyboard
from keyboard import Keycode
from t9_display import Display
NO_WORD = 0
PARTIAL_WORD = 1
WORD = 2
CACHE_SIZE = 8000
# Used to store Trie node locations
file_cache = [-1 for i in range(CACHE_SIZE)]
# Lights used to display which mode the macropad is in
leds = Led()
## Global buffers
# Key presses to be process
key_queue = []
# Keys currently being pressed
held_keys = []
# Text to be written out by the virtual keyboard
current_word = ""
# Text that was last written out by virtual keyboard
written_word = ""
keys = (('1', '2', '3'),
('4', '5', '6'),
('7', '8', '9'),
('*', '0', '#'))
import sys
sys.path.append('../src')
from led import Led
from mcp3208 import Mcp3208
from time import sleep
myled = (Led(21), Led(20), Led(16))
mymcp = Mcp3208(11, 10, 9, 8)
for i in range(3):
myled[i].pwm_on(50)
try:
while True:
inputVal0 = mymcp.readadc(0)
#base_duty = (inputVal0 - 1000)/((3000 - 1000)/100)
base_duty = inputVal0 * 100 / 4095
duty = [0, 0, 0]
if base_duty > 0:
duty[1] = base_duty
duty[2] = 100 - base_duty
duty[0] = base_duty * 2 if base_duty < 50 else 100 - (
(base_duty - 50) * 2)
print "%i, %i" % (inputVal0, base_duty)
for i in range(3):
myled[i].pwm_change_duty(duty[i])
sleep(0.05)
except KeyboardInterrupt:
from typing import List
from random import randint
from led import Led
from transitions import FadeArray
CHRISTMAS_COLORS = [
Led(0.7019607843137254, 0, 0.047058823529411764),
Led(0, 0.7019607843137254, 0.17254901960784313),
Led(1.0, 0.8431372549019608, 0),
]
class Christmas(FadeArray):
def __init__(self, rate=0.05):
super().__init__(rate=rate)
def step(self, previous: List[Led]) -> List[Led]:
if self.targets is None:
self.targets = previous
if self.converged(previous):
self.targets = [CHRISTMAS_COLORS[randint(0, 2)] for _ in previous]
return super().step(previous)
def converged(self, previous) -> bool:
for target_led, previous_led in zip(self.targets, previous):
if not target_led.similar(previous_led, only_color=True):
return False
return True
