pingo-io / pingo-py / 152

pending completion

Build # 152

Build Type

Pull #82

travis-ci

Committed by

Vido

Commit Message

<a href="https://github.com/pingo-io/pingo-py/commit/7201238ab">Reverting unintentional chances

Back to the last revision:
</a><a class="double-link" href="https://github.com/pingo-io/pingo-py/commit/7e34d7f04">7e34d7f04</a>

Pull Request Pull Request #82: Issue #81

Run Details

53 of 53 new or added lines in 2 files covered. (100.0%)

596 of 1060 relevant lines covered (56.23%)

0.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

38.46

/pingo/arduino/firmata.py


"""
Firmata protocol client for Pingo
Works on Arduino
"""

import time
import platform

import pingo
from pingo.board import Board, DigitalPin, AnalogPin, PwmPin
from pingo.board import AnalogInputCapable, PwmOutputCapable
from pingo.detect import detect
from util_firmata import pin_list_to_board_dict

PyMata = None

PIN_STATES = {
    False: 0,
    True: 1,
    0: 0,
    1: 1,
    pingo.LOW: 0,
    pingo.HIGH: 1,
}

# TODO: PyMata suports Input, Output, PWM, Servo, Encoder and Tone
PIN_MODES = {
    pingo.IN: 0,
    pingo.OUT: 1,
}

VERBOSE = False


def get_arduino():
    serial_port = detect._find_arduino_dev(platform.system())
    if not serial_port:
        raise LookupError('Serial port not found')
    return ArduinoFirmata(serial_port)


class ArduinoFirmata(Board, AnalogInputCapable, PwmOutputCapable):

    def __init__(self, port=None):
        try:
            from PyMata.pymata import PyMata as PyMata  # noqa
        except ImportError:
            msg = 'pingo.arduino.Arduino requires PyMata installed'
            raise ImportError(msg)

        super(ArduinoFirmata, self).__init__()
        self.port = port
        self.firmata_client = PyMata(self.port, verbose=VERBOSE)

        self.firmata_client.capability_query()
        time.sleep(10)  # TODO: Find a small and safe value
        capability_query_results = self.firmata_client.get_capability_query_results()
        capability_dict = pin_list_to_board_dict(capability_query_results)

        self._add_pins(
            [DigitalPin(self, location)
                for location in capability_dict['digital']] +
            [PwmPin(self, location)
                for location in capability_dict['pwm']] +
            [AnalogPin(self, 'A%s' % location, resolution=10)
                for location in capability_dict['analog']]
        )

    def cleanup(self):
        # self.firmata_client.close() has sys.exit(0)
        if hasattr(self, 'PyMata'):
            try:
                self.firmata_client.transport.close()
            except AttributeError:
                pass

    def __repr__(self):
        cls_name = self.__class__.__name__
        return '<{cls_name} {self.port!r}>'.format(**locals())

    def _set_digital_mode(self, pin, mode):
        self.firmata_client.set_pin_mode(
            pin.location,
            PIN_MODES[mode],
            self.firmata_client.DIGITAL
        )

    def _set_analog_mode(self, pin, mode):
        pin_id = int(pin.location[1:])
        self.firmata_client.set_pin_mode(
            pin_id,
            self.firmata_client.INPUT,
            self.firmata_client.ANALOG
        )

    def _set_pwm_mode(self, pin, mode):
        pin_id = int(pin.location)
        self.firmata_client.set_pin_mode(
            pin_id,
            self.firmata_client.PWM,
            self.firmata_client.DIGITAL
        )

    def _get_pin_state(self, pin):
        _state = self.firmata_client.digital_read(pin.location)
        if _state == self.firmata_client.HIGH:
            return pingo.HIGH
        return pingo.LOW

    def _set_pin_state(self, pin, state):
        self.firmata_client.digital_write(
            pin.location,
            PIN_STATES[state]
        )

    def _get_pin_value(self, pin):
        pin_id = int(pin.location[1:])
        return self.firmata_client.analog_read(pin_id)

    def _set_pwm_duty_cycle(self, pin, value):
        pin_id = int(pin.location)
        firmata_value = int(value * 255)
        return self.firmata_client.analog_write(pin_id, firmata_value)

    def _set_pwm_frequency(self, pin, value):
        raise NotImplementedError

1
2	"""	1✔
3	Firmata protocol client for Pingo
4	Works on Arduino
5	"""
6
7	import time	1✔
8	import platform	1✔
9
10	import pingo	1✔
11	from pingo.board import Board, DigitalPin, AnalogPin, PwmPin	1✔
12	from pingo.board import AnalogInputCapable, PwmOutputCapable	1✔
13	from pingo.detect import detect	1✔
14	from util_firmata import pin_list_to_board_dict	1✔
15
16	PyMata = None	1✔
17
18	PIN_STATES = {	1✔
19	False: 0,
20	True: 1,
21	0: 0,
22	1: 1,
23	pingo.LOW: 0,
24	pingo.HIGH: 1,
25	}
26
27	# TODO: PyMata suports Input, Output, PWM, Servo, Encoder and Tone
28	PIN_MODES = {	1✔
29	pingo.IN: 0,
30	pingo.OUT: 1,
31	}
32
33	VERBOSE = False	1✔
34
35
36	def get_arduino():	1✔
37	serial_port = detect._find_arduino_dev(platform.system())	×
38	if not serial_port:	×
39	raise LookupError('Serial port not found')	×
40	return ArduinoFirmata(serial_port)	×
41
42
43	class ArduinoFirmata(Board, AnalogInputCapable, PwmOutputCapable):	1✔
44
45	def __init__(self, port=None):	1✔
46	try:	×
47	from PyMata.pymata import PyMata as PyMata # noqa	×
48	except ImportError:	×
49	msg = 'pingo.arduino.Arduino requires PyMata installed'	×
50	raise ImportError(msg)	×
51
52	super(ArduinoFirmata, self).__init__()	×
53	self.port = port	×
54	self.firmata_client = PyMata(self.port, verbose=VERBOSE)	×
55
56	self.firmata_client.capability_query()	×
57	time.sleep(10) # TODO: Find a small and safe value	×
58	capability_query_results = self.firmata_client.get_capability_query_results()	×
59	capability_dict = pin_list_to_board_dict(capability_query_results)	×
60
61	self._add_pins(	×
62	[DigitalPin(self, location)
63	for location in capability_dict['digital']] +
64	[PwmPin(self, location)
65	for location in capability_dict['pwm']] +
66	[AnalogPin(self, 'A%s' % location, resolution=10)
67	for location in capability_dict['analog']]
68	)
69
70	def cleanup(self):	1✔
71	# self.firmata_client.close() has sys.exit(0)
72	if hasattr(self, 'PyMata'):	×
73	try:	×
74	self.firmata_client.transport.close()	×
75	except AttributeError:	×
76	pass	×
77
78	def __repr__(self):	1✔
79	cls_name = self.__class__.__name__	×
80	return '<{cls_name} {self.port!r}>'.format(**locals())	×
81
82	def _set_digital_mode(self, pin, mode):	1✔
83	self.firmata_client.set_pin_mode(	×
84	pin.location,
85	PIN_MODES[mode],
86	self.firmata_client.DIGITAL
87	)
88
89	def _set_analog_mode(self, pin, mode):	1✔
90	pin_id = int(pin.location[1:])	×
91	self.firmata_client.set_pin_mode(	×
92	pin_id,
93	self.firmata_client.INPUT,
94	self.firmata_client.ANALOG
95	)
96
97	def _set_pwm_mode(self, pin, mode):	1✔
98	pin_id = int(pin.location)	×
99	self.firmata_client.set_pin_mode(	×
100	pin_id,
101	self.firmata_client.PWM,
102	self.firmata_client.DIGITAL
103	)
104
105	def _get_pin_state(self, pin):	1✔
106	_state = self.firmata_client.digital_read(pin.location)	×
107	if _state == self.firmata_client.HIGH:	×
108	return pingo.HIGH	×
109	return pingo.LOW	×
110
111	def _set_pin_state(self, pin, state):	1✔
112	self.firmata_client.digital_write(	×
113	pin.location,
114	PIN_STATES[state]
115	)
116
117	def _get_pin_value(self, pin):	1✔
118	pin_id = int(pin.location[1:])	×
119	return self.firmata_client.analog_read(pin_id)	×
120
121	def _set_pwm_duty_cycle(self, pin, value):	1✔
122	pin_id = int(pin.location)	×
123	firmata_value = int(value * 255)	×
124	return self.firmata_client.analog_write(pin_id, firmata_value)	×
125
126	def _set_pwm_frequency(self, pin, value):	1✔
127	raise NotImplementedError	×

pingo-io / pingo-py / 152

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous