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
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 main():
print("Press the button")
Led().light_on()
ZumoButton().wait_for_press()
Led().light_off()
print("Button pressed")
# Sensors
camera_sensor = Camera(img_width=200, img_height=25)
reflectance_sensor = ReflectanceSensors()
ultrasonic_sensor = Ultrasonic()
# Other
led = Led()
led.light_off()
# Sensobs
camera_sensob = CameraSensob(camera_sensor)
reflectance_sensob = ReflectanceSensob(reflectance_sensor)
ultrasonic_sensob = Sensob(ultrasonic_sensor)
# Motobs
motob = Motob()
# Controller
bbcon = Bbcon()
# Behaviors
moveForward_behavior = MoveForward(None, 1, bbcon)
avoidCollision_behavior = AvoidCollision(ultrasonic_sensob, 4, bbcon)
followColor_behavior = FollowColor(camera_sensob, 6, bbcon)
pauseAtLines_behavior = PauseAtLines(reflectance_sensob, 8, bbcon)
stopCloseColor_behavior = StopCloseColor(camera_sensob, 10, bbcon)
# Add all sensobs to controller
bbcon.add_sensob(camera_sensob)
bbcon.add_sensob(reflectance_sensob)
bbcon.add_sensob(ultrasonic_sensob)
# Add all Behaviors to controller
bbcon.add_behavior(avoidCollision_behavior)
bbcon.add_behavior(moveForward_behavior)
bbcon.add_behavior(followColor_behavior)
bbcon.add_behavior(pauseAtLines_behavior)
bbcon.add_behavior(stopCloseColor_behavior)
bbcon.activate_all_behaviors()
# Add all motobs to controller
bbcon.add_motob(motob)
print("starting")
try:
while bbcon.active:
bbcon.run_one_timestep()
except:
print("Failed")
motob.stop()
print(sys.exc_info()[0])
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.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)
class SnipsController(MqttController):
def __init__(self, config, home_assistant):
MqttController.__init__(self, config)
self.led = Led()
self.home_assistant = home_assistant
def push_tts(self, topic, payload):
print('[Forwarding {}]: {}'.format(topic, payload))
self.client.publish(topic=topic, payload=payload, qos=1)
def on_connect(self, client, userdata, flags, rc):
print("Connected to snips")
for topic in [
'hermes/asr/toggleOn', 'hermes/hotword/toggleOn',
'hermes/nlu/intentParsed'
]:
self.client.subscribe(topic)
def on_message(self, client, userdata, msg):
if msg.topic == 'hermes/asr/toggleOn':
self.led.switch_on()
print('Switch on led')
elif msg.topic == 'hermes/hotword/toggleOn':
self.led.switch_off()
print('Switch off led')
elif msg.topic == 'hermes/nlu/intentParsed':
self.home_assistant.push_intent(msg)
def clock():
if request.method == 'POST':
data = request.get_json()
Led.clock = data
Led.main_update()
with open('../clock.json', 'w') as f:
json.dump(data, f)
return 'OK', 200
def _init_parts(self):
self.r_led = Led(self.red_led_pin)
self.g_led = Led(self.green_led_pin)
self.lock = Lock(self.relay_pin)
self.black_btn = PushButton(self.black_btn_pin) # add button
self.red_btn = PushButton(self.red_btn_pin) # delete button
self.r_led.off()
self.g_led.off()
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, 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 _join():
global lopy_connected
if not lora.has_joined():
Log.i("Connecting Lora...")
lopy_connected = False
Led.blink_yellow()
lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)
while not lora.has_joined():
time.sleep(2.5)
lopy_connected = True
Led.blink_green()
Log.i("Connected")
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 = 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)
def send(message):
sendToMonitors(message, "sent")
Log.i("Sending : " + message)
global messageReceived
Led.blink_purple()
_join()
messageReceived = False
attemptCounter = 0
while (not messageReceived and attemptCounter < 3):
socketLora.send(message.encode())
time.sleep(20)
attemptCounter = attemptCounter + 1
Led.blink_green()
Log.i("Message sent")
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, 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()
def _lora_callback(trigger):
Log.i("_lora_callback")
global messageReceived
events = lora.events()
if (events & LoRa.RX_PACKET_EVENT):
messageReceived = True
socketLora.setblocking(True)
Log.i("LoRa.RX_PACKET_EVENT")
Led.blink_blue()
data = socketLora.recv(256)
socketLora.setblocking(True)
_callback(data)
# if(events & LoRa.TX_PACKET_EVENT):
# Log.i("LoRa.TX_PACKET_EVENT")
if (events & LoRa.TX_FAILED_EVENT):
Log.i("LoRa.TX_FAILED_EVENT")
_join()
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, 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 __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 __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
class Hardware(object):
__metaclass__ = ABCMeta
def __init__(self):
self._init_pins()
self._init_parts()
@abstractmethod
def _init_pins(self):
raise NotImplementedError()
def _init_parts(self):
self.r_led = Led(self.red_led_pin)
self.g_led = Led(self.green_led_pin)
self.lock = Lock(self.relay_pin)
self.black_btn = PushButton(self.black_btn_pin) # add button
self.red_btn = PushButton(self.red_btn_pin) # delete button
self.r_led.off()
self.g_led.off()
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,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):
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()
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 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):
# 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))
# save_directory = "/mnt/nfsserver/videos"
# mv_directory = "/mnt/nfsserver/videos" # should be the same as save directory for pi_master
# #the following mount only applies if pi_master is set false (if this is slavepi)
# directory_to_mount = "192.168.0.3:/mnt/nfsserver"
# mount_location = "/mnt/nfs"
# if not pi_master:
# nfs_mount(directory_to_mount, mount_location)
# save_directory = "/home/nick/videos"
# mv_directory = "/mnt/nfs/videos"
#####################################################################################
if __name__ == "__main__":
camera = picamera.PiCamera()
trigger = Trigger()
green_led = Led(green_led_pin)
red_led = Led(red_led_pin)
file_name = save_name.File_namer(mv_directory,save_directory, device)
running = True
while running:
try:
red_led.led_off()
green_led.led_on()
trigger.read_state()
if trigger.input_state == False:
print "recording..." + file_name.get_name()
green_led.led_off()
red_led.led_on()
camera.start_recording(file_name.get_name())
sleep(1)
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()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pingo
from led import Led
import time
board = pingo.detect.get_board()
red_led_pin = board.pins[12] # GPIO18
r_led = Led(red_led_pin)
r_led.blink(times=10, on_delay=0.1, off_delay=None)
print(r_led.blinkThread.isAlive())
while(r_led.blinkThread.active):
# if(r_led.blinkThread.isAlive()):
print(r_led.blinkThread.active)
time.sleep(0.5)
print(r_led.blinkThread.isAlive())
def setup(self):
try:
btResult=subprocess.call(["sudo","service","bluetooth","start"])
if btResult < 0:
print >>sys.stderr, "Child terminated by signal", -btResult
else:
print >>sys.stderr, "Child returned", btResult
piscan=subprocess.call(["sudo","hciconfig","hci0","piscan"])
if piscan < 0:
print >>sys.stderr, "Child terminated by signal", -piscan
else:
print >>sys.stderr, "Child returned", piscan
except OSError as e:
print >>sys.stderr, "Execution failed", e
self.server_sock=BluetoothSocket(RFCOMM)
self.server_sock.bind(("",PORT_ANY))
self.server_sock.listen(1)
self.port=self.server_sock.getsockname()[1]
self.uuid="00001101-0000-1000-8000-00805f9b34fb"
advertise_service(self.server_sock,"decorations",service_id=self.uuid,service_classes=[self.uuid,SERIAL_PORT_CLASS],profiles=[SERIAL_PORT_PROFILE])
led=Led(0,"leds",0)
server=ServerConnection(self.server_sock)
led.start()
time.sleep(8)
if server.accept() == True:
led.stop()
for i in range(5):
led.connect()
led.starFade()
state=1
while True:
for case in switch(state):
if case(0):
if server.accept()==True:
state=1
break
else:
state=0
break
if case(1):
if server.hasConnection()==False:
state=0
break
else:
data=server.listen()
led.stop()
led=Led(0,"leds",1,data)
led.start()
state=2
break
if case(2):
if server.hasConnection()==False:
state=0
break
else:
state=1
break
from time import sleep
# Database
host = 'localhost'
# Power
ON = True
OFF = False
# Entry
ADDRESS = 0
USERNAME = 1
if __name__ == '__main__':
# Components
ld = Led(red_pin=4, green_pin=17)
ld.setup()
motor = Motor(step_pin=23, dir_pin=24, power_pin=25)
motor.setup()
encoder = Encoder(clk_pin=22, dir_pin=27)
encoder.setup()
db = Database(host, "philosoraptor", "explosion", "doorman")
db.setup()
rfid = Rfid()
rfid.setup()
# Main Loop
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))
# Next two lines only required if using OpenELEC
import sys
sys.path.append('/storage/.kodi/addons/python.RPi.GPIO/lib/')
import time
import RPi.GPIO as GPIO
from led import Led
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
redled = Led(18, "RED", 5)
yellowled = Led(8, "YELLOW", 2)
greenled = Led(20, "GREEN", 0)
whiteled = Led(17, "WHITE", 3)
flashled = Led(27, "FLASH", 0)
redled.on()
redled.off()
greenled.on()
whiteled.on()
whiteled.off()
flashled.flash()
greenled.off()
yellowled.on()
yellowled.off()
flashled.off()
redled.on()
