class Motor:
def __init__(self, trip_meter):
# these values might need to be adjusted
self.max_speed = 0.55
min_voltage = 1.0
self.correction_interval = 0.01
self.proportional_term_in_PID = 1.25
self.derivative_term_in_PID = 0.01
# these values might change
self.pin_right_forward = 6
self.pin_right_backward = 11
self.pin_left_forward = 5
self.pin_left_backward = 10
self.pin_motor_battery = 7
##################################################
# Values after this should not need to be changed.
##################################################
self.trip_meter = trip_meter
self.min_value = math.floor(min_voltage / 5.0 * 255)
try:
self.connection = SerialManager(device='/dev/ttyACM2')
self.arduino = ArduinoApi(connection=self.connection)
except:
try:
self.connection = SerialManager(device='/dev/ttyACM0')
self.arduino = ArduinoApi(connection=self.connection)
except:
try:
self.connection = SerialManager(device='/dev/ttyACM1')
self.arduino = ArduinoApi(connection=self.connection)
except:
try:
self.connection = SerialManager(device='/dev/ttyACM3')
self.arduino = ArduinoApi(connection=self.connection)
except:
print "Could not connect to the arduino using /dev/ttyACM0, /dev/ttyACM1, /dev/ttyACM2 or /dev/ttyACM3"
self.arduino.pinMode(self.pin_right_forward, self.arduino.OUTPUT)
self.arduino.pinMode(self.pin_right_backward, self.arduino.OUTPUT)
self.arduino.pinMode(self.pin_left_forward, self.arduino.OUTPUT)
self.arduino.pinMode(self.pin_left_backward, self.arduino.OUTPUT)
self.arduino.pinMode(self.pin_motor_battery, self.arduino.OUTPUT)
self.arduino.pinMode(13, self.arduino.OUTPUT)
self.arduino.digitalWrite(13, 1)
self.arduino.digitalWrite(self.pin_motor_battery, 0)
self.power = 0.0
self.turn = 0.0
self.right_forward_value = 0
self.right_backward_value = 0
self.left_forward_value = 0
self.left_backward_value = 0
self.previous_right_forward_value = 0
self.previous_right_backward_value = 0
self.previous_left_forward_value = 0
self.previous_left_backward_value = 0
self.right_speed = 0.0
self.left_speed = 0.0
self.stopped = True
self.motor_control_thread = threading.Thread(target = self.motor_control_loop)
self.motor_control_thread.setDaemon(True)
self.motor_control_thread.start()
def motor_control_loop(self):
while True:
self.true_right_speed = self.trip_meter.get_right_speed() * 100.0 / self.max_speed
self.true_left_speed = self.trip_meter.get_left_speed() * 100.0 / self.max_speed
if (self.right_speed > 0.0):
self.right_backward_value = 0
next_previous_right_forward_value = self.right_forward_value
self.right_forward_value += self.proportional_term_in_PID * (self.right_speed - self.true_right_speed) - self.derivative_term_in_PID * (self.right_forward_value - self.previous_right_forward_value) / self.correction_interval
self.previous_right_forward_value = next_previous_right_forward_value
elif (self.right_speed < 0.0):
self.right_forward_value = 0
next_previous_right_backward_value = self.right_backward_value
self.right_backward_value += self.proportional_term_in_PID * (-self.right_speed - self.true_right_speed) - self.derivative_term_in_PID * (self.right_backward_value - self.previous_right_backward_value) / self.correction_interval
self.previous_right_backward_value = next_previous_right_backward_value
else:
self.right_forward_value = 0
self.right_backward_value = 0
self.previous_right_forward_value = 0
self.previous_right_backward_value = 0
if (self.left_speed > 0.0):
self.left_backward_value = 0
next_previous_left_forward_value = self.left_forward_value
self.left_forward_value += self.proportional_term_in_PID * (self.left_speed - self.true_left_speed) - self.derivative_term_in_PID * (self.left_forward_value - self.previous_left_forward_value) / self.correction_interval
self.previous_left_forward_value = next_previous_left_forward_value
elif (self.left_speed < 0.0):
self.left_forward_value = 0
next_previous_left_backward_value = self.left_backward_value
self.left_backward_value += self.proportional_term_in_PID * (-self.left_speed - self.true_left_speed) - self.derivative_term_in_PID * (self.left_backward_value - self.previous_left_backward_value) / self.correction_interval
self.previous_left_backward_value = next_previous_left_backward_value
else:
self.left_forward_value = 0
self.left_backward_value = 0
self.previous_left_forward_value = 0
self.previous_left_backward_value = 0
if (not self.stopped):
if (self.right_forward_value < 0):
self.right_forward_value = 0.0
elif (self.right_forward_value > 255):
self.right_forward_value = 255
if (self.right_backward_value < 0.0):
self.right_backward_value = 0.0
elif (self.right_backward_value > 255):
self.right_backward_value = 255
if (self.left_forward_value < 0.0):
self.left_forward_value = 0.0
elif (self.left_forward_value > 255):
self.left_forward_value = 255
if (self.left_backward_value < 0.0):
self.left_backward_value = 0.0
elif (self.left_backward_value > 255):
self.left_backward_value = 255
self.arduino.analogWrite(self.pin_right_forward, self.right_forward_value)
self.arduino.analogWrite(self.pin_right_backward, self.right_backward_value)
self.arduino.analogWrite(self.pin_left_forward, self.left_forward_value)
self.arduino.analogWrite(self.pin_left_backward, self.left_backward_value)
time.sleep(self.correction_interval)
def stop(self):
self.stopped = True
self.right_speed = 0.0
self.left_speed = 0.0
self.right_forward_value = 0
self.right_backward_value = 0
self.left_forward_value = 0
self.left_backward_value = 0
self.arduino.analogWrite(self.pin_right_forward, 0)
self.arduino.analogWrite(self.pin_right_backward, 0)
self.arduino.analogWrite(self.pin_left_forward, 0)
self.arduino.analogWrite(self.pin_left_backward, 0)
def turn_off(self):
self.arduino.digitalWrite(self.pin_motor_battery, 1)
self.stop()
# 'right_speed' is a number between -100 and 100, where 100 is full speed forward on the right wheel
def set_right_speed(self, right_speed):
self.right_speed = right_speed
self.stopped = False
if (self.right_speed == 0):
self.right_forward_value = 0
self.right_backward_value = 0
elif (self.right_speed > 0):
self.right_forward_value = self.right_speed / 100.0 * (255 - self.min_value) + self.min_value
self.right_backward_value = 0
elif (self.right_speed < 0):
self.right_forward_value = 0
self.right_backward_value = -self.right_speed / 100.0 * (255 - self.min_value) + self.min_value
# 'left_speed' is a number between -100 and 100, where 100 is full speed forward on the left wheel
def set_left_speed(self, left_speed):
self.left_speed = left_speed
self.stopped = False
if (self.left_speed == 0):
self.left_forward_value = 0
self.left_backward_value = 0
elif (self.left_speed > 0):
self.left_forward_value = self.left_speed / 100.0 * (255 - self.min_value) + self.min_value
self.left_backward_value = 0
elif (self.left_speed < 0):
self.left_forward_value = 0
self.left_backward_value = -self.left_speed / 100.0 * (255 - self.min_value) + self.min_value
M2A = 12
M2B = 13
a.pinMode(M1A, a.OUTPUT)
a.pinMode(M1B, a.OUTPUT)
a.pinMode(M2A, a.OUTPUT)
a.pinMode(M2B, a.OUTPUT)
a.digitalWrite(M1A, a.LOW)
a.digitalWrite(M2B, a.LOW)
a.digitalWrite(M2A, a.LOW)
a.digitalWrite(M2B, a.LOW)
M1En = 5
M2En = 6
a.pinMode(M1En, a.OUTPUT)
a.pinMode(M2En, a.OUTPUT)
a.analogWrite(M1En, 0)
a.analogWrite(M2En, 0)
try:
print 'Turning Motor 1'
print 'Clockwise'
sleep(2)
for x in range(0, 255):
a.analogWrite(M1En, x)
a.digitalWrite(M1A, a.HIGH)
print(x)
sleep(0.01)
for x in range(0, 255):
a.analogWrite(M1En, 255 - x)
print(255 - x)
from nanpy import (ArduinoApi, SerialManager)
from time import sleep
#Connect to Arduino. Automatically finds serial port.
connection = SerialManager()
a = ArduinoApi(connection = connection)
servo = 7
arrayLen = 19
routine = [180, 0, 170, 10, 160, 20, 150, 30, 140, 40,
130, 50, 120, 60, 110, 70, 100, 80, 90] #pattern for servo motor
a.pinMode(servo, a.OUTPUT)
while True:
for i in range(0, arrayLen): #for every space in the array(forwards)
a.analogWrite(servo, routine[i])
sleep(0.05)
for i in range(arrayLen, 0): #for every space in the array(forwards)
a.analogWrite(servo, routine[i])
sleep(0.05)
# Make sure you are connected to the Arduino!
try:
con = SerialManager("/dev/ttyACM0")
a = ArduinoApi(connection=con)
for device in devices:
if (device["sensor"] == False):
# This is an output device. SET the values!
a.pinMode(device["port"], a.OUTPUT)
type_values = device["type_values"]
for type_value in type_values:
name = type_value["name"]
device_values = device["device_values"]
a.analogWrite(device["port"], device_values[name])
elif (device["sensor"] == True):
sensor = device["type"]
if (sensor == "dht22"):
dht = DHT(device["port"], DHT.DHT22)
type_values = device["type_values"]
for type_value in type_values:
name = type_value["name"]
device_values = device["device_values"]
if (name == "temperature"):
device_values[name] = dht.readTemperature(
False)
elif (name == "humidity"):
device_values[name] = dht.readHumidity()
except:
a.digitalWrite(Motor1_2, a.HIGH)
def command (state):
if state == "forward":
return a.analogWrite(PWM1, 255), a.digitalWrite(Motor1_1,a.HIGH),a.digitalWrite(Motor1_2,a.LOW),
a.analogWrite(PWM2, 255), a.digitalWrite(Motor2_1,a.HIGH), a.digitalWrite(Motor2_2,a.LOW),
a.analogWrite(PWM3, 255), a.digitalWrite(Motor3_1,a.HIGH), a.digitalWrite(Motor3_2,a.LOW),
a.analogWrite(PWM4,255),a.digitalWrite(Motor4_1,a.HIGH), a.digitalWrite(Motor4_2,a.LOW)
elif state == "right":
return a.analogWrite(PWM1, 255), a.digitalWrite(Motor1_1,a.LOW),a.digitalWrite(Motor1_2,a.HIGH),
a.analogWrite(PWM2, 255), a.digitalWrite(Motor2_1,a.HIGH), a.digitalWrite(Motor2_2,a.LOW),
a.analogWrite(PWM3, 255), a.digitalWrite(Motor3_1,a.LOW), a.digitalWrite(Motor3_2,a.HIGH),
a.analogWrite(PWM4, 255),a.digitalWrite(Motor4_1,a.HIGH), a.digitalWrite(Motor4_2,a.LOW)
elif state == "left":
return a.analogWrite(PWM1, 255), a.digitalWrite(Motor1_1,a.HIGH),a.digitalWrite(Motor1_2,a.LOW),
a.analogWrite(PWM2, 255), a.digitalWrite(Motor2_1,a.LOW), a.digitalWrite(Motor2_2,a.HIGH),
a.analogWrite(PWM3, 255), a.digitalWrite(Motor3_1,a.HIGH), a.digitalWrite(Motor3_2,a.LOW),
a.analogWrite(PWM4,255),a.digitalWrite(Motor4_1,a.LOW), a.digitalWrite(Motor4_2,a.HIGH)
elif state == "left":
return a.analogWrite(PWM1, 255), a.digitalWrite(Motor1_1,a.LOW),a.digitalWrite(Motor1_2,a.HIGH),
a.analogWrite(PWM2, 255), a.digitalWrite(Motor2_1,a.LOW), a.digitalWrite(Motor2_2,a.HIGH),
a.analogWrite(PWM3, 255), a.digitalWrite(Motor3_1,a.LOW), a.digitalWrite(Motor3_2,a.HIGH),
a.analogWrite(PWM4,255),a.digitalWrite(Motor4_1,a.LOW), a.digitalWrite(Motor4_2,a.HIGH)
else:
# docs - https://github.com/nanpy/nanpy
from nanpy import ArduinoApi, SerialManager
from time import sleep
connection = SerialManager()
a = ArduinoApi(connection=connection)
LED = 13
brightness = 0
fadeAmount = 5
a.pinMode(LED, a.OUTPUT)
while True:
a.analogWrite(LED, brightness)
brightness += fadeAmount
if brightness == 0 or brightness == 255:
fadeAmount = -fadeAmount
sleep(0.03)
""" other basic functions - ArduinoApi.py
a.digitalRead(pin)
a.digitalWrite(pin, value)
a.analogRead(pin)
a.analogWrite(pin, value)
a.millis()
a.pulseIn(pin, value)
a.shiftOut(dataPin, clockPin, bitOrder, value)
"""
class ArduinoController(object):
serialManager = None
led_controller = None
def __init__(self,
zmq_context=None,
debounce=DEFAULT_DEBOUNCE,
button_pins=[],
led_pin=DEFAULT_LED_PIN):
self.debounce = debounce
self.button_pins = button_pins
self.led_pin = led_pin
self.zmq_context = zmq_context or zmq.Context.instance()
self.zmq_buttons_pub = self.zmq_context.socket(zmq.PUB)
self.zmq_buttons_pub.bind("inproc://arduino/buttons_pub")
self.buttons_timestamps = {pin: None for pin in self.button_pins}
def connect(self):
# close old connection if exists
if self.serialManager:
self.serialManager.close()
# make new connection
self.serialManager = SerialManager()
self.a = ArduinoApi(connection=self.serialManager)
def setup(self):
self.a.pinMode(self.led_pin, self.a.OUTPUT)
for pin in self.button_pins:
self.a.pinMode(pin, self.a.INPUT)
def loop(self):
for pin in self.button_pins:
if self.a.digitalRead(pin) == self.a.HIGH:
if self.buttons_timestamps[pin] is None:
self._keypress(pin)
self.buttons_timestamps[pin] = self._get_millis()
else:
if self.buttons_timestamps[pin] is not None:
if self.buttons_timestamps[
pin] + self.debounce < self._get_millis():
self._keyup(pin)
self.buttons_timestamps[pin] = None
if self.buttons_timestamps[pin] is not None:
self._keydown(pin)
self._led_frame()
def set_led_controller(self, led_controller):
self.led_controller = led_controller
def set_led_blinking(self, countdown=None):
self.set_led_controller(LedBlinker(freq=10, countdown=countdown))
def set_led_fading(self):
self.set_led_controller(LedFader(freq=0.25))
def set_led_off(self):
self.set_led_controller(LedSingle(brightness=0))
def set_led_on(self):
self.set_led_controller(LedSingle(brightness=255))
def set_led_blink_once(self):
self.set_led_controller(LedBlinker(freq=25, countdown=1))
def _keypress(self, pin):
evt = 'keypress={}'.format(pin).encode()
self.zmq_buttons_pub.send(evt)
def _keydown(self, pin):
evt = 'keydown={}'.format(pin).encode()
self.zmq_buttons_pub.send(evt)
def _keyup(self, pin):
evt = 'keyup={}'.format(pin).encode()
self.zmq_buttons_pub.send(evt)
def _get_millis(self):
return int(time.time() * 1000)
def _led_frame(self):
if self.led_controller is None:
self.a.analogWrite(self.led_pin, 0)
else:
brightness = self.led_controller.frame(self._get_millis())
self.a.analogWrite(self.led_pin, brightness)
a.pinMode(dirPinFR, a.OUTPUT)
a.pinMode(dirPinFL, a.OUTPUT)
a.pinMode(dirPinRR, a.OUTPUT)
a.pinMode(dirPinRL, a.OUTPUT)
a.pinMode(pwmPinFR, a.OUTPUT)
a.pinMode(pwmPinFL, a.OUTPUT)
a.pinMode(pwmPinRR, a.OUTPUT)
a.pinMode(pwmPinRL, a.OUTPUT)
while True:
events = pygame.event.get()
for event in events:
if event.type == pygame.JOYBUTTONDOWN:
if j.get_button(L1):
print('L1')
a.analogWrite(pwmPinFL, 0)
a.analogWrite(pwmPinRR, 0)
a.digitalWrite(dirPinFR, a.LOW)
a.digitalWrite(dirPinRL, a.LOW)
for i in range(150, 2):
a.analogWrite(pwmPinFR, i)
a.analogWrite(pwmPinRL, i)
if j.get_button(L2):
print('L2')
if j.get_button(R1):
print('R1')
stop()
if j.get_button(R2):
print('R2')
if j.get_button(cross):
EL = 3
ER = 11
try:
connection = SerialManager()
a = ArduinoApi(connection = connection)
print("connected!")
except:
print("Failed to connect to Arduino")
# setup the pinModes as if we were in the Arduino IDE
a.pinMode(ER, a.OUTPUT)
a.pinMode(EL, a.OUTPUT)
a.pinMode(ML1, a.OUTPUT)
a.pinMode(ML2, a.OUTPUT)
a.pinMode(MR1, a.OUTPUT)
a.pinMode(MR2, a.OUTPUT)
try:
while True:
a.digitalWrite(ML1, a.HIGH)
a.digitalWrite(ML2, a.LOW)
a.digitalWrite(MR1, a.HIGH)
a.digitalWrite(MR2, a.LOW)
a.analogWrite(EL, 80)
a.analogWrite(ER, 255)
except:
a.digitalWrite(ML1, a.LOW) # cut off voltage to these pins if something went wrong
a.digitalWrite(MR1, a.LOW) # cut off voltage to these pins if something went wrong
class Motor():
def __init__(self, device):
# self.compass = compassObject
self.devicePath=device
self.RPM=50
self.rotateRPM=160
self.currentDirection=None
# Directions
self.m11 = 2
self.m12 = 4
self.m21 = 8
self.m22 = 6
# Speed
self.s11 = 3
self.s12 = 5
self.s21 = 9
self.s22 = 7
self.connectMotor()
def connectMotor(self):
try:
connection = SerialManager(self.devicePath) #CHANGE THIS
self.motorSerial = ArduinoApi(connection=connection)
except Exception as e:
raise e
def setRPM(self, value):
self.RPM = value
#* Motor Movements
def moveMotor(self, direction):
if direction == self.currentDirection:
print("Ignoring, same direction")
else:
self.currentDirection=direction
if self.currentDirection=='forward':
self.forwardMotor()
elif self.currentDirection=='backward':
self.backwardMotor()
elif self.currentDirection=='left':
self.leftMotor()
elif self.currentDirection=='right':
self.rightMotor()
elif self.currentDirection=='stop':
self.resetAllMotors()
def forwardMotor(self):
print("Go forward!")
self.motorSerial.analogWrite(self.s11,self.RPM)
self.motorSerial.analogWrite(self.s12,self.RPM)
self.motorSerial.analogWrite(self.s21,self.RPM)
self.motorSerial.analogWrite(self.s22,self.RPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.LOW)
def backwardMotor(self):
self.motorSerial.analogWrite(self.s11,self.RPM)
self.motorSerial.analogWrite(self.s12,self.RPM)
self.motorSerial.analogWrite(self.s21,self.RPM)
self.motorSerial.analogWrite(self.s22,self.RPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.HIGH)
def leftMotor(self):
self.motorSerial.analogWrite(self.s11,self.rotateRPM)
self.motorSerial.analogWrite(self.s12,self.rotateRPM)
self.motorSerial.analogWrite(self.s21,self.rotateRPM)
self.motorSerial.analogWrite(self.s22,self.rotateRPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.HIGH)
def rightMotor(self):
self.motorSerial.analogWrite(self.s11,self.rotateRPM)
self.motorSerial.analogWrite(self.s12,self.rotateRPM)
self.motorSerial.analogWrite(self.s21,self.rotateRPM)
self.motorSerial.analogWrite(self.s22,self.rotateRPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.LOW)
def resetAllMotors(self):
self.motorSerial.analogWrite(self.s11,0)
self.motorSerial.analogWrite(self.s12,0)
self.motorSerial.analogWrite(self.s21,0)
self.motorSerial.analogWrite(self.s22,0)
def moveBot(x):
x = x.lower()
try:
connection = SerialManager()
a = ArduinoApi(connection=connection)
except:
print('Failed To Connect')
a.pinMode(m1pin1, a.OUTPUT)
a.pinMode(m1pin2, a.OUTPUT)
a.pinMode(m2pin1, a.OUTPUT)
a.pinMode(m2pin2, a.OUTPUT)
a.pinMode(m3pin1, a.OUTPUT)
a.pinMode(m3pin2, a.OUTPUT)
a.pinMode(m4pin1, a.OUTPUT)
a.pinMode(m4pin2, a.OUTPUT)
a.pinMode(m1enable, a.OUTPUT)
a.pinMode(m2enable, a.OUTPUT)
a.pinMode(m3enable, a.OUTPUT)
a.pinMode(m4enable, a.OUTPUT)
try:
if (x == "left"):
print("left dhukche")
a.analogWrite(m1enable, 200)
a.digitalWrite(m1pin1, a.HIGH)
a.digitalWrite(m1pin2, a.LOW)
a.analogWrite(m2enable, 200)
a.digitalWrite(m2pin1, a.HIGH)
a.digitalWrite(m2pin2, a.LOW)
a.analogWrite(m3enable, 200)
a.digitalWrite(m3pin1, a.HIGH)
a.digitalWrite(m3pin2, a.LOW)
a.analogWrite(m4enable, 200)
a.digitalWrite(m4pin1, a.HIGH)
a.digitalWrite(m4pin2, a.LOW)
sleep(1)
updateMovement()
elif (x == "right"):
print("right dhukche")
a.analogWrite(m1enable, 255)
a.digitalWrite(m1pin1, a.HIGH)
a.digitalWrite(m1pin2, a.LOW)
a.analogWrite(m2enable, 150)
a.digitalWrite(m2pin1, a.LOW)
a.digitalWrite(m2pin2, a.HIGH)
a.analogWrite(m3enable, 255)
a.digitalWrite(m3pin1, a.HIGH)
a.digitalWrite(m3pin2, a.LOW)
a.analogWrite(m4enable, 150)
a.digitalWrite(m4pin1, a.LOW)
a.digitalWrite(m4pin2, a.HIGH)
sleep(1)
updateMovement()
elif (x == "front"):
print("front dhukche")
a.analogWrite(m1enable, 250)
a.digitalWrite(m1pin1, a.HIGH)
a.digitalWrite(m1pin2, a.LOW)
a.analogWrite(m2enable, 100)
a.digitalWrite(m2pin1, a.HIGH)
a.digitalWrite(m2pin2, a.LOW)
a.analogWrite(m3enable, 250)
a.digitalWrite(m3pin1, a.HIGH)
a.digitalWrite(m3pin2, a.LOW)
a.analogWrite(m4enable, 100)
a.digitalWrite(m4pin1, a.HIGH)
a.digitalWrite(m4pin2, a.LOW)
sleep(1)
updateMovement()
elif (x == "back"):
print("dhukche")
a.analogWrite(m1enable, 200)
a.digitalWrite(m1pin1, a.LOW)
a.digitalWrite(m1pin2, a.HIGH)
a.analogWrite(m2enable, 200)
a.digitalWrite(m2pin1, a.LOW)
a.digitalWrite(m2pin2, a.HIGH)
a.analogWrite(m3enable, 200)
a.digitalWrite(m3pin1, a.LOW)
a.digitalWrite(m3pin2, a.HIGH)
a.analogWrite(m4enable, 200)
a.digitalWrite(m4pin1, a.LOW)
a.digitalWrite(m4pin2, a.HIGH)
sleep(1)
updateMovement()
else:
a.digitalWrite(m1pin1, a.LOW)
a.digitalWrite(m1pin2, a.LOW)
a.digitalWrite(m2pin1, a.LOW)
a.digitalWrite(m2pin2, a.LOW)
a.digitalWrite(m3pin1, a.LOW)
a.digitalWrite(m3pin2, a.LOW)
a.digitalWrite(m4pin1, a.LOW)
a.digitalWrite(m4pin2, a.LOW)
except:
pass
move_forward(time)
elif(str==b):
move_back(time)
def turn(str):
tl='turn_left'
tr='turn_right'
if(str==tl):
turn_left()
elif(str==tr):
turn_right()
def move_forward(time):
print('moving forward')
a.analogWrite(speed_left,255)
a.analogWrite(speed_right,255)
a.analogWrite(rot_left_1,255)
a.analogWrite(rot_left_2,0)
a.analogWrite(rot_right_1,255)
a.analogWrite(rot_right_2,0)
sleep(0.2*time)
def move_back(time):
a.analogWrite(speed_left,255)
a.analogWrite(speed_right,255)
from nanpy import (ArduinoApi, SerialManager)
from time import sleep
#Connect to Arduino. Automatically finds serial port.
connection = SerialManager()
a = ArduinoApi(connection = connection)
motorPin = 6
button = 7
a.pinMode(motorPin, a.OUTPUT)
a.pinMode(button, a.INPUT)
while True:
state = a.digitalRead(button)
while (state == 1):
for i in range(50, 255): #Start at 50 so it doesn't stop completely at any point
a.analogWrite(motorpin, i)
sleep(0.03)
for i in range(255, 50): #Counts backwards to 50
a.analogWrite(motorpin, i)
sleep(0.03)
a.analogWrite(motorPin, 0) #Turns off motor
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import subprocess
import RPi.GPIO as GPIO
import time
#import espeak
#import commands
from nanpy import ArduinoApi
from nanpy import SerialManager
#def espeak(string):
# output = 'espeak "%s" ' % string
#a = commands.getoutput(output)
connection = SerialManager(device='/dev/ttyACM0')
a = ArduinoApi(connection=connection)
bulb = 10
a.pinMode(bulb, a.OUTPUT)
def bulb50():
connection = SerialManager(device='/dev/ttyACM0')
a = ArduinoApi(connection=connection)
bulb = 10
a.pinMode(bulb, a.OUTPUT)
for i in range(0, 200):
a.analogWrite(bulb, 100)
from nanpy import (ArduinoApi, SerialManager, Tone)
from time import sleep
#Connect to Arduino. Automatically finds serial port.
connection = SerialManager()
a = ArduinoApi(connection=connection)
sensor = 14 #Analog pin 0
motorPin = 5
a.pinMode(sensor, a.INPUT) #Setup sensor
a.pinMode(motorPin, a.OUTPUT) #Setup motor
while True:
reading = analogRead(sensor) #Get reading
angle = map(reading, 0, 1023, 0, 360) #Convert reading to degrees by changing the range
speed = map(angle, 0, 360, 0, 255) #Find speed relative to angle
a.analogWrite(motorPin, speed)
class Motor():
def __init__(self, device):
# self.compass = compassObject
self.devicePath = device
self.RPM = 50
self.rotateRPM = 160
self.currentDirection = None
self.RPMOptions = [50, 100, 120, 150, 170, 200, 255]
self.currentSpeed = 0
# Directions
self.m11 = 2
self.m12 = 4
self.m21 = 6
self.m22 = 8
# Speed
self.s11 = 3
self.s12 = 5
self.s21 = 7
self.s22 = 9
self.connectMotor()
def connectMotor(self):
try:
connection = SerialManager(self.devicePath) #CHANGE THIS
self.motorSerial = ArduinoApi(connection=connection)
except Exception as e:
raise e
def setRPM(self, value):
self.RPM = value
newDir = self.currentDirection
self.currentDirection = ''
self.moveMotor(newDir)
def incrementRPM(self):
self.currentSpeed = self.currentSpeed + 1
if self.currentSpeed > len(self.RPMOptions) - 1:
self.currentSpeed = len(self.RPMOptions) - 1
self.setRPM(self.RPMOptions[self.currentSpeed])
return self.RPMOptions[self.currentSpeed]
def decrementRPM(self):
self.currentSpeed = self.currentSpeed - 1
if self.currentSpeed < 0:
self.currentSpeed = 0
self.setRPM(self.RPMOptions[self.currentSpeed])
return self.RPMOptions[self.currentSpeed]
#* Motor Movements
def moveMotor(self, direction):
if direction == self.currentDirection:
print("Ignoring, same direction")
else:
self.currentDirection = direction
if self.currentDirection == 'forward':
self.forwardMotor()
elif self.currentDirection == 'backward':
self.backwardMotor()
elif self.currentDirection == 'left':
self.leftMotor()
elif self.currentDirection == 'right':
self.rightMotor()
elif self.currentDirection == 'stop':
self.resetAllMotors()
def forwardMotor(self):
print("Go forward!")
self.motorSerial.analogWrite(self.s11, self.RPM)
self.motorSerial.analogWrite(self.s12, self.RPM)
self.motorSerial.analogWrite(self.s21, self.RPM)
self.motorSerial.analogWrite(self.s22, self.RPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.LOW)
def backwardMotor(self):
self.motorSerial.analogWrite(self.s11, self.RPM)
self.motorSerial.analogWrite(self.s12, self.RPM)
self.motorSerial.analogWrite(self.s21, self.RPM)
self.motorSerial.analogWrite(self.s22, self.RPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.HIGH)
def leftMotor(self):
self.motorSerial.analogWrite(self.s11, self.rotateRPM)
self.motorSerial.analogWrite(self.s12, self.rotateRPM)
self.motorSerial.analogWrite(self.s21, self.rotateRPM)
self.motorSerial.analogWrite(self.s22, self.rotateRPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.HIGH)
def rightMotor(self):
self.motorSerial.analogWrite(self.s11, self.rotateRPM)
self.motorSerial.analogWrite(self.s12, self.rotateRPM)
self.motorSerial.analogWrite(self.s21, self.rotateRPM)
self.motorSerial.analogWrite(self.s22, self.rotateRPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.LOW)
def resetAllMotors(self):
self.motorSerial.analogWrite(self.s11, 0)
self.motorSerial.analogWrite(self.s12, 0)
self.motorSerial.analogWrite(self.s21, 0)
self.motorSerial.analogWrite(self.s22, 0)
#setup the pin modes as if they were in the Arduino IDE
a.pinMode(enA, a.OUTPUT)
a.pinMode(enB, a.OUTPUT)
a.pinMode(in1, a.OUTPUT)
a.pinMode(in2, a.OUTPUT)
a.pinMode(in3, a.OUTPUT)
a.pinMode(in4, a.OUTPUT)
try:
print("hello")
a.digitalWrite(in1, a.HIGH)
a.digitalWrite(in2, a.LOW)
a.digitalWrite(in3, a.HIGH)
a.digitalWrite(in4, a.LOW)
a.analogWrite(enA, 150)
a.analogWrite(enB, 150)
#a.delay(5000)
sleep(5)
a.analogWrite(enA, 0)
a.analogWrite(enB, 0)
sleep(5)
except:
print("u suck")
a.digitalWrite(enA, a.LOW)
a.digitalWrite(enB, a.LOW)
a.digitalWrite(in1, a.LOW)
a.digitalWrite(in2, a.LOW)
a.digitalWrite(in3, a.LOW)
a.digitalWrite(in4, a.LOW)
ser = serial.Serial('/dev/ttyACM1', 115200, timeout=0)
print 'e'
path = [
Point(-0.4, -31.7),
Point(-1.161, 15.83),
Point(0.016, -28.119),
Point(-0.591, -21.995),
Point(-0.197, -15.945),
Point(0.293, -9.742),
Point(0.077, -2.05),
Point(.565, -2.212)
]
#set arduino pins - motors start off
a.digitalWrite(dirA, a.HIGH)
a.digitalWrite(dirB, a.HIGH)
a.analogWrite(pwmA, 0)
a.analogWrite(pwmB, 0)
print 'd'
#initalize self point
self = Point(0, 0)
data = hedge.position()
self.setX(data[1])
self.setY(data[2])
#initialize direction
direction = 0
print 'f'
avoidanceTurn = 1
ser.flushInput()
time.sleep(.5)
rawDir = ser.readline()
print str(rawDir)
class Car():
def __init__(self, arduinoApi=None, serialPort="/dev/ttyACM0"):
self.PINS = {
"LEFT_SPEED": 11, # ENA
"RIGHT_SPEED": 5, # ENB
"IN1": 9,
"IN2": 8,
"IN3": 7,
"IN4": 6,
}
if arduinoApi:
self.api = arduinoApi
else:
connection = SerialManager(device=serialPort)
self.api = ArduinoApi(connection=connection)
for pin in self.PINS.values():
self.api.pinMode(pin, self.api.OUTPUT)
self.left_speed_raw = 0
self.left_direction = 0
self.right_speed_raw = 0
self.right_direction = 0
def write(self):
self.write_speed()
self.write_left_direction()
self.write_right_direction()
def write_speed(self):
self.api.analogWrite(self.PINS["LEFT_SPEED"], self.left_speed_raw)
self.api.analogWrite(self.PINS["RIGHT_SPEED"], self.right_speed_raw)
def write_left_direction(self):
# both pins LOW if left_direction == 0 aka. full stop
self.api.digitalWrite(
self.PINS["IN3"],
self.api.LOW if self.left_direction > 0 else self.api.HIGH)
self.api.digitalWrite(
self.PINS["IN4"],
self.api.LOW if self.left_direction < 0 else self.api.HIGH)
def write_right_direction(self):
# both pins LOW if right_direction == 0 aka. full stop
self.api.digitalWrite(
self.PINS["IN1"],
self.api.LOW if self.right_direction > 0 else self.api.HIGH)
self.api.digitalWrite(
self.PINS["IN2"],
self.api.LOW if self.right_direction < 0 else self.api.HIGH)
# -100 <= left_speed <= 100
# -100 <= right_speed <= 100
# a value of 0 means stop
def move(self, left_speed, right_speed, turn=0):
# cmp(-123, 0) == -1
# cmp(0, 0) == 0
# cmp(88, 0) == 1
# aka it mimicks the "sign" function from other languages (and basic math)
self.left_direction = cmp(left_speed, 0)
self.right_direction = cmp(right_speed, 0)
# Because the wheels only start moving when the analog port has
# value 'threshold' or up. In our case it was somewhere between
# 80 and 90.
threshold = float(85)
# Make sure we don't f**k up with values outside [-100...100]
left_speed = min(100, max(-100, left_speed))
right_speed = min(100, max(-100, right_speed))
# Here we map a value [0...100] to [threshold...255]
self.left_speed_raw = round((float(abs(left_speed)) / 100.0) *
(255.0 - threshold) + threshold)
self.right_speed_raw = round((float(abs(right_speed)) / 100.0) *
(255.0 - threshold) + threshold)
if turn > 0:
self.right_speed_raw = 0
# self.left_speed_raw = min(255, self.left_speed_raw + turn * 4)
elif turn < 0:
self.left_speed_raw = 0
# self.right_speed_raw = min(255, self.right_speed_raw - turn * 4)
# write debug info
print "left_speed %d" % (left_speed)
print "right_speed %d" % (right_speed)
print "self.left_speed_raw %d" % (self.left_speed_raw)
print "self.right_speed_raw %d" % (self.right_speed_raw)
print "self.left_direction %d" % (self.left_direction)
print "self.right_direction %d" % (self.right_direction)
print ""
# Write values to the Bruce car
self.write()
def fullStop(self):
self.move(0, 0, 0)
class Motor():
def __init__(self, device):
# self.compass = compassObject
self.devicePath = device
self.RPM = 100
self.rotateRPM = 160
self.currentDirection = None
# Directions
self.m11 = 2
self.m12 = 4
self.m21 = 8
self.m22 = 6
# Speed
self.s11 = 3
self.s12 = 5
self.s21 = 9
self.s22 = 7
self.connectMotor()
def connectMotor(self):
try:
connection = SerialManager(self.devicePath) #CHANGE THIS
self.motorSerial = ArduinoApi(connection=connection)
except Exception as e:
raise e
# Finish this function
# def centerBot(self, getAngle):
# angle = self.compass.getCompassAngle()
# if(abs(angle-getAngle)>5):
# if(angle<getAngle):
# print("Rotate right")
# else:
# print("Rotate Left")
# else:
# botCentered=True
#* Motor Movements
def moveMotor(self, direction):
if direction == self.currentDirection:
print("Ignoring, same direction")
else:
self.currentDirection = direction
if self.currentDirection == 'forward':
self.forwardMotor()
elif self.currentDirection == 'backward':
self.backwardMotor()
elif self.currentDirection == 'left':
self.leftMotor()
elif self.currentDirection == 'right':
self.rightMotor()
elif self.currentDirection == 'stop':
self.resetAllMotors()
def forwardMotor(self):
print("Go forward!")
self.motorSerial.analogWrite(self.s11, self.RPM)
self.motorSerial.analogWrite(self.s12, self.RPM)
self.motorSerial.analogWrite(self.s21, self.RPM)
self.motorSerial.analogWrite(self.s22, self.RPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.LOW)
def backwardMotor(self):
self.motorSerial.analogWrite(self.s11, self.RPM)
self.motorSerial.analogWrite(self.s12, self.RPM)
self.motorSerial.analogWrite(self.s21, self.RPM)
self.motorSerial.analogWrite(self.s22, self.RPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.HIGH)
def leftMotor(self):
self.motorSerial.analogWrite(self.s11, self.rotateRPM)
self.motorSerial.analogWrite(self.s12, self.rotateRPM)
self.motorSerial.analogWrite(self.s21, self.rotateRPM)
self.motorSerial.analogWrite(self.s22, self.rotateRPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.HIGH)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.HIGH)
def rightMotor(self):
self.motorSerial.analogWrite(self.s11, self.rotateRPM)
self.motorSerial.analogWrite(self.s12, self.rotateRPM)
self.motorSerial.analogWrite(self.s21, self.rotateRPM)
self.motorSerial.analogWrite(self.s22, self.rotateRPM)
self.motorSerial.digitalWrite(self.m11, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m12, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m21, self.motorSerial.LOW)
self.motorSerial.digitalWrite(self.m22, self.motorSerial.LOW)
def resetAllMotors(self):
# while self.RPM>0:
# self.motorSerial.analogWrite(self.s11,self.RPM)
# self.motorSerial.analogWrite(self.s12,self.RPM)
# self.motorSerial.analogWrite(self.s21,self.RPM)
# self.motorSerial.analogWrite(self.s22,self.RPM)
# self.RPM-=1
# time.sleep(0.01)
# self.RPM=255
self.motorSerial.analogWrite(self.s11, 0)
self.motorSerial.analogWrite(self.s12, 0)
self.motorSerial.analogWrite(self.s21, 0)
self.motorSerial.analogWrite(self.s22, 0)
class Motor():
# Works as setup()
def __init__(self, device):
self.devicePath = device
self.connection = SerialManager(device=self.devicePath)
self.arduino = ArduinoApi(connection=self.connection)
self.RPM1 = 100
self.RPM2 = 100
self.RPM3 = 100
# Motor pins
self.dir1=7
self.pwm1=6
self.dir2=12
self.pwm2=9
self.dir3=13
self.pwm3=11
# Setup pinmodes
self.arduino.pinMode(self.dir1, self.arduino.OUTPUT)
self.arduino.pinMode(self.pwm1, self.arduino.OUTPUT)
self.arduino.pinMode(self.dir2, self.arduino.OUTPUT)
self.arduino.pinMode(self.pwm2, self.arduino.OUTPUT)
self.arduino.pinMode(self.dir3, self.arduino.OUTPUT)
self.arduino.pinMode(self.pwm3, self.arduino.OUTPUT)
def moveMotor(self, direction):
if direction=='u':
self.upMotor()
elif direction=='d':
self.downMotor()
elif direction=='o':
self.openMotor()
elif direction=='c':
self.closeMotor()
# elif direction=='x':
# exit()
def upMotor(self):
self.arduino.digitalWrite(self.dir1, self.arduino.HIGH)
self.arduino.digitalWrite(self.dir2, self.arduino.HIGH)
self.arduino.analogWrite(self.pwm1, self.RPM1)
self.arduino.analogWrite(self.pwm2, self.RPM1)
time.sleep(1)
self.arduino.analogWrite(self.pwm1, 0)
self.arduino.analogWrite(self.pwm2, 0)
def downMotor(self):
self.arduino.digitalWrite(self.dir1, self.arduino.LOW)
self.arduino.digitalWrite(self.dir2, self.arduino.LOW)
self.arduino.analogWrite(self.pwm1, self.RPM1)
self.arduino.analogWrite(self.pwm2, self.RPM2)
time.sleep(1)
self.arduino.analogWrite(self.pwm1, 0)
self.arduino.analogWrite(self.pwm2, 0)
def openMotor(self):
self.arduino.digitalWrite(self.dir3, self.arduino.HIGH)
self.arduino.analogWrite(self.pwm3, self.RPM3)
time.sleep(1)
self.arduino.analogWrite(self.pwm3, 0)
def closeMotor(self):
self.arduino.digitalWrite(self.dir3, self.arduino.LOW)
self.arduino.analogWrite(self.pwm3, self.RPM3)
time.sleep(1)
self.arduino.analogWrite(self.pwm3, 0)
from nanpy import (ArduinoApi, SerialManager)
from time import sleep
#Connect to Arduino. Automatically finds serial port.
connection = SerialManager()
a = ArduinoApi(connection=connection)
red = 3
yellow = 5
green = 6
a.pinMode(red, OUTPUT)
a.pinMode(yellow, OUTPUT)
a.pinMode(green, OUTPUT)
while True:
for i in range(
red, green
): #starting with the red pin, go through until it reaches the green
if (i != 4): #pin 4 is not used since not a PWM pin
for n in range(0, 1023, 4):
a.analogWrite(i, n) #Write n to i
sleep(0.03)
analogWrite(i, 0)
#Turn off LED
sleep(0.05)
class Motor():
# Works as setup()
def __init__(self, device):
self.devicePath = device
self.connection = SerialManager(device=self.devicePath)
self.arduino = ArduinoApi(connection=self.connection)
self.RPM = 70
self.turnPRM = 60
# Motor pins
self.dir11=7
self.pwm11=5 #cytron 1
self.dir21=2
self.pwm21=3
self.dir11=self.dir21
self.pwm11=self.pwm21
self.dir12=8
self.pwm12=9 #cytron 2
self.dir22=13
self.pwm22=11
# Setup pinmodes
self.arduino.pinMode(self.dir11, self.arduino.OUTPUT)
self.arduino.pinMode(self.pwm11, self.arduino.OUTPUT)
self.arduino.pinMode(self.dir12, self.arduino.OUTPUT)
self.arduino.pinMode(self.pwm12, self.arduino.OUTPUT)
self.arduino.pinMode(self.dir21, self.arduino.OUTPUT)
self.arduino.pinMode(self.pwm21, self.arduino.OUTPUT)
self.arduino.pinMode(self.dir22, self.arduino.OUTPUT)
self.arduino.pinMode(self.pwm22, self.arduino.OUTPUT)
def moveMotor(self, direction):
if direction=='f':
self.forwardMotor()
elif direction=='b':
self.backwardMotor()
elif direction=='l':
self.leftMotor()
elif direction=='r':
self.rightMotor()
elif direction=='s':
self.resetAllMotors()
elif direction=='x':
exit()
def forwardMotor(self):
self.arduino.digitalWrite(self.dir11, self.arduino.HIGH)
self.arduino.digitalWrite(self.dir12, self.arduino.LOW)
self.arduino.digitalWrite(self.dir21, self.arduino.HIGH)
self.arduino.digitalWrite(self.dir22, self.arduino.LOW)
self.arduino.analogWrite(self.pwm11, self.RPM)
self.arduino.analogWrite(self.pwm12, self.RPM)
self.arduino.analogWrite(self.pwm21, self.RPM)
self.arduino.analogWrite(self.pwm22, self.RPM)
def backwardMotor(self):
self.arduino.digitalWrite(self.dir11, self.arduino.LOW)
self.arduino.digitalWrite(self.dir12, self.arduino.HIGH)
self.arduino.digitalWrite(self.dir21, self.arduino.LOW)
self.arduino.digitalWrite(self.dir22, self.arduino.HIGH)
self.arduino.analogWrite(self.pwm11, self.RPM)
self.arduino.analogWrite(self.pwm12, self.RPM)
self.arduino.analogWrite(self.pwm21, self.RPM)
self.arduino.analogWrite(self.pwm22, self.RPM)
def leftMotor(self):
self.arduino.digitalWrite(self.dir11, self.arduino.HIGH)
self.arduino.digitalWrite(self.dir12, self.arduino.HIGH)
self.arduino.digitalWrite(self.dir21, self.arduino.HIGH)
self.arduino.digitalWrite(self.dir22, self.arduino.HIGH)
self.arduino.analogWrite(self.pwm11, self.turnRPM)
self.arduino.analogWrite(self.pwm12, self.turnRPM)
self.arduino.analogWrite(self.pwm21, self.turnRPM)
self.arduino.analogWrite(self.pwm22, self.turnRPM)
def rightMotor(self):
self.arduino.digitalWrite(self.dir11, self.arduino.LOW)
self.arduino.digitalWrite(self.dir12, self.arduino.LOW)
self.arduino.digitalWrite(self.dir21, self.arduino.LOW)
self.arduino.digitalWrite(self.dir22, self.arduino.LOW)
self.arduino.analogWrite(self.pwm11, self.turnRPM)
self.arduino.analogWrite(self.pwm12, self.turnRPM)
self.arduino.analogWrite(self.pwm21, self.turnRPM)
self.arduino.analogWrite(self.pwm22, self.turnRPM)
def resetAllMotors(self):
self.arduino.analogWrite(self.pwm11,0)
self.arduino.analogWrite(self.pwm12,0)
self.arduino.analogWrite(self.pwm21,0)
self.arduino.analogWrite(self.pwm22,0)
from nanpy import (ArduinoApi, SerialManager)
#Connect to Arduino. Automatically finds serial port.
connection = SerialManager()
a = ArduinoApi(connection=connection)
sensor = 14 #Analog pin 0
led = 5
a.pinMode(sensor, a.INPUT) #Setup sensor
a.pinMode(led, a.OUTPUT) #Setup LED
while True:
brightness = a.analogRead(sensor) #Get reading
print(brightness)
reverse = (1023 - brightness) #For Grove, 1023 = 780
lightRange = map(reverse, 0, 1023, 0, 255)
#For Grove, 1023 = 780. Changes the range of the readings to work with an LED
a.analogWrite(led, lightRange)
