mirror of
https://github.com/thearn/Python-Arduino-Command-API.git
synced 2026-01-10 15:08:18 -05:00
261 lines
8.3 KiB
Python
261 lines
8.3 KiB
Python
import logging
|
|
import unittest
|
|
|
|
|
|
logging.basicConfig(level=logging.DEBUG)
|
|
|
|
|
|
class MockSerial(object):
|
|
|
|
def __init__(self, baud, port, timeout=None):
|
|
self.port = port
|
|
self.baud = baud
|
|
self.timeout = timeout
|
|
self.output = []
|
|
self.input = []
|
|
self.is_open = True
|
|
|
|
def flush(self):
|
|
pass
|
|
|
|
def write(self, line):
|
|
self.output.append(line)
|
|
|
|
def isOpen(self):
|
|
return self.is_open
|
|
|
|
def close(self):
|
|
if self.is_open:
|
|
self.is_open = False
|
|
else:
|
|
raise ValueError('Mock serial port is already closed.')
|
|
|
|
def readline(self):
|
|
"""
|
|
@TODO: This does not take timeout into account at all.
|
|
"""
|
|
return self.input.pop(0)
|
|
|
|
def reset_mock(self):
|
|
self.output = []
|
|
self.input = []
|
|
|
|
def push_line(self, line, term='\r\n'):
|
|
self.input.append(str(line) + term)
|
|
|
|
|
|
INPUT = "INPUT"
|
|
OUTPUT = "OUTPUT"
|
|
LOW = "LOW"
|
|
HIGH = "HIGH"
|
|
READ_LOW = 0
|
|
READ_HIGH = 1
|
|
MSBFIRST = "MSBFIRST"
|
|
LSBFIRST = "LSBFIRST"
|
|
|
|
|
|
class ArduinoTestCase(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
from Arduino.arduino import Arduino
|
|
self.mock_serial = MockSerial(115200, '/dev/ttyACM0')
|
|
self.board = Arduino(sr=self.mock_serial)
|
|
|
|
|
|
class TestArduino(ArduinoTestCase):
|
|
|
|
def parse_cmd_sr(self, cmd_str):
|
|
assert cmd_str[0] == '@'
|
|
first_index = cmd_str.find('%')
|
|
assert first_index != -1
|
|
assert cmd_str[-2:] == '$!'
|
|
# Skip over the @ and read up to but not including the %.
|
|
cmd = cmd_str[1:first_index]
|
|
# Skip over the first % and ignore the trailing $!.
|
|
args_str = cmd_str[first_index+1:-2]
|
|
args = args_str.split('%')
|
|
return cmd, args
|
|
|
|
def test_close(self):
|
|
self.board.close()
|
|
# Call again, should skip calling close.
|
|
self.board.close()
|
|
|
|
def test_version(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
expected_version = "version"
|
|
self.mock_serial.push_line(expected_version)
|
|
self.assertEqual(self.board.version(), expected_version)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'), build_cmd_str('version'))
|
|
|
|
def test_pinMode_input(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 9
|
|
self.board.pinMode(pin, INPUT)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('pm', (-pin,)))
|
|
|
|
def test_pinMode_output(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 9
|
|
self.board.pinMode(pin, OUTPUT)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('pm', (pin,)))
|
|
|
|
def test_pulseIn_low(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
expected_duration = 230
|
|
self.mock_serial.push_line(expected_duration)
|
|
pin = 9
|
|
self.assertEqual(self.board.pulseIn(pin, LOW), expected_duration)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('pi', (-pin,)))
|
|
|
|
def test_pulseIn_high(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
expected_duration = 230
|
|
pin = 9
|
|
self.mock_serial.push_line(expected_duration)
|
|
self.assertEqual(self.board.pulseIn(pin, HIGH), expected_duration)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'), build_cmd_str('pi', (pin,)))
|
|
|
|
def test_digitalRead(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 9
|
|
self.mock_serial.push_line(READ_LOW)
|
|
self.assertEqual(self.board.digitalRead(pin), READ_LOW)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'), build_cmd_str('dr', (pin,)))
|
|
|
|
def test_digitalWrite_low(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 9
|
|
self.board.digitalWrite(pin, LOW)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'), build_cmd_str('dw', (-pin,)))
|
|
|
|
def test_digitalWrite_high(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 9
|
|
self.board.digitalWrite(pin, HIGH)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'), build_cmd_str('dw', (pin,)))
|
|
|
|
def test_melody(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 9
|
|
notes = ["C4"]
|
|
duration = 4
|
|
C4_NOTE = 262
|
|
self.board.Melody(pin, notes, [duration])
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('to', (len(notes), pin, C4_NOTE, duration)))
|
|
self.assertEqual(self.mock_serial.output[1].decode('UTF-8'),
|
|
build_cmd_str('nto', (pin,)))
|
|
|
|
def test_shiftIn(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
dataPin = 2
|
|
clockPin = 3
|
|
pinOrder = MSBFIRST
|
|
expected = 0xff
|
|
self.mock_serial.push_line(expected)
|
|
self.assertEqual(self.board.shiftIn(dataPin, clockPin, pinOrder),
|
|
expected)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('si', (dataPin, clockPin, pinOrder,)))
|
|
|
|
def test_shiftOut(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
dataPin = 2
|
|
clockPin = 3
|
|
pinOrder = MSBFIRST
|
|
value = 0xff
|
|
self.board.shiftOut(dataPin, clockPin, pinOrder, value)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('so', (dataPin, clockPin, pinOrder, value)))
|
|
|
|
def test_analogRead(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 9
|
|
expected = 1023
|
|
self.mock_serial.push_line(expected)
|
|
self.assertEqual(self.board.analogRead(pin), expected)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('ar', (pin,)))
|
|
|
|
def test_analogWrite(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 9
|
|
value = 255
|
|
self.board.analogWrite(pin, value)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('aw', (pin, value)))
|
|
|
|
|
|
class TestServos(ArduinoTestCase):
|
|
|
|
def test_attach(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 10
|
|
position = 0
|
|
self.mock_serial.push_line(position)
|
|
servo_min = 544
|
|
servo_max = 2400
|
|
self.board.Servos.attach(pin, min=servo_min, max=servo_max)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('sva', (pin, servo_min, servo_max)))
|
|
|
|
def test_detach(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 10
|
|
position = 0
|
|
# Attach first.
|
|
self.mock_serial.push_line(position)
|
|
self.board.Servos.attach(pin)
|
|
self.mock_serial.reset_mock()
|
|
self.board.Servos.detach(pin)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str('svd', (position,)))
|
|
|
|
def test_write(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 10
|
|
position = 0
|
|
angle = 90
|
|
# Attach first.
|
|
self.mock_serial.push_line(position)
|
|
self.board.Servos.attach(pin)
|
|
self.mock_serial.reset_mock()
|
|
self.board.Servos.write(pin, angle)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str("svw", (position, angle)))
|
|
|
|
def test_writeMicroseconds(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 10
|
|
position = 0
|
|
microseconds = 1500
|
|
# Attach first.
|
|
self.mock_serial.push_line(position)
|
|
self.board.Servos.attach(pin)
|
|
self.mock_serial.reset_mock()
|
|
self.board.Servos.writeMicroseconds(pin, microseconds)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str("svwm", (position, microseconds)))
|
|
|
|
def test_read(self):
|
|
from Arduino.arduino import build_cmd_str
|
|
pin = 10
|
|
position = 0
|
|
angle = 90
|
|
# Attach first.
|
|
self.mock_serial.push_line(position)
|
|
self.board.Servos.attach(pin)
|
|
self.mock_serial.reset_mock()
|
|
self.mock_serial.push_line(angle)
|
|
self.assertEqual(self.board.Servos.read(pin), angle)
|
|
self.assertEqual(self.mock_serial.output[0].decode('UTF-8'),
|
|
build_cmd_str("svr", (position,)))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|