def main(input_device):
# Initialise Connect SDK
sdk = ChirpConnect()
print(str(sdk))
print(sdk.audio.query_devices())
if sdk.protocol_name != 'standard':
raise RuntimeError('Must use the standard protocol ' +
'to be compatible with other Chirp Messenger apps.')
# Configure audio
sdk.audio.frame_size = 4096
sdk.audio.input_device = input_device
# Set callbacks and start SDK
sdk.set_callbacks(Callbacks())
sdk.start(send=False, receive=True)
try:
# Process audio streams
while True:
time.sleep(1)
except KeyboardInterrupt:
print('Exiting')
sdk.stop()
def main(block_name, input_device, output_device, block_size, sample_rate):
global display, xd
# Initialise ConnectSDK
sdk = ChirpConnect(block=block_name)
print(str(sdk))
print('Protocol: {protocol} [v{version}]'.format(
protocol=sdk.protocol_name, version=sdk.protocol_version))
print(sdk.audio.query_devices())
# Configure audio
sdk.audio.input_device = input_device
sdk.audio.output_device = output_device
sdk.audio.block_size = block_size
sdk.input_sample_rate = 44000
sdk.output_sample_rate = sample_rate
# Set callback functions
sdk.set_callbacks(Callbacks())
# Generate random payload and send
sdk.start(send=True, receive=True)
try:
# Process audio streams
while True:
time.sleep(0.1)
# sys.stdout.write('.')
sys.stdout.flush()
if display:
easygui.msgbox(xd, "Alert")
display = False
except KeyboardInterrupt:
print('Exiting')
sdk.stop()
#!/usr/bin/env python
import os
from playsound import playsound
from chirpsdk import ChirpConnect, CallbackSet
chirp = ChirpConnect()
chirp.start(send=True)
identifier = 'cop'
payload = bytearray([ord(ch) for ch in identifier])
chirp.send(payload, blocking=True)
playsound('beedoo.mp3')
playsound('beedoo.mp3')
import sys
import time
import json
from chirpsdk import ChirpConnect, CallbackSet
class Callbacks(CallbackSet):
def on_received(self, payload, channel):
if payload is not None:
hex = payload.decode('utf-8')
print(json.dumps({"data": hex, "type": "hex"}))
else:
print(json.dumps({"data": "Decode Failed", "type": "error"}))
def on_receiving(self, channel):
print(json.dumps({"data": "Listening...", "type": "listening"}))
return super().on_receiving(channel)
chirp = ChirpConnect(block='ultrasonic-multi-channel')
chirp.start(receive=True)
chirp.set_callbacks(Callbacks())
try:
while True:
time.sleep(0.1)
sys.stdout.flush()
except KeyboardInterrupt:
print('Exiting')
from chirpsdk import ChirpConnect, CallbackSet
from resources import send_credential
class Callbacks(CallbackSet):
def on_received(self, payload, channel):
if payload is None:
print('Decode failed!')
else:
payload = ''.join([chr(tmp) for tmp in payload])
data = payload.split(':')
send_audio_credential(data[0], data[1])
chirp = ChirpConnect()
chirp.set_callbacks(Callbacks())
chirp.start(send=False, receive=True)
try:
while (True):
pass
except KeyboardInterrupt:
chirp.stop()
print('Exiting...')
import argparse
import sys
import time
import datetime
import json
import math
import random
import logging
from chirpsdk import ChirpConnect, CallbackSet, CHIRP_CONNECT_STATE
logging.basicConfig(filename='accesspoint.log',
format='%(asctime)s %(message)s')
logger = logging.getLogger()
logger.setLevel(logging.INFO)
sdk = ChirpConnect()
chid = 7
device_no = ''
class Callbacks(CallbackSet):
def __init__(self):
self.temp = ''
self.received = ''
def on_state_changed(self, previous_state, current_state):
""" Called when the SDK's state has changed """
logger.info('State changed from %s to %s',
CHIRP_CONNECT_STATE.get(previous_state),
CHIRP_CONNECT_STATE.get(current_state))
print('State changed from {} to {}'.format(
CHIRP_CONNECT_STATE.get(previous_state),
from cryptography.hazmat.backends import default_backend from cryptography.hazmat.primitives.twofactor.totp import TOTP from cryptography.hazmat.primitives.hashes import SHA256 from chirpsdk import ChirpConnect import time chirp = ChirpConnect() chirp.start(send=True, receive=False) key = b'}\x11\xf4b\xf8\xc8$\x01Hh\x95m\xa8\xb0\x1a~\xbb-\x81\x04\xc7\xb8\xa4%\x86\x87\xda\\ja\x92R' totp = TOTP(key, 8, SHA256(), 30, backend=default_backend()) totp_value = totp.generate(time.time()) identifier = '[email protected]:'+totp_value.decode() payload = chirp.new_payload(identifier.encode()) chirp.send(payload, blocking=True) chirp.stop()
import sys
import time
import json
from chirpsdk import ChirpConnect, CallbackSet
class Callbacks(CallbackSet):
def on_received(self, payload, channel):
if payload is not None:
hex = payload.decode('utf-8')
print(json.dumps({"data": hex, "type": "hex"}))
else:
print(json.dumps({"data": "Decode Failed", "type": "error"}))
def on_receiving(self, channel):
print(json.dumps({"data": "Listening...", "type": "listening"}))
return super().on_receiving(channel)
chirp = ChirpConnect()
chirp.start(receive=True)
chirp.set_callbacks(Callbacks())
try:
while True:
time.sleep(0.1)
sys.stdout.flush()
except KeyboardInterrupt:
print('Exiting')
def test_read_chirprc(self):
self.sdk = ChirpConnect()
self.sdk.read_chirprc('test')
self.assertIsNotNone(self.sdk.config)
from chirpsdk import ChirpConnect, CallbackSet
import chirpsdk
import sys
import time
chirp = ChirpConnect(
debug=True,
key="544c4dC370CEAf0df0d4C23E6",
secret="BAa70CdaaAA5e9E43A46bfF1D99Ae5DEB0c0Aa4b36dfDB9fD0",
config=
"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"
)
recebido = False
chirp.audio.wav_filename = 'C:\\debug\\teste.wav'
print(chirpsdk.CHIRP_CONNECT_STATE_NOT_CREATED)
class Callbacks(CallbackSet):
def on_sent(self, payload, channel):
print(f"mandei : {payload}")
identifier = payload.decode('utf-8')
print(identifier)
def on_receiving(self, channel):
print('Receiving data [ch{ch}]'.format(ch=channel))
def on_received(self, payload, channel):
print("algo")
if payload is not None:
global recebido
identifier = payload.decode('utf-8')
print('Received: ' + identifier)
def main(app_key, app_secret, app_config, input_device, output_device,
block_size, sample_rate):
# Initialise ConnectSDK
sdk = ChirpConnect(app_key, app_secret, app_config)
print(str(sdk))
print('Protocol: {protocol} [v{version}]'.format(
protocol=sdk.protocol_name, version=sdk.protocol_version))
print(sdk.audio.query_devices())
# Configure audio
sdk.audio.input_device = input_device
sdk.audio.output_device = output_device
sdk.audio.block_size = block_size
sdk.input_sample_rate = sample_rate
sdk.output_sample_rate = sample_rate
# Set callback functions
sdk.set_callbacks(Callbacks())
# Generate random payload and send
payload = sdk.random_payload()
sdk.start(send=True, receive=True)
sdk.send(payload)
try:
# Process audio streams
while True:
time.sleep(0.1)
sys.stdout.write('.')
sys.stdout.flush()
except KeyboardInterrupt:
print('Exiting')
sdk.stop()
sdk.close()
def main(block_name, input_device, output_device, block_size, sample_rate,
string):
# Initialise ConnectSDK
sdk = ChirpConnect(block=block_name)
print(str(sdk))
print('Protocol: {protocol} [v{version}]'.format(
protocol=sdk.protocol_name, version=sdk.protocol_version))
print(sdk.audio.query_devices())
# Configure audio
sdk.audio.input_device = input_device
sdk.audio.output_device = output_device
sdk.audio.block_size = block_size
sdk.input_sample_rate = sample_rate
sdk.output_sample_rate = 44100
# Set callback functions
sdk.set_callbacks(Callbacks())
# print("type your message")
#msg = ""
print(string)
divideMsg8(string)
#print(divMsg)
# window = Tk()
# messages = Text(window)
# messages.pack()
# # input_user = StringVar()
# # input_field = Entry(window, text=input_user)
# input_field.pack(side=BOTTOM, fill=X)
# def Enter_pressed(event):
# input_get = input_field.get()
# global msg, divMsg
# msg = input_get
# divMsg = divideMsg8(string)
# #print(input_get)
# messages.insert(INSERT, '%s\n' % input_get)
# # label = Label(window, text=input_get)
# input_user.set('')
# # label.pack()
# return "break"
# frame = Frame(window) # , width=300, height=300)
# input_field.bind("<Return>", Enter_pressed)
# frame.pack()
# window.mainloop()
#initialize SDK to SEND ONLY
sdk.start(send=True, receive=True)
timeLapse = 0
# numMsgSent = 0;
try:
# Process audio streams
while True:
if string != "xS$9!a6@":
time.sleep(0.1)
# sys.stdout.write('.')
sys.stdout.flush()
timeLapse += 1
if timeLapse % 50 == 0:
timeLapse = 0
# if numMsgSent <= len(divMsg):
if len(divMsg) > 0:
# identifier = divMsg[numMsgSent]
identifier = divMsg[0]
payload = bytearray([ord(ch) for ch in identifier])
sdk.send(payload)
divMsg.pop(0)
# numMsgSent += 1
else:
identifier = "@6a!9$Sx"
payload = bytearray([ord(ch) for ch in identifier])
sdk.send(payload)
time.sleep(5)
break
else:
time.sleep(0.1)
# sys.stdout.write('.')
sys.stdout.flush()
break
except KeyboardInterrupt:
print('Exiting')
sdk.stop()
class Modem:
"""
An audio modem able to encode and decode data from/to audio. Internally uses chirp for
the modulation/demodulation and error correction, but adding a layer that allows for messages
longer than 32 bytes (sending multiple chirp messages for every grillo message).
"""
DATA_LEN = 30
PACKET_DURATION = timedelta(seconds=4.66)
def __init__(self, with_confirmation=False):
self.chirp = ChirpConnect(
key=config.CHIRP_APP_KEY,
secret=config.CHIRP_APP_SECRET,
config=config.CHIRP_APP_CONFIG,
)
self.chirp.start(send=True, receive=True)
self.with_confirmation = with_confirmation
self.reset_chained_status()
def reset_chained_status(self):
"""
Reset the status of the chained message that is being received.
"""
self.chained_total_parts = None
self.chained_parts = {}
def send_message(self, message):
"""
Send a message as multiple packets.
"""
chain_len = self._get_chain_len(len(message))
if chain_len > 255:
raise MessageTooLongException()
packets_to_send = range(chain_len)
while len(packets_to_send) > 0:
self._send_packets(message, packets_to_send, chain_len)
if self.with_confirmation:
packets_to_send = self._get_packets_to_retry()
else:
break
def _get_packets_to_retry(self):
"""
Wait for the other end to inform which parts of a message it didn't receive.
"""
packets_to_retry = []
ack_msg = self.receive_packet(self.PACKET_DURATION * 2)
if ack_msg is None:
return []
header = ack_msg[0]
if header == 0:
packets_to_retry = ack_msg[1:]
return packets_to_retry
else:
raise MessageAckIsBroken()
def _send_packets(self, message, packet_list, chain_len):
"""
Send a message as multiple packets, one after the other.
"""
for i in packet_list:
packet = (bytes([chain_len, i]) +
message[self.DATA_LEN * i:self.DATA_LEN * (i + 1)])
self.send_packet(packet)
def send_packet(self, packet):
"""
Send a single packet.
"""
self.chirp.send(packet, blocking=True)
def send_ack(self, missing_parts=None):
"""
Send a packet informing the missing parts of a chained message.
"""
if missing_parts is None:
missing_parts = []
self.send_packet(bytes([0] + missing_parts))
def _get_chain_len(self, size):
return size // self.DATA_LEN + 1
def receive_packet(self, timeout=None):
"""
Wait (blocking) for a single packet, and return it when received.
"""
receiver = SinglePacketReceiver()
self.chirp.set_callbacks(receiver)
start = datetime.now()
while receiver.packet is None:
time.sleep(0.1)
if timeout:
now = datetime.now()
if now - start > timeout:
break
self.stop_listening()
return receiver.packet
def receive_message(self, timeout=300):
"""
Wait (blocking) for a single message, and return it when received.
"""
self.reset_chained_status()
receiver = SinglePacketReceiver(callback=self.on_chained_part_received)
self.chirp.set_callbacks(receiver)
self.timeout_start = datetime.now()
if timeout:
self.timeout_delta = timedelta(seconds=timeout)
chained_message = None
last_expected_part = None
while chained_message is None:
time.sleep(0.1)
if self.chained_total_parts is not None:
if last_expected_part is None:
last_expected_part = self.chained_total_parts - 1
if last_expected_part in self.chained_parts or self._timeout_expired(
):
# finished receiving all the parts or should have finished and we didn't
missing_parts = self.chained_missing_parts()
if missing_parts:
# we didn't get all the parts, ask for the missing ones
parts_to_resend = missing_parts[:self.DATA_LEN]
last_expected_part = parts_to_resend[-1]
self.send_ack(parts_to_resend)
self._reset_timeout()
else:
# stop the chained building loop, we got all the parts
chained_message = self.chained_combine()
self.send_ack()
break
if timeout and self._timeout_expired():
break
self.stop_listening()
self.reset_chained_status()
return chained_message
def _timeout_expired(self):
now = datetime.now()
return (now - self.timeout_start) > self.timeout_delta
def on_chained_part_received(self, packet):
"""
Executed when chirp receives data that is part of a chained message.
"""
if packet is not None:
total_parts = packet[0]
part_number = packet[1]
message_part = packet[2:]
if self.chained_total_parts is None:
# first part received!
self.chained_total_parts = total_parts
self.chained_parts[part_number] = message_part
self._reset_timeout()
def _reset_timeout(self):
self.timeout_delta = self.PACKET_DURATION * 1.5
self.timeout_start = datetime.now()
def chained_missing_parts(self):
"""
Which parts of the message are missing?
"""
return [
part_number for part_number in range(self.chained_total_parts)
if part_number not in self.chained_parts
]
def chained_combine(self):
"""
Concatenate all the message parts.
"""
return b''.join(self.chained_parts[part_number]
for part_number in range(self.chained_total_parts))
def listen_for_packets(self, callback):
"""
Start listening for packets, calling a callback whenever a packet is received.
"""
receiver = SinglePacketReceiver(callback)
self.chirp.set_callbacks(receiver)
def listen_for_messages(self, callback):
"""
Start listening for messages, calling a callback whenever a packet is received.
"""
while True:
message = self.receive_message()
callback(message)
self.reset_chained_status()
def stop_listening(self):
"""
Stop using chirp to listen for packets.
"""
self.chirp.set_callbacks(NoCallbacks())
from chirpsdk import ChirpConnect, CallbackSet
import chirpsdk
import Consumo
import sys
import time
import RPi.GPIO as GPIO
chirp = ChirpConnect(key="0cDCbED05BdFEACad7A9AeFBD",
secret="14f10FE0c6dD2c9B14DC3a739EAE42AF5E363BD339CfCDEb3B",
config="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");
recebido = False
GPIO.setmode(GPIO.BCM)
vermelho = 26
amarelo = 13
verde = 6
botao = 17
GPIO.setup(botao, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(vermelho, GPIO.OUT)
GPIO.setup(amarelo, GPIO.OUT)
GPIO.setup(verde, GPIO.OUT)
class Callbacks(CallbackSet):
global amarelo
global verde
def on_sent(self, payload, channel):
print(f"mandei : {payload}")
identifier = payload.decode('utf-8')
print(identifier)
def test_not_created(self):
with self.assertRaises(ConnectError):
sdk = ChirpConnect(self.app_key, self.app_secret, '/not/real/path')
self.assertEqual(sdk.state, CHIRP_CONNECT_STATE_NOT_CREATED)
def main(args):
# ------------------------------------------------------------------------
# Initialise the Connect SDK.
# ------------------------------------------------------------------------
sdk = ChirpConnect()
print(sdk.audio.query_devices())
print(str(sdk))
sdk.audio.output_device = args.o
if args.network_config:
sdk.set_config_from_network()
if sdk.protocol_name != '16khz-mono':
raise RuntimeError('Must use the 16khz-mono protocol ' +
'to be compatible with other Chirp Messenger apps.')
# ------------------------------------------------------------------------
# Parse unicode and send as a chirp payload
# ------------------------------------------------------------------------
message = args.message.encode('utf-8')
payload = sdk.new_payload(message)
sdk.volume = args.volume
sdk.set_callbacks(Callbacks())
sdk.start()
sdk.send(payload)
try:
# Process audio streams
while True:
time.sleep(0.1)
except KeyboardInterrupt:
print('Exiting')
sdk.stop()
sdk.close()
class TestConnectSDK(unittest.TestCase):
BUFFER_SIZE = 1024
TEST_PAYLOAD_LENGTH = 3
@classmethod
def setUpClass(cls):
config = configparser.ConfigParser()
config.read(os.path.expanduser('~/.chirprc'))
try:
cls.app_key = config.get('test', 'app_key')
cls.app_secret = config.get('test', 'app_secret')
cls.app_config = config.get('test', 'app_config')
except configparser.NoSectionError:
raise Exception(
"Couldn't find test credentials. Please add a [test] section to your ~/.chirprc."
)
cls.is2 = sys.version[0] == '2'
def setUp(self):
self.sdk = ChirpConnect(self.app_key, self.app_secret, self.app_config)
self.sdk.audio = None
self.async_request = patch(
'requests_futures.sessions.FuturesSession.post')
self.async_patch = self.async_request.start()
self.addCleanup(self.async_request.stop)
self.length = None
self.channel = None
def test_version(self):
version = self.sdk.version
for data in ['name', 'version', 'build']:
self.assertIn(data, version)
self.assertTrue(len(version[data]) > 0)
def test_read_chirprc(self):
self.sdk = ChirpConnect()
self.sdk.read_chirprc('test')
self.assertIsNotNone(self.sdk.config)
# -- Getters & Setters
def test_volume(self):
self.assertEqual(self.sdk.volume, 1.0)
def test_set_volume(self):
self.sdk.volume = 0.33
self.assertEqual(self.sdk.volume, 0.33)
def test_input_sample_rate(self):
self.assertEqual(self.sdk.input_sample_rate, 44100)
def test_output_sample_rate(self):
self.assertEqual(self.sdk.output_sample_rate, 44100)
def test_set_input_sample_rate(self):
self.sdk.input_sample_rate = 48000
self.assertEqual(self.sdk.input_sample_rate, 48000)
with self.assertRaises(ConnectError):
self.sdk.input_sample_rate = 0
def test_set_output_sample_rate(self):
self.sdk.output_sample_rate = 48000
self.assertEqual(self.sdk.output_sample_rate, 48000)
with self.assertRaises(ConnectError):
self.sdk.output_sample_rate = 0
def test_default_state(self):
self.assertEqual(self.sdk.state, CHIRP_CONNECT_STATE_STOPPED)
def test_get_auto_mute(self):
self.assertTrue(self.sdk.auto_mute)
def test_set_auto_mute(self):
self.sdk.auto_mute = False
self.assertFalse(self.sdk.auto_mute)
def test_protocol_name(self):
self.assertEqual(self.sdk.protocol_name, 'standard')
def test_protocol_version(self):
self.assertIsInstance(self.sdk.protocol_version, int)
def test_protocol_duration(self):
self.assertEqual(self.sdk.get_duration(10), 2.04)
def test_expiry(self):
self.assertIsInstance(self.sdk.expiry, datetime)
def test_channel_count(self):
self.assertEqual(self.sdk.channel_count, 1)
def test_transmission_channel(self):
self.assertEqual(self.sdk.transmission_channel, 0)
def test_get_state_for_channel(self):
self.sdk.start()
self.assertEqual(self.sdk.get_state_for_channel(0),
CHIRP_CONNECT_STATE_RUNNING)
payload = self.sdk.random_payload(self.TEST_PAYLOAD_LENGTH)
self.sdk.send(payload)
self.assertEqual(self.sdk.get_state_for_channel(0),
CHIRP_CONNECT_STATE_SENDING)
# -- States
def test_not_created(self):
with self.assertRaises(ConnectError):
sdk = ChirpConnect(self.app_key, self.app_secret, '/not/real/path')
self.assertEqual(sdk.state, CHIRP_CONNECT_STATE_NOT_CREATED)
def test_start(self):
self.sdk.start()
self.assertEqual(self.sdk.state, CHIRP_CONNECT_STATE_RUNNING)
def test_already_started(self):
self.sdk.start()
with self.assertRaises(ConnectError):
self.sdk.start()
def test_pause(self):
self.sdk.start()
self.sdk.pause(True)
self.assertEqual(self.sdk.state, CHIRP_CONNECT_STATE_PAUSED)
def test_unpause(self):
self.sdk.start()
self.sdk.pause(True)
self.sdk.pause(False)
self.assertEqual(self.sdk.state, CHIRP_CONNECT_STATE_RUNNING)
def test_already_paused(self):
with self.assertRaises(ConnectError):
self.sdk.pause(True)
def test_stop(self):
self.sdk.start()
self.sdk.stop()
self.assertEqual(self.sdk.state, CHIRP_CONNECT_STATE_STOPPED)
def test_already_stopped(self):
with self.assertRaises(ConnectError):
self.sdk.stop()
# -- Callbacks
def stub_connect_state_callback(self, old, new):
self.old = old
self.new = new
def stub_connect_callback(self, payload, channel):
self.length = len(payload)
self.channel = channel
def stub_receiving_callback(self, channel):
self.recv = True
self.channel = channel
def test_state_changed_callback(self):
self.sdk.callbacks.on_state_changed = self.stub_connect_state_callback
self.sdk.trigger_callbacks([0, 1, 2, 3, 4])
self.assertIsNotNone(self.old)
self.assertIsNotNone(self.new)
def test_sending_callback(self):
self.sdk.callbacks.on_sending = self.stub_connect_callback
self.sdk.trigger_callbacks([0, 1, 2, 3, 4])
self.assertIsNotNone(self.length)
self.assertIsNotNone(self.channel)
def test_sent_callback(self):
self.sdk.callbacks.on_sent = self.stub_connect_callback
self.sdk.trigger_callbacks([0, 1, 2, 3, 4])
self.assertIsNotNone(self.length)
self.assertIsNotNone(self.channel)
def test_receiving_callback(self):
self.sdk.callbacks.on_receiving = self.stub_receiving_callback
self.sdk.trigger_callbacks([0, 1, 2, 3, 4])
self.assertTrue(self.recv)
self.assertIsNotNone(self.channel)
def test_received_callback(self):
self.sdk.callbacks.on_received = self.stub_connect_callback
self.sdk.trigger_callbacks([0, 1, 2, 3, 4])
self.assertIsNotNone(self.length)
self.assertIsNotNone(self.channel)
# -- Processing
def test_process_input(self):
indata = ar.array('f', [0.025] * self.BUFFER_SIZE)
self.sdk.start()
self.sdk.process_input(
getattr(indata, 'tostring' if self.is2 else 'tobytes')())
def test_process_input_not_started(self):
indata = ar.array('f', [0.025] * self.BUFFER_SIZE)
with self.assertRaises(ConnectError):
self.sdk.process_input(
getattr(indata, 'tostring' if self.is2 else 'tobytes')())
def test_process_output(self):
outdata = ar.array('f', [0.05] * self.BUFFER_SIZE)
self.sdk.start()
self.sdk.process_output(outdata)
def test_process_output_not_started(self):
outdata = ar.array('f', [0.05] * self.BUFFER_SIZE)
with self.assertRaises(ConnectError):
self.sdk.process_output(outdata)
def test_process_shorts_input(self):
indata = ar.array('h', [128] * self.BUFFER_SIZE)
self.sdk.start()
self.sdk.process_shorts_input(
getattr(indata, 'tostring' if self.is2 else 'tobytes')())
def test_process_shorts_output(self):
outdata = ar.array('h', [-128] * self.BUFFER_SIZE)
self.sdk.start()
self.sdk.process_shorts_output(outdata)
# -- Payload
def test_get_max_payload_length(self):
self.assertIsInstance(self.sdk.max_payload_length, int)
self.assertTrue(self.sdk.max_payload_length > 0)
def test_new_payload_string(self):
payload = self.sdk.new_payload('test'.encode())
self.assertIsInstance(payload, bytearray)
def test_new_payload_array(self):
payload = self.sdk.new_payload([64, 27, 33, 27])
self.assertIsInstance(payload, bytearray)
def test_random_payload(self):
payload = self.sdk.random_payload(self.TEST_PAYLOAD_LENGTH)
self.assertIsInstance(payload, bytearray)
for byte in range(0, len(payload)):
self.assertIsInstance(payload[byte], int)
def test_pseudo_random_payload(self):
self.sdk._set_seed(0)
self.assertEqual(
self.sdk.random_payload(0),
[47, 117, 192, 67, 251, 195, 103, 9, 211, 21, 242, 36, 87])
def test_is_valid(self):
payload = self.sdk.random_payload(self.TEST_PAYLOAD_LENGTH)
self.assertTrue(self.sdk.is_valid(payload))
def test_payload_is_valid(self):
payload = self.sdk.random_payload(self.TEST_PAYLOAD_LENGTH)
self.assertTrue(payload.isvalid())
def test_as_string(self):
payload = self.sdk.random_payload(self.TEST_PAYLOAD_LENGTH)
self.assertIsInstance(self.sdk.as_string(payload), str)
def test_payload_as_string(self):
payload = self.sdk.new_payload(b'hello')
self.assertEqual(str(payload), '68656c6c6f')
def test_send(self):
self.sdk.start()
payload = self.sdk.random_payload(self.TEST_PAYLOAD_LENGTH)
self.assertIsNone(self.sdk.send(payload))
def test_null_payload(self):
with self.assertRaises(ValueError):
self.sdk.new_payload([])
def test_payload_too_long(self):
payload = self.sdk.new_payload('hello'.encode('ascii'))
with self.assertRaises(ValueError):
payload.extend('this-is-wayyyyy-toooooo-long')
def main(args):
# ------------------------------------------------------------------------
# Initialise the Connect SDK.
# ------------------------------------------------------------------------
sdk = ChirpConnect()
print(str(sdk))
if args.network_config:
sdk.set_config_from_network()
print('Protocol: {protocol} [v{version}]'.format(
protocol=sdk.protocol_name,
version=sdk.protocol_version))
# ------------------------------------------------------------------------
# Disable audio playback.
# ------------------------------------------------------------------------
sdk.audio = None
sdk.set_callbacks(Callbacks(args))
sdk.start(send=False, receive=True)
w = wave.open(args.infile, 'r')
data = w.readframes(w.getnframes())
sdk.input_sample_rate = w.getframerate()
for f in range(0, len(data), CHIRP_SDK_BUFFER_SIZE):
if w.getsampwidth() == 2:
sdk.process_shorts_input(data[f: f + CHIRP_SDK_BUFFER_SIZE])
elif w.getsampwidth() == 4:
sdk.process_input(data[f: f + CHIRP_SDK_BUFFER_SIZE])
sdk.stop()
class Grillo:
"""
Tool to send data to a different computer or receive it, just using audio and mic.
"""
HEADER_SEPARATOR = b"|"
FILE_NAME_SEPARATOR = b"<NAME>"
def __init__(self, send=False, receive=False):
"""
Return an instance of a chirp thingymagic ready to be used.
"""
self.chirp = ChirpConnect(
key=config.CHIRP_APP_KEY,
secret=config.CHIRP_APP_SECRET,
config=config.CHIRP_APP_CONFIG,
)
self.chirp.set_callbacks(ChirpCallbacks(self))
self.listening = receive
self.chirp.start(send=send, receive=receive)
def send_message(self, kind, payload):
"""
Build a serialized message to send over audio.
"""
message = kind.value.encode(
"utf-8") + Grillo.HEADER_SEPARATOR + payload
if len(message) > 32:
raise MessageTooLongException()
self.chirp.send(message, blocking=True)
def read_message(self, message):
"""
Read a serialized message received over audio.
"""
parts = message.split(Grillo.HEADER_SEPARATOR)
kind = MessageKind(parts[0].decode("utf-8"))
payload = Grillo.HEADER_SEPARATOR.join(parts[1:])
return kind, payload
def send_text(self, text):
"""
Send text via audio.
"""
self.send_message(MessageKind.TEXT, text.encode("utf-8"))
def send_clipboard(self):
"""
Send clipboard contents via audio.
"""
self.send_message(MessageKind.CLIPBOARD,
pyperclip.paste().encode("utf-8"))
def send_file(self, file_path):
"""
Send file contents via audio.
"""
if isinstance(file_path, str):
file_path = Path(file_path)
with file_path.open('rb') as file:
file_contents = file.read()
payload = (file_path.name.encode("utf-8") +
Grillo.FILE_NAME_SEPARATOR + file_contents)
self.send_message(MessageKind.FILE, payload)
def listen(self, forever=False):
"""
Receive whatever data is being sent from the source computer.
"""
while self.listening or forever:
time.sleep(1)
def receive_message(self, message):
"""
Process an incoming message.
"""
kind, payload = self.read_message(message)
if kind == MessageKind.TEXT:
self.receive_text(payload)
elif kind == MessageKind.CLIPBOARD:
self.receive_clipboard(payload)
elif kind == MessageKind.FILE:
self.receive_file(payload)
self.listening = False
def receive_text(self, payload):
"""
Receive text via audio.
"""
text = payload.decode("utf-8")
print("Received text:")
print(text)
def receive_clipboard(self, payload):
"""
Receive clipboard contents via audio.
"""
clipboard_contents = payload.decode("utf-8")
pyperclip.copy(clipboard_contents)
print("Received clipboard contents, copied to your own clipboard :)")
def receive_file(self, payload):
"""
Receive file contents via audio.
"""
parts = payload.split(Grillo.FILE_NAME_SEPARATOR)
name = parts[0].decode("utf-8")
file_contents = Grillo.FILE_NAME_SEPARATOR.join(parts[1:])
file_path = Path(".") / name
copy_counter = 0
while file_path.exists():
copy_counter += 1
file_path = Path(".") / str(copy_counter) + "_" + name
with file_path.open('wb') as file:
file.write(file_contents)
print("Received a file, saved to", str(file_path))
def main(args):
# ------------------------------------------------------------------------
# Initialise the Connect SDK.
# ------------------------------------------------------------------------
sdk = ChirpConnect()
print(str(sdk))
if args.network_config:
sdk.set_config_from_network()
print('Protocol: {protocol} [v{version}]'.format(
protocol=sdk.protocol_name, version=sdk.protocol_version))
# ------------------------------------------------------------------------
# Disable audio playback.
# ------------------------------------------------------------------------
sdk.audio = None
sdk.start(send=True, receive=False)
# ------------------------------------------------------------------------
# Encode payload
# ------------------------------------------------------------------------
if args.unicode:
message = args.unicode.encode('utf-8')
payload = sdk.new_payload(message)
elif args.hex:
message = bytearray.fromhex(args.hex)
payload = sdk.new_payload(message)
else:
payload = sdk.random_payload()
# ------------------------------------------------------------------------
# Set transmission channel
# ------------------------------------------------------------------------
if args.channel:
if args.channel >= sdk.channel_count:
raise ValueError('Channel %d is not available' % args.channel)
sdk.transmission_channel = args.channel
# ------------------------------------------------------------------------
# Process output
# ------------------------------------------------------------------------
output_file = args.outfile if args.outfile else '%s.wav' % payload
w = wave.open(output_file, 'w')
w.setnchannels(1)
w.setsampwidth(2)
w.setframerate(sdk.output_sample_rate)
sdk.send(payload)
while sdk.state == CHIRP_CONNECT_STATE_SENDING:
data = ar.array('h', [0] * CHIRP_SDK_BUFFER_SIZE)
byte_data = bytearray(data.tobytes() if sys.version[0] ==
'3' else data.tostring())
sdk.process_shorts_output(byte_data)
w.writeframes(byte_data)
print('Wrote audio to output: %s' % output_file)
w.close()
sdk.stop()
