def __init__(self, arduino_wait=2, sleep_tune=0.0001, log_output=False,com_port=None,
ip_address=None, ip_port=2000,
ip_handshake='*HELLO*'):
PymataCore.__init__(self, arduino_wait, sleep_tune, log_output, com_port, ip_address, ip_port,ip_handshake)
# report query results are stored in this dictionary
self.query_reply_data[BoardConstants.DHT11_DATA] = None
self.command_dictionary[BoardConstants.DHT11_DATA] = self._dht_data
self.command_dictionary[BoardConstants.PING_DATA] = self._ping_data
self.dht_map = {}
self.ping_map = {}
async def open(self) -> Transport:
"""Establish and return a transport-layer connection to the device.
Establishes a connection session with a mutual handshake specified by
the transport-layer protocol. Once the connection is established,
messages can be sent over the transport layer.
Blocks until the connection is established.
"""
# Connect board
logger.info('Please plug in the device now...')
self._board = PymataCore(**self._board_kwargs)
self.transport = Transport(self._board, **self.transport_kwargs)
self.transport.register_message_listener(self._on_sysex_message)
await self._board.start_aio()
logger.debug('Established datalink-layer connection!')
self._handshake_started = False
self._connected = False
# Establish mutual handshake
logger.debug('Initiating handshake for transport-layer connection...')
while self.transport is not None and not self._connected:
if self._handshake_started:
await self.transport.send_serialized_message('')
await asyncio.sleep(self._handshake_attempt_interval)
# Set up event handling
self.transport.start_receiving_serialized_messages()
logger.info('Established transport-layer connection!')
return self.transport
def __init__(self, port='', pwmMax=100):
board = None
try:
#Board init
if len(port) > 0:
board = PymataCore(com_port=port)
else:
board = PymataCore()
except Exception as excObj:
print("Something is wrong: {0}".format(excObj))
raise excObj
self.__board = board
self.__board.start()
#Led init
self.leds = {
1: Led(board, 10, False, Constants.PWM, pwmMax),
2: Led(board, 9, False, Constants.PWM, pwmMax),
3: Led(board, 5, False, Constants.PWM, pwmMax),
4: Led(board, 4, False, Constants.OUTPUT, 1),
5: Led(board, 8, True, Constants.OUTPUT, 1)
}
#Buzzer init
#Keyboard init
self.keys = {
1: Key(board, 13),
2: Key(board, 12),
3: Key(board, 7),
4: Key(board, 8)
}
#Sensors init
self.sensorLight = AnalogSensor(board, 0)
self.sensorTemperature = AnalogSensor(board, 1)
self.sensorAlcohol = AnalogSensor(board, 2)
self.sensorAxisX = AnalogSensor(board, 3)
self.sensorAxisY = AnalogSensor(board, 4)
self.sensorAxisZ = AnalogSensor(board, 5)
async def kick_off(self, my_loop):
"""
After s2aio is instantiated, this method must be called to start the HTTP server,
instantiate tye pymata_core interface to the arduino board, open Scratch and start
the polling watchdog timer to detect when Scratch stops polling.
:param my_loop: The asyncio event loop
:return: A reference to this server
"""
self.loop = my_loop
# noinspection PyBroadException
try:
# instantiate the arduino interface
self.board = PymataCore(com_port=self.com_port)
await self.board.start_aio()
# populate the arduino pin capability lists
await self.get_pin_capabilities()
# start up the HTTP server
app = web.Application(loop=my_loop)
srv = await my_loop.create_server(app.make_handler(), '127.0.0.1', 50209)
# start scratch if specified
# open to a specified project
if self.client == 'scratch':
if self.scratch_executable and self.scratch_project:
# noinspection PyPep8
if sys.platform.startswith('win32'):
os_string = "start /b " + self.scratch_executable + ' ' + self.scratch_project
await asyncio.sleep(self.windows_wait_time)
os.system(os_string)
else:
# noinspection PyPep8
os_string = 'nohup ' + self.scratch_executable + ' ' + self.scratch_project + ' ' + ' > /dev/null 2>&1 &'
os.system(os_string)
elif self.scratch_executable and not self.scratch_project:
os_string = 'nohup ' + self.scratch_executable + '> /dev/null 2>&1 &'
os.system(os_string)
else:
print('You must provide scratch excutable information')
elif self.client == 'snap':
new = 2
webbrowser.open(self.snap_url, new=new)
await asyncio.sleep(self.windows_wait_time)
else:
# no client specified, just start s2aio and wait for the user to start the client of choice
pass
# Scratch command handlers
app.router.add_route('GET', '/digital_pin_mode/{enable}/{pin}/{mode}', self.setup_digital_pin)
app.router.add_route('GET', '/analog_pin_mode/{enable}/{pin}', self.setup_analog_pin)
app.router.add_route('GET', '/poll', self.poll)
app.router.add_route('GET', '/digital_write/{pin}/{value}', self.digital_write)
app.router.add_route('GET', '/analog_write/{pin}/{value}', self.analog_write)
app.router.add_route('GET', '/play_tone/{pin}/{frequency}/{duration}', self.play_tone)
app.router.add_route('GET', '/set_servo_position/{pin}/{position}', self.set_servo_position)
app.router.add_route('GET', '/tone_off/{pin}', self.tone_off)
# Snap requires reporters to be supported
app.router.add_route('GET', '/digital_read/{pin}', self.digital_read)
app.router.add_route('GET', '/analog_read/{pin}', self.analog_read)
app.router.add_route('GET', '/problem', self.problem)
if self.client == 'scratch':
await self.poll_watchdog()
else:
await self.keep_alive()
return srv
except:
pass
print(
'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
+ str(data))
async def latching(my_board):
"""
Set digital pin 6 as a PWM output and set its output value to 128
@param my_board: A PymataCore instance
@return: No Return Value
"""
# set the pin mode
# await my_board.set_pin_mode(2, Constants.ANALOG, pin_callback, Constants.CB_TYPE_ASYNCIO)
await my_board.set_pin_mode(2, Constants.ANALOG)
await my_board.set_analog_latch(2, Constants.LATCH_GT, 500, latch_callback,
Constants.CB_TYPE_ASYNCIO)
while True:
await asyncio.sleep(1)
#value = await my_board.analog_read(2)
#print(value)
# create a PyMataCore instance and complete the initialization with a call to start()
board = PymataCore()
board.start()
# get the loop, and execute pin6_pwm_128
loop = asyncio.get_event_loop()
loop.run_until_complete(latching(board))
# your code goes here
async def blink(my_board):
"""
Blink LED 13
@return: No Return Value
"""
# set the pin mode
await my_board.set_pin_mode(13, Constants.OUTPUT)
for i in range(0, 5):
await my_board.digital_write(13, 1)
await asyncio.sleep(1)
await my_board.digital_write(13, 0)
await asyncio.sleep(1)
if __name__ == "__main__":
# create a PyMataCore instance and complete the initialization with a call to start_aio()
board = PymataCore()
loop = asyncio.get_event_loop()
loop.run_until_complete(board.start_aio())
# now execute your code on the loop and shutdown when done
try:
loop.run_until_complete(blink(board))
loop.run_until_complete(board.shutdown())
except RuntimeError:
loop.run_until_complete(board.shutdown())
exit(0)
if args.com == 'None':
comport = None
else:
comport = args.com
if args.log == 'True':
log = True
else:
log = False
ard_ip_addr = args.aIPaddr
ard_ip_port = args.aIPport
ard_handshake = args.handshake
core = PymataCore(int(args.wait), float(args.sleep), log, comport,
ard_ip_addr, ard_ip_port, ard_handshake)
# core = PymataCore()
core.start()
# Signal handler to trap control C
# noinspection PyUnusedLocal,PyUnusedLocal
def _signal_handler(sig, frame):
if core is not None:
print('\nYou pressed Ctrl+C')
task = asyncio.ensure_future(core.shutdown())
asyncio.get_event_loop().run_until_complete(task)
sys.exit(1)
return [xa, ya, za, cx, cy, cz]
async def wait_for_read_result(self):
"""
This is a utility function to wait for return data call back
@return: Returns resultant data from callback
"""
while not self.callback_data:
await asyncio.sleep(.001)
rval = self.callback_data
self.callback_data = []
return rval
if __name__ == "__main__":
my_board = PymataCore(2)
loop = asyncio.get_event_loop()
loop.run_until_complete(my_board.start_aio())
accel = RedBotAccel(my_board, 0x1d, 2, 0)
loop.run_until_complete(accel.start())
while True:
availb = loop.run_until_complete(accel.available())
if availb:
axis = loop.run_until_complete(accel.read())
x = axis[3]
y = axis[4]
z = axis[5]
tap = loop.run_until_complete(accel.read_tap())
if tap:
return [xa, ya, za, cx, cy, cz]
async def wait_for_read_result(self):
"""
This is a utility function to wait for return data call back
@return: Returns resultant data from callback
"""
while not self.callback_data:
await asyncio.sleep(.001)
rval = self.callback_data
self.callback_data = []
return rval
if __name__ == "__main__":
my_board = PymataCore(2)
loop = asyncio.get_event_loop()
loop.run_until_complete(my_board.start_aio())
accel = RedBotAccel(my_board, 0x1d, 2, 0)
loop.run_until_complete(accel.start())
while True:
availb = loop.run_until_complete(accel.available())
if availb:
axis = loop.run_until_complete(accel.read())
x = axis[3]
y = axis[4]
z = axis[5]
tap = loop.run_until_complete(accel.read_tap())
if tap:
if args.com == 'None':
comport = None
else:
comport = args.com
if args.log == 'True':
log = True
else:
log = False
ard_ip_addr = args.aIPaddr
ard_ip_port = args.aIPport
ard_handshake = args.handshake
core = PymataCore(int(args.wait), float(args.sleep), log, comport,
ard_ip_addr, ard_ip_port, ard_handshake)
# core = PymataCore()
core.start()
# Signal handler to trap control C
# noinspection PyUnusedLocal,PyUnusedLocal
def _signal_handler(sig, frame):
if core is not None:
print('\nYou pressed Ctrl+C')
task = asyncio.ensure_future(core.shutdown())
asyncio.get_event_loop().run_until_complete(task)
sys.exit(1)
class PymataIOT(WebSocketServerProtocol):
"""
This class implements the PyMata Websocket interface. JSON command messages are received via Websocket connection,
decoded and mapped to an associated PyMata method to be executed
operation.
The methods below are not intended to be called directly. The JSON message format is documented as part of the
method description. All JSON reply messages (to be handled by the client) will also be documented for
within the description.
usage: pymata_iot.py [-h] [-host HOSTNAME] [-port PORT] [-wait WAIT]
[-comport COM] [-sleep SLEEP] [-log LOG]
optional arguments:
-h, --help show this help message and exit
-host HOSTNAME Server name or IP address
-port PORT Server port number
-wait WAIT Arduino wait time
-comport COM Arduino COM port
-sleep SLEEP sleep tune in ms.
-log LOG True = send output to file, False = send output to console
"""
parser = argparse.ArgumentParser()
parser.add_argument("-host",
dest="hostname",
default="localhost",
help="Server name or IP address")
parser.add_argument("-port",
dest="port",
default="9000",
help="Server port number")
parser.add_argument("-wait",
dest="wait",
default="2",
help="Arduino wait time")
parser.add_argument("-comport",
dest="com",
default="None",
help="Arduino COM port")
parser.add_argument("-sleep",
dest="sleep",
default=".001",
help="sleep tune in ms.")
parser.add_argument("-log",
dest="log",
default="False",
help="redirect console output to log file")
args = parser.parse_args()
ip_addr = args.hostname
ip_port = args.port
if args.com == 'None':
comport = None
else:
comport = args.com
if args.log == 'True':
log = True
else:
log = False
core = PymataCore(int(args.wait), float(args.sleep), log, comport)
core.start()
def __init__(self):
"""
This is the "constructor" for PymataIOT. It sets up a translation dictionary using incoming JSON commands
and maps them to command methods.
@return: No Return.
"""
self.command_map = {
"analog_read": self.analog_read,
"analog_write": self.analog_write,
"digital_read": self.digital_read,
"digital_write": self.digital_write,
"disable_analog_reporting": self.disable_analog_reporting,
"disable_digital_reporting": self.disable_digital_reporting,
"enable_analog_reporting": self.disable_analog_reporting,
"enable_digital_reporting": self.disable_digital_reporting,
"encoder_config": self.encoder_config,
"encoder_read": self.encoder_read,
"get_analog_latch_data": self.get_analog_latch_data,
"get_analog_map": self.get_analog_map,
"get_capability_report": self.get_capability_report,
"get_digital_latch_data": self.get_digital_latch_data,
"get_firmware_version": self.get_firmware_version,
"get_pin_state": self.get_pinstate_report,
"get_protocol_version": self.get_protocol_version,
"get_pymata_version": self.get_pymata_version,
"i2c_config": self.i2c_config,
"i2c_read_data": self.i2c_read_data,
"i2c_read_request": self.i2c_read_request,
"i2c_write_request": self.i2c_write_request,
"play_tone": self.play_tone,
"set_analog_latch": self.set_analog_latch,
"set_digital_latch": self.set_digital_latch,
"set_pin_mode": self.set_pin_mode,
"set_sampling_interval": self.set_sampling_interval,
"sonar_config": self.sonar_config,
"sonar_read": self.sonar_read,
"servo_config": self.servo_config,
"stepper_config": self.stepper_config,
"stepper_step": self.stepper_step
}
@asyncio.coroutine
def analog_read(self, command):
"""
This method reads and returns the last reported value for an analog pin.
Normally not used since analog pin updates will be provided automatically
as they occur with the analog_message_reply being sent to the client after set_pin_mode is called.
(see enable_analog_reporting for message format).
@param command: {"method": "analog_read", "params": [ANALOG_PIN]}
@return: {"method": "analog_read_reply", "params": [PIN, ANALOG_DATA_VALUE]}
"""
pin = int(command[0])
data_val = yield from self.core.analog_read(pin)
reply = json.dumps({
"method": "analog_read_reply",
"params": [pin, data_val]
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def analog_write(self, command):
"""
This method writes a value to an analog pin.
It is used to set the output of a PWM pin or the angle of a Servo.
@param command: {"method": "analog_write", "params": [PIN, WRITE_VALUE]}
@return: No return message.
"""
pin = int(command[0])
value = int(command[1])
yield from self.core.analog_write(pin, value)
@asyncio.coroutine
def digital_read(self, command):
"""
This method reads and returns the last reported value for a digital pin.
Normally not used since digital pin updates will be provided automatically
as they occur with the digital_message_reply being sent to the client after set_pin_mode is called..
(see enable_digital_reporting for message format)
@param command: {"method": "digital_read", "params": [PIN]}
@return: {"method": "digital_read_reply", "params": [PIN, DIGITAL_DATA_VALUE]}
"""
pin = int(command[0])
data_val = yield from self.core.digital_read(pin)
reply = json.dumps({
"method": "digital_read_reply",
"params": [pin, data_val]
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def digital_write(self, command):
"""
This method writes a zero or one to a digital pin.
@param command: {"method": "digital_write", "params": [PIN, DIGITAL_DATA_VALUE]}
@return: No return message..
"""
pin = int(command[0])
value = int(command[1])
yield from self.core.digital_write(pin, value)
@asyncio.coroutine
def disable_analog_reporting(self, command):
"""
Disable Firmata reporting for an analog pin.
@param command: {"method": "disable_analog_reporting", "params": [PIN]}
@return: No return message..
"""
pin = int(command[0])
yield from self.core.disable_analog_reporting(pin)
@asyncio.coroutine
def disable_digital_reporting(self, command):
"""
Disable Firmata reporting for a digital pin.
@param command: {"method": "disable_digital_reporting", "params": [PIN]}
@return: No return message.
"""
pin = int(command[0])
yield from self.core.disable_digital_reporting(pin)
@asyncio.coroutine
def enable_analog_reporting(self, command):
"""
Enable Firmata reporting for an analog pin.
@param command: {"method": "enable_analog_reporting", "params": [PIN]}
@return: {"method": "analog_message_reply", "params": [PIN, ANALOG_DATA_VALUE]}
"""
pin = int(command[0])
yield from self.core.enable_analog_reporting(pin)
@asyncio.coroutine
def enable_digital_reporting(self, command):
"""
Enable Firmata reporting for a digital pin.
@param command: {"method": "enable_digital_reporting", "params": [PIN]}
@return: {"method": "digital_message_reply", "params": [PIN, DIGITAL_DATA_VALUE]}
"""
pin = int(command[0])
yield from self.core.enable_digital_reporting(pin)
@asyncio.coroutine
def encoder_config(self, command):
"""
Configure 2 pins for FirmataPlus encoder operation.
@param command: {"method": "encoder_config", "params": [PIN_A, PIN_B]}
@return: {"method": "encoder_data_reply", "params": [ENCODER_DATA]}
"""
pin_a = int(command[0])
pin_b = int(command[1])
yield from self.core.encoder_config(pin_a, pin_b,
self.encoder_callback)
@asyncio.coroutine
def encoder_read(self, command):
"""
This is a polling method to read the last cached FirmataPlus encoder value.
Normally not used. See encoder config for the asynchronous report message format.
@param command: {"method": "encoder_read", "params": [PIN_A]}
@return: {"method": "encoder_read_reply", "params": [PIN_A, ENCODER_VALUE]}
"""
pin = int(command[0])
val = yield from self.core.encoder_read(pin)
reply = json.dumps({
"method": "encoder_read_reply",
"params": [pin, val]
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def get_analog_latch_data(self, command):
"""
This method retrieves a latch table entry for an analog pin.
See constants.py for definition of reply message parameters.
@param command: {"method": "get_analog_latch_data", "params": [ANALOG_PIN]}
@return: {"method": "get_analog_latch_data_reply", "params": [ANALOG_PIN, LATCHED_STATE, THRESHOLD_TYPE,\
THRESHOLD_TARGET, DATA_VALUE, TIME_STAMP ]}
"""
pin = int(command[0])
data_val = yield from self.core.get_analog_latch_data(pin)
if data_val:
data_val = data_val[0:-1]
reply = json.dumps({
"method": "get_analog_latch_data_reply",
"params": [pin, data_val]
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def get_analog_map(self):
"""
This method retrieves the Firmata analog map.
Refer to: http://firmata.org/wiki/Protocol#Analog_Mapping_Query to interpret the reply
The command JSON format is: {"method":"get_analog_map","params":["null"]}
@return: {"method": "analog_map_reply", "params": [ANALOG_MAP]}
"""
value = yield from self.core.get_analog_map()
if value:
reply = json.dumps({"method": "analog_map_reply", "params": value})
else:
reply = json.dumps({
"method": "analog_map_reply",
"params": "None"
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def get_capability_report(self):
"""
This method retrieves the Firmata capability report.
Refer to http://firmata.org/wiki/Protocol#Capability_Query
The command format is: {"method":"get_capability_report","params":["null"]}
@return: {"method": "capability_report_reply", "params": [RAW_CAPABILITY_REPORT]}
"""
value = yield from self.core.get_capability_report()
asyncio.sleep(.1)
if value:
reply = json.dumps({
"method": "capability_report_reply",
"params": value
})
else:
reply = json.dumps({
"method": "capability_report_reply",
"params": "None"
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def get_digital_latch_data(self, command):
"""
This method retrieves a latch table entry for a digital pin.
See constants.py for definition of reply message parameters.
@param command: {"method": "get_digital_latch_data", "params": [ANALOG_PIN]}
@return: {"method": "get_digital_latch_data_reply", "params": [DIGITAL_PIN, LATCHED_STATE, THRESHOLD_TYPE,\
THRESHOLD_TARGET, DATA_VALUE, TIME_STAMP ]}
"""
pin = int(command[0])
data_val = yield from self.core.get_digital_latch_data(pin)
if data_val:
data_val = data_val[0:-1]
reply = json.dumps({
"method": "get_digital_latch_data_reply",
"params": [pin, data_val]
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def get_firmware_version(self):
"""
This method retrieves the Firmata firmware version.
See: http://firmata.org/wiki/Protocol#Query_Firmware_Name_and_Version
JSON command: {"method": "get_firmware_version", "params": ["null"]}
@return: {"method": "firmware_version_reply", "params": [FIRMWARE_VERSION]}
"""
value = yield from self.core.get_firmware_version()
if value:
reply = json.dumps({
"method": "firmware_version_reply",
"params": value
})
else:
reply = json.dumps({
"method": "firmware_version_reply",
"params": "Unknown"
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def get_pinstate_report(self, command):
"""
This method retrieves a Firmata pin_state report for a pin..
See: http://firmata.org/wiki/Protocol#Pin_State_Query
@param command: {"method": "get_pin_state", "params": [PIN]}
@return: {"method": "get_pin_state_reply", "params": [PIN_NUMBER, PIN_MODE, PIN_STATE]}
"""
pin = int(command[0])
value = yield from self.core.get_pin_state(pin)
if value:
reply = json.dumps({"method": "pin_state_reply", "params": value})
else:
reply = json.dumps({
"method": "pin_state_reply",
"params": "Unknown"
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def get_protocol_version(self):
"""
This method retrieves the Firmata protocol version.
JSON command: {"method": "get_protocol_version", "params": ["null"]}
@return: {"method": "protocol_version_reply", "params": [PROTOCOL_VERSION]}
"""
value = yield from self.core.get_protocol_version()
if value:
reply = json.dumps({
"method": "protocol_version_reply",
"params": value
})
else:
reply = json.dumps({
"method": "protocol_version_reply",
"params": "Unknown"
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def get_pymata_version(self):
"""
This method retrieves the PyMata release version number.
JSON command: {"method": "get_pymata_version", "params": ["null"]}
@return: {"method": "pymata_version_reply", "params":[PYMATA_VERSION]}
"""
value = yield from self.core.get_pymata_version()
if value:
reply = json.dumps({
"method": "pymata_version_reply",
"params": value
})
else:
reply = json.dumps({
"method": "pymata_version_reply",
"params": "Unknown"
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def i2c_config(self, command):
"""
This method initializes the I2c and sets the optional read delay (in microseconds).
It must be called before doing any other i2c operations for a given device.
@param command: {"method": "i2c_config", "params": [DELAY]}
@return: No Return message.
"""
delay = int(command[0])
yield from self.core.i2c_config(delay)
@asyncio.coroutine
def i2c_read_data(self, command):
"""
This method retrieves the last value read for an i2c device identified by address.
This is a polling implementation and i2c_read_request and i2c_read_request_reply may be
a better alternative.
@param command: {"method": "i2c_read_data", "params": [I2C_ADDRESS ]}
@return:{"method": "i2c_read_data_reply", "params": i2c_data}
"""
address = int(command[0])
i2c_data = yield from self.core.i2c_read_data(address)
reply = json.dumps({
"method": "i2c_read_data_reply",
"params": i2c_data
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def i2c_read_request(self, command):
"""
This method sends an I2C read request to Firmata. It is qualified by a single shot, continuous
read, or stop reading command.
Special Note: for the read type supply one of the following string values:
"0" = I2C_READ
"1" = I2C_READ | I2C_END_TX_MASK"
"2" = I2C_READ_CONTINUOUSLY
"3" = I2C_READ_CONTINUOUSLY | I2C_END_TX_MASK
"4" = I2C_STOP_READING
@param command: {"method": "i2c_read_request", "params": [I2C_ADDRESS, I2C_REGISTER,
NUMBER_OF_BYTES, I2C_READ_TYPE ]}
@return: {"method": "i2c_read_request_reply", "params": [DATA]}
"""
device_address = int(command[0])
register = int(command[1])
number_of_bytes = int(command[2])
if command[3] == "0":
read_type = Constants.I2C_READ_CONTINUOUSLY
elif command[3] == "1":
read_type = Constants.I2C_READ
elif command[3] == "2":
read_type = Constants.I2C_READ | Constants.I2C_END_TX_MASK
elif command[3] == "3":
read_type = Constants.I2C_READ_CONTINUOUSLY | Constants.I2C_END_TX_MASK
else: # the default case stop reading valid request or invalid request
read_type = Constants.I2C_STOP_READING
yield from self.core.i2c_read_request(device_address, register,
number_of_bytes, read_type,
self.i2c_read_request_callback)
yield from asyncio.sleep(1)
@asyncio.coroutine
def i2c_write_request(self, command):
"""
This method performs an I2C write at a given I2C address,
@param command: {"method": "i2c_write_request", "params": [I2C_DEVICE_ADDRESS, [DATA_TO_WRITE]]}
@return:No return message.
"""
device_address = int(command[0])
params = command[1]
params = [int(i) for i in params]
yield from self.core.i2c_write_request(device_address, params)
@asyncio.coroutine
def play_tone(self, command):
"""
This method controls a piezo device to play a tone. It is a FirmataPlus feature.
Tone command is TONE_TONE to play, TONE_NO_TONE to stop playing.
@param command: {"method": "play_tone", "params": [PIN, TONE_COMMAND, FREQUENCY(Hz), DURATION(MS)]}
@return:No return message.
"""
pin = int(command[0])
if command[1] == "TONE_TONE":
tone_command = Constants.TONE_TONE
else:
tone_command = Constants.TONE_NO_TONE
frequency = int(command[2])
duration = int(command[3])
yield from self.core.play_tone(pin, tone_command, frequency, duration)
@asyncio.coroutine
def set_analog_latch(self, command):
"""
This method sets the an analog latch for a given analog pin, providing the threshold type, and
latching threshold.
@param command: {"method": "set_analog_latch", "params": [PIN, THRESHOLD_TYPE, THRESHOLD_VALUE]}
@return:{"method": "analog_latch_data_reply", "params": [PIN, DATA_VALUE_LATCHED, TIMESTAMP_STRING]}
"""
pin = int(command[0])
threshold_type = int(command[1])
threshold_value = int(command[2])
yield from self.core.set_analog_latch(pin, threshold_type,
threshold_value,
self.analog_latch_callback)
@asyncio.coroutine
def set_digital_latch(self, command):
"""
This method sets the a digital latch for a given digital pin, the threshold type, and latching threshold.
@param command:{"method": "set_digital_latch", "params": [PIN, THRESHOLD (0 or 1)]}
@return:{"method": digital_latch_data_reply", "params": [PIN, DATA_VALUE_LATCHED, TIMESTAMP_STRING]}
"""
pin = int(command[0])
threshold_value = int(command[1])
yield from self.core.set_digital_latch(pin, threshold_value,
self.digital_latch_callback)
@asyncio.coroutine
def set_pin_mode(self, command):
"""
This method sets the pin mode for the selected pin. It handles: Input, Analog(Input) PWM, and OUTPUT. Servo
is handled by servo_config().
@param command: {"method": "set_pin_mode", "params": [PIN, MODE]}
@return:No return message.
"""
pin = int(command[0])
mode = int(command[1])
if mode == Constants.INPUT:
cb = self.digital_callback
elif mode == Constants.ANALOG:
cb = self.analog_callback
else:
cb = None
yield from self.core.set_pin_mode(pin, mode, cb)
def set_sampling_interval(self, command):
"""
This method sets the Firmata sampling interval in ms.
@param command:{"method": "set_sampling_interval", "params": [INTERVAL]}
@return:No return message.
"""
sample_interval = int(command[0])
yield from self.core.set_sampling_interval(sample_interval)
@asyncio.coroutine
def sonar_config(self, command):
"""
This method configures 2 pins to support HC-SR04 Ping devices.
This is a FirmataPlus feature.
@param command: {"method": "sonar_config", "params": [TRIGGER_PIN, ECHO_PIN, PING_INTERVAL(default=50),
MAX_DISTANCE(default= 200 cm]}
@return:{"method": "sonar_data_reply", "params": [DISTANCE_IN_CM]}
"""
trigger = int(command[0])
echo = int(command[1])
interval = int(command[2])
max_dist = int(command[3])
yield from self.core.sonar_config(trigger, echo, self.sonar_callback,
interval, max_dist)
@asyncio.coroutine
def sonar_read(self, command):
"""
This method retrieves the last sonar data value that was cached.
This is a polling method. After sonar config, sonar_data_reply messages will be sent automatically.
@param command: {"method": "sonar_read", "params": [TRIGGER_PIN]}
@return:{"method": "sonar_read_reply", "params": [TRIGGER_PIN, DATA_VALUE]}
"""
pin = int(command[0])
val = yield from self.core.sonar_data_retrieve(pin)
reply = json.dumps({
"method": "sonar_read_reply",
"params": [pin, val]
})
self.sendMessage(reply.encode('utf8'))
@asyncio.coroutine
def servo_config(self, command):
"""
This method configures a pin for servo operation. The servo angle is set by using analog_write().
@param command: {"method": "servo_config", "params": [PIN, MINIMUM_PULSE(ms), MAXIMUM_PULSE(ms)]}
@return:No message returned.
"""
pin = int(command[0])
min_pulse = int(command[1])
max_pulse = int(command[2])
yield from self.core.servo_config(pin, min_pulse, max_pulse)
@asyncio.coroutine
def stepper_config(self, command):
"""
This method configures 4 pins for stepper motor operation.
This is a FirmataPlus feature.
@param command: {"method": "stepper_config", "params": [STEPS_PER_REVOLUTION, [PIN1, PIN2, PIN3, PIN4]]}
@return:No message returned.
"""
steps_per_revs = int(command[0])
pins = command[1]
pin1 = int(pins[0])
pin2 = int(pins[1])
pin3 = int(pins[2])
pin4 = int(pins[3])
yield from self.core.stepper_config(steps_per_revs,
[pin1, pin2, pin3, pin4])
@asyncio.coroutine
def stepper_step(self, command):
"""
This method activates a stepper motor motion.
This is a FirmataPlus feature.
@param command: {"method": "stepper_step", "params": [SPEED, NUMBER_OF_STEPS]}
@return:No message returned.
"""
speed = int(command[0])
num_steps = int(command[1])
yield from self.core.stepper_step(speed, num_steps)
def onClose(self, was_clean, code, reason):
"""
Websocket management message.
This message is received when the client closes the connection. A console status message is printed and
and the interface is shutdown before exiting.
@param was_clean: Autobahn provided flag
@param code:Autobahn provided flag
@param reason:Autobahn provided flag
@return:Console message is generated.
"""
print("WebSocket connection closed: {0}".format(reason))
yield from self.core.shutdown()
def onConnect(self, request):
"""
WebSocket management method.
This method issues a console status message for Websocket connection establishment.
@param request: Websocket request
@return: No return value.
"""
print("Client connecting: {0}".format(request.peer))
def onMessage(self, payload, is_binary):
"""
Websocket management method.
This method receives JSON messages from the Websocket client. All messages are assumed to be text.
If a binary message is sent, a console status message is generated.
The JSON command is interpreted and translated to a method call to handle the command request.
@param payload: JSON command
@param is_binary: True if message is binary. Assumed to always be False
@return: No value is returned.
"""
if is_binary:
print("Binary message received: {0} bytes".format(len(payload)))
print('Expected text and not binary')
else:
cmd_dict = json.loads(payload.decode('utf8'))
client_cmd = cmd_dict.get("method")
if client_cmd in self.command_map:
cmd = self.command_map.get(client_cmd)
params = cmd_dict.get("params")
if params[0] != "null":
yield from cmd(params)
else:
yield from cmd()
def onOpen(self):
"""
WebSocket management method.
This method issues a console status message for the opening of a Websocket connection. It sends a Firmata
reset command to the Arduino.
@return: No return value.
"""
print("WebSocket connection open.")
yield from self.core.send_reset()
def analog_callback(self, data):
"""
This method handles the analog message received from pymata_core
@param data: analog callback message
@return:{"method": "analog_message_reply", "params": [PIN, DATA_VALUE}
"""
reply = json.dumps({
"method": "analog_message_reply",
"params": [data[0], data[1]]
})
self.sendMessage(reply.encode('utf8'))
def analog_latch_callback(self, data):
"""
This method handles analog_latch data received from pymata_core
@param data: analog latch callback message
@return:{"method": "analog_latch_data_reply", "params": [ANALOG_PIN, VALUE_AT_TRIGGER, TIME_STAMP_STRING]}
"""
ts = data[2]
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
reply = json.dumps({
"method": "analog_latch_data_reply",
"params": [data[0], data[1], st]
})
self.sendMessage(reply.encode('utf8'))
def digital_callback(self, data):
"""
This method handles the digital message received from pymata_core
@param data: digital callback message
@return:{"method": "digital_message_reply", "params": [PIN, DATA_VALUE]}
"""
reply = json.dumps({
"method": "digital_message_reply",
"params": [data[0], data[1]]
})
self.sendMessage(reply.encode('utf8'))
# yield from self.core.sleep(.001)
def digital_latch_callback(self, data):
"""
This method handles the digital latch data message received from pymata_core
@param data: digital latch callback message
@return:s{"method": "digital_latch_data_reply", "params": [PIN, DATA_VALUE_AT_TRIGGER, TIME_STAMP_STRING]}
"""
ts = data[2]
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
reply = json.dumps({
"method": "digital_latch_data_reply",
"params": [data[0], data[1], st]
})
self.sendMessage(reply.encode('utf8'))
def encoder_callback(self, data):
"""
This method handles the encoder data message received from pymata_core
@param data: encoder data callback message
@return:{"method": "encoder_data_reply", "params": [ENCODER VALUE]}
"""
reply = json.dumps({"method": "encoder_data_reply", "params": data})
self.sendMessage(reply.encode('utf8'))
def i2c_read_request_callback(self, data):
"""
This method handles the i2c read data message received from pymata_core.
@param data: i2c read data callback message
@return:{"method": "i2c_read_request_reply", "params": [DATA_VALUE]}
"""
reply = json.dumps({
"method": "i2c_read_request_reply",
"params": data
})
# print(reply);
self.sendMessage(reply.encode('utf8'))
def i2c_read_data_callback(self, data):
"""
This method handles the i2c cached read data received from pymata_core.
@param data: i2c read cached data callback message
@return:{"method": "i2c_read_data_reply", "params": [DATA_VALUE]}
"""
reply = json.dumps({"method": "i2c_read_data_reply", "params": data})
self.sendMessage(reply.encode('utf8'))
def sonar_callback(self, data):
"""
This method handles sonar data received from pymata_core.
@param data: sonar data callback message
@return:{"method": "sonar_data_reply", "params": [DATA_VALUE]}
"""
reply = json.dumps({"method": "sonar_data_reply", "params": data})
self.sendMessage(reply.encode('utf8'))
currentBrightness = 0
requestedBrightness = 0
lastBrightness = 255
currentMode = MODE_OFF
requestedMode = MODE_OFF
switchModeAt = time.time()
logger = logging.getLogger(__name__)
mqttClient = MQTTClient(config={
'keep_alive': 5,
'ping_delay': 1,
'auto_reconnect': True
})
board = PymataCore()
async def init_firmata():
""" Initialize Firmata connection """
await board.start_aio()
await board.set_pin_mode(FAN_PIN, FirmataConstants.OUTPUT)
await board.set_pin_mode(FIRE_PIN, FirmataConstants.OUTPUT)
await board.set_pin_mode(HEATER_LOW_PIN, FirmataConstants.OUTPUT)
await board.set_pin_mode(HEATER_HIGH_PIN, FirmataConstants.OUTPUT)
await board.set_pin_mode(LIGHT_PIN, FirmataConstants.PWM)
await board.digital_write(FAN_PIN, 0)
await board.digital_write(FIRE_PIN, 0)
async def left_encoder_callback(self, data):
if self.socket:
if data[0] != 0 or data[1] != 0:
msg = json.dumps({
"info": "encoders",
"left": data[0],
"right": data[1]
})
self.socket.sendMessage(msg.encode('utf8'))
asyncio.sleep(.1)
def establish_socket(self, socket):
self.socket = socket
if __name__ == "__main__":
loop = asyncio.get_event_loop()
my_core = PymataCore()
rbc = RedBotController(my_core)
loop.run_until_complete(rbc.init_red_board())
asyncio.ensure_future(rbc.motor_control(0, 1, 60))
asyncio.ensure_future(rbc.motor_control(1, 1, 60))
while True:
loop.run_until_complete(rbc.get_accel_data())
loop.run_until_complete(asyncio.sleep(.1))
loop.run_forever()
Blink LED 13
@return: No Return Value
"""
# set the pin mode
await my_board.set_pin_mode(13, Constants.OUTPUT)
for i in range(0, 5):
await my_board.digital_write(13, 1)
await asyncio.sleep(1)
await my_board.digital_write(13, 0)
await asyncio.sleep(1)
if __name__ == "__main__":
# create a PyMataCore instance and complete the initialization with a call to start_aio()
board = PymataCore()
loop = asyncio.get_event_loop()
loop.run_until_complete(board.start_aio())
# now execute your code on the loop and shutdown when done
try:
loop.run_until_complete(blink(board))
loop.run_until_complete(board.shutdown())
except RuntimeError:
loop.run_until_complete(board.shutdown())
exit(0)
from pymata_aio.constants import Constants
@asyncio.coroutine
def pin_6_pwm_128(my_board):
"""
Set digital pin 6 as a PWM output and set its output value to 128
@param my_board: A PymataCore instance
@return: No Return Value
"""
# set the pin mode
yield from my_board.set_pin_mode(6, Constants.PWM)
# set the pin to 128
yield from my_board.analog_write(6, 128)
# let the led stay lit for 3 seconds
yield from asyncio.sleep(3)
# shutdown
yield from my_board.shutdown()
# create a PyMataCore instance and complete the initialization with a call to start()
board = PymataCore()
board.start()
# get the loop, and execute pin6_pwm_128
loop = asyncio.get_event_loop()
loop.run_until_complete(pin_6_pwm_128(board))
async def kick_off(self, my_loop):
"""
After s2aios is instantiated, this method must be called to start the HTTP server,
instantiate tye pymata_core interface to the arduino board
:param my_loop: The asyncio event loop
:return: A reference to this server
"""
self.loop = my_loop
# noinspection PyBroadException
try:
# instantiate the arduino interface
self.board = PymataCore(arduino_wait=5, com_port=self.com_port, ip_address=self.ip_address,
ip_port=self.ip_port)
await self.board.start_aio()
# populate the arduino pin capability lists
await self.get_pin_capabilities()
# start up the HTTP server
app = web.Application(loop=my_loop)
srv = await my_loop.create_server(app.make_handler(), self.server_ip_address, self.server_ip__port)
# Scratch command handlers
# multi-board
app.router.add_route('GET', '/multi_board_connect/{board}/{addr}/{port}', self.multi_board_connect)
app.router.add_route('GET', '/digital_pin_mode/{board}/{enable}/{pin}/{mode}', self.setup_digital_pin)
app.router.add_route('GET', '/analog_pin_mode/{board}/{enable}/{pin}', self.setup_analog_pin)
app.router.add_route('GET', '/digital_write/{board}/{pin}/{value}', self.digital_write)
app.router.add_route('GET', '/analog_write/{board}/{pin}/{value}', self.analog_write)
app.router.add_route('GET', '/play_tone/{pin}/{board}/{frequency}/{duration}', self.play_tone)
app.router.add_route('GET', '/set_servo_position/{board}/{pin}/{position}', self.set_servo_position)
app.router.add_route('GET', '/tone_off/{board}/{pin}', self.tone_off)
# Snap requires reporters to be supported
app.router.add_route('GET', '/digital_read/{board}/{pin}', self.digital_read)
app.router.add_route('GET', '/analog_read/{board}/{pin}', self.analog_read)
# single board interface
app.router.add_route('GET', '/digital_read/{pin}', self.digital_read)
app.router.add_route('GET', '/analog_read/{pin}', self.analog_read)
app.router.add_route('GET', '/digital_pin_mode/{enable}/{pin}/{mode}', self.setup_digital_pin)
app.router.add_route('GET', '/analog_pin_mode/{enable}/{pin}', self.setup_analog_pin)
app.router.add_route('GET', '/poll', self.poll)
app.router.add_route('GET', '/digital_write/{pin}/{value}', self.digital_write)
app.router.add_route('GET', '/analog_write/{pin}/{value}', self.analog_write)
app.router.add_route('GET', '/play_tone/{pin}/{frequency}/{duration}', self.play_tone)
app.router.add_route('GET', '/set_servo_position/{pin}/{position}', self.set_servo_position)
app.router.add_route('GET', '/tone_off/{pin}', self.tone_off)
# Snap requires reporters to be supported
app.router.add_route('GET', '/digital_read/{pin}', self.digital_read)
app.router.add_route('GET', '/analog_read/{pin}', self.analog_read)
app.router.add_route('GET', '/problem', self.problem)
await self.board.keep_alive()
await self.keep_alive()
# self.client = aiohttp.ClientSession(loop=loop)
return srv
except:
pass
