class Heartbeat:
"""Toggle an output pin in a repeating pattern."""
def __init__(self, pin_id, invert=False):
"""Initialize a new heartbeat.
Args:
pin_id (int): Which pin to toggle.
invert (bool): Whether the pin should be considered "active low".
See the ``invert`` parameter of MicroPython's ``Signal``.
"""
self._sig = Signal(pin_id, Pin.OUT, invert=invert)
self._sig.off()
async def beat(self, sch):
"""Perform the heartbeat.
Pass this function to ``create_task`` of Perthensis' ``Scheduler``.
Note that it will set the pin to "on" for 2 seconds before starting the
pattern. This is supposed to make board resets clearly visible.
"""
self._sig.on()
await sch.sleep(2)
while True:
for idx, delay in enumerate(PATTERN):
self._sig.on() if idx % 2 == 0 else self._sig.off()
await sch.sleep_ms(delay)
def main():
pin = Pin(('GPIO_1', 5), Pin.OUT)
led = Signal(pin, invert=True)
led.off()
led_status = 'OFF'
while True:
reported = {'state': {'reported': {}}}
reported['state']['reported']['led'] = led_status
degu.update_shadow(ujson.dumps(reported))
received = degu.get_shadow()
if received:
try:
desired = ujson.loads(received)
try:
led_status = desired['state']['desired']['led']
except:
pass
if led_status == 'ON':
led.on()
else:
led.off()
except:
pass
time.sleep(1)
def _wait_for_sta_connection(self, a_sta_name):
status_led = Signal(Pin(2, Pin.OUT), invert=True)
MAX_CONNECT_TIME_MS = 20000
start = time.ticks_ms()
deadline = start + MAX_CONNECT_TIME_MS
now = start
print("connecting to wifi '{}' ...".format(a_sta_name))
status = 0
while now < deadline:
new_status = self.sta_if.status()
if new_status != status:
status = new_status
print("status: {}".format(self._if_status_string(status)))
if self._connecting_finished(status):
break
time.sleep_ms(50)
now = time.ticks_ms()
status_led.value(not status_led.value())
if self.sta_if.isconnected():
print("DONE (finished in {} ms)".format(now-start))
print(self.sta_if.ifconfig())
status_led.on()
time.sleep_ms(500)
else:
print("FAILED (finished in {} ms)".format(now-start))
status_led.off()
def blink_user_led(interval, times: int = 1) -> None:
user_led = Signal(Pin(SERVICE_LED_PIN, Pin.OUT), invert=True)
for _ in range(times):
user_led.on()
time.sleep(interval)
user_led.off()
time.sleep(interval)
def main():
from machine import Signal, Pin, freq
import hwconfig
import time
import gc
btn_fetch = Signal(hwconfig.D6, Pin.IN, Pin.PULL_UP, invert=True)
btn_turbo = Signal(hwconfig.D5, Pin.IN, Pin.PULL_UP, invert=True)
blue_led = Signal(hwconfig.LED_BLUE, Pin.OUT, invert=True)
red_led = Signal(hwconfig.LED_RED, Pin.OUT, invert=True)
print("Connect D6 to GND to fetch data")
print("Keep D5 pressed to speed up clock")
while True:
if btn_fetch.value():
print("fetching")
params = {
"stopId": "Technik",
"optDir": -1,
"nRows": 4,
"showArrivals": "n",
"optTime": "now",
"allLines": "y"
}
red_led.on()
time_fetch = time.ticks_ms()
xml = get_ivb_xml(params)
time_fetch = time.ticks_diff(time.ticks_ms(), time_fetch)
red_led.off()
gc.collect()
blue_led.on()
speed_up = btn_turbo.value()
if speed_up:
freq(160000000)
print("speeding up")
time_parse = time.ticks_ms()
smart_info = extract_bus_plan(xml)
time_parse = time.ticks_diff(time.ticks_ms(), time_parse)
if speed_up:
freq(80000000)
blue_led.off()
gc.collect()
print(smart_info)
print("fetched in {} ms, parsed in {} ms".format(
time_fetch, time_parse))
gc.collect()
time.sleep_ms(100)
class Supply:
SUPPLY_STATE_DISABLED = const(0)
SUPPLY_STATE_ENABLED = const(1)
def __init__(self,
en_pin_nr,
voltage,
settle_time_ms,
inverse_pol=False,
default_state=SUPPLY_STATE_DISABLED):
self.EnPin = Signal(en_pin_nr, mode=Pin.OUT, invert=inverse_pol)
if default_state is self.SUPPLY_STATE_ENABLED:
self.Enable()
else:
self.EnCount = 0
self.EnPin.off()
self.Voltage = voltage
self.SettleTime = settle_time_ms
def Enable(self):
self.EnCount += 1
# print("[Supply] Enable count: {}".format(self.EnCount))
if self.EnCount is 1:
# print("[Supply] Enabling supply")
self.EnPin.on()
utime.sleep_ms(self.SettleTime)
return 0
def Disable(self):
if self.EnCount is 0:
# print("[Supply] Supply cannot be disabled")
return -1
self.EnCount -= 1
# print("[Supply] Enable count: {}".format(self.EnCount))
if self.EnCount is 0:
# print("[Supply] Disabling supply")
self.EnPin.off()
utime.sleep_ms(self.SettleTime)
return 0
def IsEnabled(self):
return self.EnCount > 0
def main():
gc.collect()
genWebObj = CGenWeb()
switchState = False
switchObj = Signal(Pin(0, Pin.OUT),
invert=True) # GPIO0; Relay: NO ( normally open )
switchObj.off()
# ledObj = Signal(Pin(2, Pin.OUT), invert=True) # GPIO2; ESP01S
# ledObj.off()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', 80))
s.listen(2)
while True:
try:
if gc.mem_free() < G_GC_THRESHOLD:
gc.collect()
conn, addr = s.accept()
conn.settimeout(3.0)
print('Received HTTP GET connection request from %s' % str(addr))
request = conn.recv(1024)
conn.settimeout(None)
request = str(request)
print('GET Rquest Content = %s' % request)
switch_on = request.find('/?switch_on')
switch_off = request.find('/?switch_off')
if switch_on == G_CMD_IDX:
print('Switch ON -> GPIO2')
switchState = True
switchObj.on()
# ledObj.on()
if switch_off == G_CMD_IDX:
print('Switch OFF -> GPIO2')
switchState = False
switchObj.off()
# ledObj.off()
resHtml = genWebObj.getWebPage(switchState)
conn.send('HTTP/1.1 200 OK\n')
conn.send('Content-Type: text/html\n')
conn.send('Connection: closed.\n\n')
conn.sendall(resHtml)
conn.close()
except OSError as e:
conn.close()
print('Connection closed. OSError =', e)
def main():
path = 'thing/' + zcoap.eui64()
reported = {'state': {'reported': {}}}
addr = zcoap.gw_addr()
port = 5683
cli = zcoap.client((addr, port))
pin = Pin(('GPIO_1', 5), Pin.OUT)
led = Signal(pin, invert=True)
led.off()
led_status = 'OFF'
while True:
reported['state']['reported']['led'] = led_status
cli.request_post(path, ujson.dumps(reported))
received = cli.request_get(path)
if received:
try:
desired = ujson.loads(received)
try:
led_status = desired['state']['desired']['led']
except:
pass
if led_status == 'ON':
led.on()
else:
led.off()
except:
pass
time.sleep(1)
cli.close()
class Heartbeat:
def __init__(self, scheduler, pin_id, invert=False):
self._sig = Signal(pin_id, Pin.OUT, invert=invert)
self._sig.off()
scheduler.create_task(self._cycle)
async def _cycle(self, sch):
self._sig.on()
await sch.sleep(2)
while True:
self._sig.on()
await sch.sleep_ms(50)
self._sig.off()
await sch.sleep_ms(100)
self._sig.on()
await sch.sleep_ms(100)
self._sig.off()
await sch.sleep_ms(750)
import time from machine import u2if, Pin, Signal # Initialize GPIO to output and set the value HIGH led = Pin(u2if.GP3, Pin.OUT, value=Pin.HIGH) time.sleep(1) # Switch off the led led.value(Pin.LOW) # Active-low RGB led led_r = Signal(Pin(u2if.GP6, Pin.OUT), invert=True) led_g = Signal(Pin(u2if.GP7, Pin.OUT), invert=True) led_b = Signal(Pin(u2if.GP8, Pin.OUT), invert=True) # Switch on the three colors led_r.value(Pin.HIGH) led_g.on() # == .value(Pin.HIGH) led_b.on() time.sleep(1) # Switch off the three colors led_r.off() led_g.value(Pin.LOW) # == .value(Pin.LOW) led_b.value(Pin.LOW)
p2 = Pin('P2', Pin.OUT_PP)
p3 = Pin('P3', Pin.OUT_PP)
top_led = Signal(p0, invert=False)
bot_led = Signal(p1, invert=False)
left_led = Signal(p2, invert=False)
right_led = Signal(p3, invert=False)
# Only blobs that with more pixels than "pixel_threshold" and more area than "area_threshold" are
# returned by "find_blobs" below. Change "pixels_threshold" and "area_threshold" if you change the
# camera resolution. "merge=True" must be set to merge overlapping color blobs for color codes.
while(True):
clock.tick()
img = sensor.snapshot()
for blob in img.find_blobs(thresholds, pixels_threshold=200, area_threshold=200, merge=True):
img.draw_rectangle(blob.rect())
img.draw_cross(blob.cx(), blob.cy())
img.draw_string(blob.x() + 1, blob.y() + 1, "Yellow Ball")
# Area = blob.area()
#print("Area of blob is:", Area)
print ("x=",blob.x(),"y=",blob.y())
if (blob.x())<=160: left_led.on()
elif (blob.x())>=160: left_led.off()
if (blob.y())<=120: top_led.on()
elif (blob.y())>=120: top_led.off()
if (blob.x())>=160: right_led.on()
elif (blob.x())<=160: right_led.off()
if (blob.y())>=120: bot_led.on()
elif (blob.y())<=120: bot_led.off()
class KtaneHardware(KtaneBase):
mode: int
def __init__(self, addr: int) -> None:
uart = UART(UART_NUM,
CONSTANTS.UART.BAUD_RATE,
tx=Pin(TX_PIN),
rx=Pin(RX_PIN))
tx_en = Pin(TX_EN_PIN, Pin.OUT)
KtaneBase.__init__(self, addr, uart, tx_en, LOG, idle, ticks_us)
self.status_red = Signal(Pin(STATUS_RED, Pin.OUT), invert=True)
self.status_green = Signal(Pin(STATUS_GREEN, Pin.OUT), invert=True)
self.set_mode(CONSTANTS.MODES.SLEEP)
def set_mode(self, mode: int) -> None:
self.mode = mode
if mode == CONSTANTS.MODES.SLEEP:
LOG.info("mode=sleep")
self.status_green.off()
self.status_red.off()
elif mode in [CONSTANTS.MODES.ARMED, CONSTANTS.MODES.READY]:
LOG.info("mode=armed or ready")
self.status_green.off()
self.status_red.on()
elif mode == CONSTANTS.MODES.DISARMED:
LOG.info("mode=disarmed")
self.status_green.on()
self.status_red.off()
def check_queued_tasks(self, was_idle):
if self.queued & CONSTANTS.QUEUED_TASKS.STRIKE:
was_idle = False
self.strike()
state = disable_irq()
self.queued &= ~CONSTANTS.QUEUED_TASKS.STRIKE
enable_irq(state)
if self.queued & CONSTANTS.QUEUED_TASKS.DISARMED:
was_idle = False
self.disarmed()
state = disable_irq()
self.queued &= ~CONSTANTS.QUEUED_TASKS.DISARMED
enable_irq(state)
if was_idle:
self.idle()
def unable_to_arm(self) -> None:
LOG.info("error")
self.queue_packet(
QueuedPacket(CONSTANTS.MODULES.MASTER_ADDR,
CONSTANTS.PROTOCOL.PACKET_TYPE.ERROR))
def disarmed(self):
LOG.info("disarmed")
self.queue_packet(
QueuedPacket(CONSTANTS.MODULES.MASTER_ADDR,
CONSTANTS.PROTOCOL.PACKET_TYPE.DISARMED))
self.set_mode(CONSTANTS.MODES.DISARMED)
def strike(self):
LOG.info("strike")
self.queue_packet(
QueuedPacket(CONSTANTS.MODULES.MASTER_ADDR,
CONSTANTS.PROTOCOL.PACKET_TYPE.STRIKE))
def stop(self, _source: int, _dest: int, _payload: bytes) -> bool:
LOG.info("stop")
self.set_mode(CONSTANTS.MODES.SLEEP)
return False
# -*- coding: utf-8 -*- """ 程式說明請參閱3-24頁 """ from machine import Pin, Signal ledPin = Pin(2, Pin.OUT, value=1) led = Signal(ledPin, invert=True) led.value(1) led.value(0) led.on() led.off()
from machine import Signal, Pin
from time import sleep
ledPin2 = machine.Pin(2, machine.Pin.OUT)
led2 = Signal(ledPin2, invert=True)
led2.off()
while True:
led2.on()
sleep(0.5)
led2.off()
sleep(0.25)
try:
import usocket as socket
except:
import socket
import gc
from dcmotor import DCMotor
from machine import Pin, Signal, PWM
gc.collect()
ledLight = Signal(Pin(2, Pin.OUT), invert=True) # GPIO2 ( D4 )
ledLight.on()
pwmFrequency = 500
enablePin = PWM(Pin(4), pwmFrequency) # GPIO4 ( D2 )
pin1 = Pin(5, Pin.OUT) # GPIO5 ( D1 )
pin2 = Pin(14, Pin.OUT) # GPIO14 ( D5 )
dcMotorA = DCMotor(pin1, pin2, enablePin)
pin3 = Pin(12, Pin.OUT) # GPIO12 ( D6 )
pin4 = Pin(13, Pin.OUT) # GPIO13 ( D7 )
dcMotorB = DCMotor(pin3, pin4, enablePin)
forwardSpeed = 100
backwardSpeed = 80
def web_page():
html = """
<html>
def main():
gc.collect()
genWebObj = CGenWeb()
ledLight = Signal(Pin(2, Pin.OUT), invert=False) # GPIO2 ( P2 )
sleep(0.1)
ledLight.on()
dcMotorLT = CDcMotor(15, 4) # GPIO15 ( P15 ), GPIO4 ( P4 )
sleep(0.1)
dcMotorLT.stop()
dcMotorLB = CDcMotor(16, 17) # GPIO16 ( P16 ), GPIO17 ( P17 )
sleep(0.1)
dcMotorLB.stop()
dcMotorRT = CDcMotor(5, 18) # GPIO5 ( P5 ), # GPIO18 ( P18 )
sleep(0.1)
dcMotorRT.stop()
dcMotorRB = CDcMotor(19, 23) # GPIO19 ( P19 ), GPIO23 ( P23 )
sleep(0.1)
dcMotorRB.stop()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('', 80))
sock.listen(2)
while True:
try:
if gc.mem_free() < G_GC_THRESHOLD:
gc.collect()
conn, addr = sock.accept()
conn.settimeout(3.0)
print('Received HTTP GET connection request from %s' % str(addr))
request = conn.recv(1024)
conn.settimeout(None)
request = str(request)
print('GET Rquest Content = %s' % request)
speed_up = request.find('/?speed_up')
slow_down = request.find('/?slow_down')
left_front = request.find('/?left_front')
car_forward = request.find('/?car_forward')
right_front = request.find('/?right_front')
car_left = request.find('/?car_left')
car_stop = request.find('/?car_stop')
car_right = request.find('/?car_right')
turn_left = request.find('/?turn_left')
car_backward = request.find('/?car_backward')
turn_right = request.find('/?turn_right')
if speed_up == G_CMD_IDX:
print('cmd: speed_up')
ledLight.on()
dcMotorLT.speedUp()
dcMotorLB.speedUp()
dcMotorRT.speedUp()
dcMotorRB.speedUp()
elif slow_down == G_CMD_IDX:
print('cmd: slow_down')
ledLight.on()
dcMotorLT.slowDown()
dcMotorLB.slowDown()
dcMotorRT.slowDown()
dcMotorRB.slowDown()
elif left_front == G_CMD_IDX:
print('cmd: left_front')
ledLight.on()
dcMotorLB.forward(G_TURN_SPEED)
dcMotorRT.forward(G_TURN_SPEED)
dcMotorLT.stop()
dcMotorRB.stop()
elif car_forward == G_CMD_IDX:
print('cmd: car_forward')
ledLight.on()
dcMotorLT.forward(G_FORWARD_SPEED)
dcMotorLB.forward(G_FORWARD_SPEED)
dcMotorRT.forward(G_FORWARD_SPEED)
dcMotorRB.forward(G_FORWARD_SPEED)
elif right_front == G_CMD_IDX:
print('cmd: right_front')
ledLight.on()
dcMotorLT.forward(G_TURN_SPEED)
dcMotorRB.forward(G_TURN_SPEED)
dcMotorLB.stop()
dcMotorRT.stop()
elif car_left == G_CMD_IDX:
print('cmd: car_left')
ledLight.on()
dcMotorLT.backward(G_TURN_SPEED)
dcMotorLB.forward(G_TURN_SPEED)
dcMotorRT.forward(G_TURN_SPEED)
dcMotorRB.backward(G_TURN_SPEED)
elif car_stop == G_CMD_IDX:
print('cmd: car_stop')
ledLight.off()
dcMotorLT.stop()
dcMotorLB.stop()
dcMotorRT.stop()
dcMotorRB.stop()
elif car_right == G_CMD_IDX:
print('cmd: car_right')
ledLight.on()
dcMotorLT.forward(G_TURN_SPEED)
dcMotorLB.backward(G_TURN_SPEED)
dcMotorRT.backward(G_TURN_SPEED)
dcMotorRB.forward(G_TURN_SPEED)
elif turn_left == G_CMD_IDX:
print('cmd: turn_left')
ledLight.on()
dcMotorLT.backward(G_TURN_SPEED)
dcMotorLB.backward(G_TURN_SPEED)
dcMotorRT.forward(G_TURN_SPEED)
dcMotorRB.forward(G_TURN_SPEED)
elif car_backward == G_CMD_IDX:
print('cmd: car_backward')
ledLight.on()
dcMotorLT.backward(G_BACKWARD_SPEED)
dcMotorLB.backward(G_BACKWARD_SPEED)
dcMotorRT.backward(G_BACKWARD_SPEED)
dcMotorRB.backward(G_BACKWARD_SPEED)
elif turn_right == G_CMD_IDX:
print('cmd: turn_right')
ledLight.on()
dcMotorLT.forward(G_TURN_SPEED)
dcMotorLB.forward(G_TURN_SPEED)
dcMotorRT.backward(G_TURN_SPEED)
dcMotorRB.backward(G_TURN_SPEED)
resHtml = genWebObj.getWebPage()
conn.send('HTTP/1.1 200 OK\n')
conn.send('Content-Type: text/html\n')
conn.send('Connection: closed.\n\n')
conn.sendall(resHtml)
conn.close()
except OSError as e:
conn.close()
print('Connection closed. OSError =', e)
from machine import Pin, Signal RED_RGB_PIN = 15 BLUE_PIN = 2 red_pin = Pin(RED_RGB_PIN, Pin.OUT) blue_pin = Pin(BLUE_PIN, Pin.OUT) red_pin.value(1) blue_pin.value(0) red = Signal(red_pin, invert=False) blue = Signal(blue_pin, invert=True) red.value(1) blue.value(1) red.on() blue.on()
import zcoap
import time
import ujson
if __name__ == '__main__':
path = 'thing/' + zcoap.eui64()
reported = {'state':{'reported':{}}}
pin = Pin(('GPIO_1', 7), Pin.OUT)
led1 = Signal(pin, invert=True)
led1.off()
while True:
addr = zcoap.gw_addr()
port = 5683
cli = zcoap.client((addr, port))
reported['state']['reported']['message'] = 'OK'
print(ujson.dumps(reported))
cli.request_post(path, ujson.dumps(reported))
received = cli.request_get(path)
if received:
led1.on()
time.sleep(5)
cli.close()
wifi = WLAN(STA_IF)
pot = ADC(0)
# Leds
led_0 = Signal(LED_0_PIN, Pin.OUT, invert=True)
led_2 = Signal(LED_2_PIN, Pin.OUT, invert=False)
led_1 = Signal(LED_1_PIN, Pin.OUT, invert=False)
# Insertion detection
insertion = Signal(INSERTION_PIN, Pin.IN)
# Read brightness from trim pot at A0 and set it
brightness = set_matrix_brightness(pot, display, 0)
# Draw WiFi symbol
led_0.on()
led_2.on()
symbols.draw(symbols.WIFI, matrix=display, display=1, clear=True)
sleep(0.5)
# Enable garbage collector
gc.enable()
# Connect to WiFi
if not wifi.isconnected():
print("Connecting to WiFI '" + secrets.WIFI_SSID + '"')
wifi.active(True)
wifi.connect(secrets.WIFI_SSID, secrets.WIFI_PASSWORD)
while not wifi.isconnected():
pass
data = self.i2c.readfrom_mem(self.addr, 0, 2)
return 0.01 * 2**(data[0] >> 4) * ((data[0] & 0x0f) << 8 | data[1])
from machine import Pin, Signal
import utime
import machine, SystemLink
i2c = machine.I2C('X')
hdc = HDC2080(i2c)
opt = OPT3001(i2c)
led_b = Signal('X4', Pin.OUT, value=0, invert=True)
fred2 = SystemLink.SystemLink('fred2', 'STRING')
fred2.connect()
while True:
hdc.measure()
opt.measure()
led_b.on()
while not hdc.is_ready():
machine.idle()
print(hdc.temperature(), hdc.humidity())
while not opt.is_ready():
machine.idle()
print(opt.lux())
if fred2.status():
fred2.put(str(hdc.temperature()))
led_b.off()
utime.sleep(1)
import machine, time
from machine import Pin, Signal
#blue led on pin 21
green = Signal(Pin(17, Pin.OUT))
red = Signal(Pin(5, Pin.OUT))
blue = Signal(Pin(2, Pin.OUT))
red.off()
blue.off()
green.off()
red.on()
blue.on()
green.on()
green
if not 'i2c' in dir():
i2c = machine.I2C(0, sda=21, scl=22)
#init only one time
if not 'tft' in dir():
tft = m5stack.Display()
import machine, time
if not 'i2c' in dir():
i2c = machine.I2C(0, sda=21, scl=22)
MOTION_ID = const(104)
if MOTION_ID in i2c.scan():
print('motion sensor detected on i2cbus')
# load motion sensor logic,
# two different devices share the same ID, try and retry
from machine import Signal, Pin, ADC
from time import sleep
ledPin2 = machine.Pin(2, machine.Pin.OUT)
Led2 = Signal(ledPin2, invert=True)
adc = ADC(0)
val = 0
while True:
val = adc.read()
print(val)
if val < 100:
Led2.on()
else:
Led2.off()
sleep(0.25)
def main():
gc.collect()
ledLight = Signal(Pin(2, Pin.OUT), invert=False) # GPIO2 ( D2 )
sleep(0.1)
ledLight.on()
dcMotorA = DCMotor(4, 5) # GPIO4 ( D4 ), GPIO5 ( D5 )
sleep(0.1)
dcMotorA.stop()
servoB = CServo(15) # GPIO15 ( D15 )
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('', 80))
sock.listen(5)
while True:
try:
if gc.mem_free() < G_GC_THRESHOLD:
gc.collect()
conn, addr = sock.accept()
conn.settimeout(3.0)
print('Received HTTP GET connection request from %s' % str(addr))
request = conn.recv(1024)
conn.settimeout(None)
request = str(request)
print('GET Rquest Content = %s' % request)
car_direction = request.find('/?car_direction')
turn_left = request.find('/?turn_left')
car_forward = request.find('/?car_forward')
turn_right = request.find('/?turn_right')
speed_up = request.find('/?speed_up')
car_stop = request.find('/?car_stop')
slow_down = request.find('/?slow_down')
car_backward = request.find('/?car_backward')
if car_direction == G_CMD_IDX:
endIdx = request.find(' HTTP/')
subReq = request[G_CMD_IDX:endIdx]
startIdx = subReq.find('=') + 1
virtualAngle = int(subReq[startIdx:])
print('cmd: car_direction, virtualAngle =', virtualAngle)
ledLight.on()
servoB.carDirection(virtualAngle)
elif turn_left == G_CMD_IDX:
print('cmd: turn_left')
ledLight.on()
servoB.turnLeft()
elif car_forward == G_CMD_IDX:
print('cmd: car_forward')
ledLight.on()
dcMotorA.forward(G_FORWARD_SPEED)
elif turn_right == G_CMD_IDX:
print('cmd: turn_right')
ledLight.on()
servoB.turnRight()
elif speed_up == G_CMD_IDX:
print('cmd: speed_up')
ledLight.on()
dcMotorA.speedUp()
elif car_stop == G_CMD_IDX:
print('cmd: car_stop')
ledLight.off()
dcMotorA.stop()
elif slow_down == G_CMD_IDX:
print('cmd: slow_down')
ledLight.on()
dcMotorA.slowDown()
elif car_backward == G_CMD_IDX:
print('cmd: car_backward')
ledLight.on()
dcMotorA.backward(G_BACKWARD_SPEED)
resHtml = getWebPage()
conn.send('HTTP/1.1 200 OK\n')
conn.send('Content-Type: text/html\n')
conn.send('Connection: closed.\n\n')
conn.sendall(resHtml)
conn.close()
except OSError as e:
conn.close()
print('Connection closed. OSError =', e)
# The duty cycle & frequency have been emperically tuned
# here to maximize the HV charge. This results in around
# 250V on the HV capacitor. Setting duty cycle higher generally
# just causes more current flow/waste in the HV transformer.
hvpwm.freq(2500)
hvpwm.duty_u16(800) #range 0 to 65535, 800 = 1.22% duty cycle
#hvpwm pin drives the HV transformer
pwm_off()
# Status LEDs:
ledHv = Signal(Pin(6, Pin.OUT)) #HV 'on' LED (based on feedback)
ledArm = Signal(Pin(27, Pin.OUT)) #Arm 'on' LED
ledStatus = Signal(Pin(7, Pin.OUT)) #Simple status LED
ledStatus.on()
# Due to original PCB being single-layer milled board, these buttons
# used different "active" status to simplify the board routing. This
# was left the same for final PCB.
buttonArm = Signal(Pin(28, Pin.IN, pull=Pin.PULL_DOWN))
buttonPulse = Signal(Pin(11, Pin.IN, pull=Pin.PULL_UP), invert=True)
# The 'charged' input routes to two pins, one of them is an ADC pin.
# Technically could just use the ADC pin as digital input, but again
# for 'technical debt' reasons left as two pins.
charged = Signal(Pin(18, Pin.IN), invert=True)
# The 'pulseOut' pin drives the gate of the switch via transformer.
pulse_out_pin = 14
pulseOut = Pin(pulse_out_pin, Pin.OUT)
