def __init__(self, ser):
self._last_angles = np.ndarray
self._last_imu = np.ndarray
# https://www.pieter-jan.com/node/11
self.pitch_acc = 0
self.roll_acc = 0
self.pitch = 0
self.roll = 0
self._tx_thread = Transmitter(name="tx_th", ser=ser)
self._rx_thread = Receiver(name="rx_th", ser=ser)
self._rx_thread.set_timeout(0.010)
self._rx_thread.bind(self.receive_callback)
self._pub_imu = rp.Publisher('imu_raw', Imu, queue_size=1)
self._pub_joint_states = rp.Publisher('joint_states',
JointState,
queue_size=1)
self._motor_map = rp.get_param("~motor_mapping")
self._imu_calibration = rp.get_param("~imu_calibration")
for motor in self._motor_map:
self._motor_map[motor]["subscriber"] = rp.Subscriber(
motor + "/command", Float64, self.trajectory_callback, motor)
self._motor_map[motor]["publisher"] = rp.Publisher(
motor + "/state", JointControllerState, queue_size=1)
self._motor_map[motor]["value"] = 0.0
self._publish_timer = rp.Timer(rp.Duration(nsecs=10000000),
self.send_angles)
def main():
nrx=3
# Create a tx
ntx=3
ta = None
#ta = SampleRate()
transmitter = Transmitter(ntx,ta)
# Create a channel
chan = TraceChan()
num_chans=1
length = chan.create_chan(transmitter.Ntx,nrx)
#ta = OracleRA(chan)
#transmitter.set_transmit_ra(ta)
#receiver = Receiver(MaxTputRA(),nrx)
#receiver = Receiver(MinEngRA(),nrx)
receiver = Receiver(EngTputRA(),nrx)
#receiver = Receiver(EffSnrRA(),nrx)
#receiver = Receiver(RxSampleRate(),nrx)
#receiver = Receiver(RxOracle(),nrx)
#length =10
for num in range(0,length):
pkt = transmitter.transmit_pkt()
chan.apply_channel(pkt)
#print chan.curr_chan
#print pkt
# Create receiver
receiver.receive_pkt(pkt)
ack_pkt = receiver.get_feedback_pkt()
transmitter.process_ack(ack_pkt)
def __init__(self):
mainServerIP = globe.components.mainServerIp
mainServerPort = globe.components.mainServerPort
self.mainServerAddress = 'http://' + mainServerIP + ':' + mainServerPort
# Starting receiver flask server process:
print("Starting the receiver HTTP server...\n")
self.serverThread = threading.Thread(target=initReceiver, args=())
self.serverThread.start()
time.sleep(1)
self.transmitter = Transmitter(self.mainServerAddress)
# Send the content of jsonPath to each devices:
print("\nSending JSON paths to devices...")
archAddress = globe.content[0][:-1]
connMapAddress = globe.content[1][:-1]
data = archAddress + '#' + connMapAddress
for ip in globe.components.devicesIp:
address = f'http://{ip}:8484/updateJsonPath' # f for format
response = requests.post(address, data)
if globe.jupyterFlag == 0:
print(response.ok, response.status_code)
time.sleep(1)
def __init__(self):
self.__transmitter = Transmitter()
self.__configpath = self.__set_configpath()
self.__config = self.__init_config()
self.__default_account = AccountManager.get_default_account()
self.__accounts = []
self.__load_accounts_from_config()
def __init__(self, numOfInputs):
self.transmitter = Transmitter()
self.receiver = Receiver()
self.wirelessChannel = wireless_channel(0.1)
self.numOfInputs = numOfInputs
self.sigmaValues = [10, 1, 0.1]
self.generated_Points = []
self.colors = ['purple', 'yellow', 'orange']
def test_set_transmitter_exactly_once(self):
tt = Transmitter()
url = 'whee.com'
username = '******'
account = Account(url, username, None)
tt.set_account(account)
aa = ElyxerEntry()
aa.set_transmitter(tt)
self.assertRaises(TransmitterAlreadyExistsError, lambda: aa.set_transmitter(tt))
def test_set_transmitter_exactly_once(self):
tt = Transmitter()
url = 'whee.com'
username = '******'
account = Account(url, username, None)
tt.set_account(account)
aa = ElyxerEntry()
aa.set_transmitter(tt)
self.assertRaises(TransmitterAlreadyExistsError,
lambda: aa.set_transmitter(tt))
def main():
if len(sys.argv) == 6:
filename = sys.argv[1]
card_type = sys.argv[2]
energy_constraint = sys.argv[3]
chan_pred = eval(sys.argv[4])
increment = eval(sys.argv[5])
print "filename: " + str(filename)
else:
print "Correct usage: python simulate_maxtput.py trace_file card_type tx/rx pred(True/False)"
sys.exit(1)
nrx = 3
# Create a tx
ntx = 3
ta = None
transmitter = Transmitter(ntx, ta)
# Create a channel
chan = TraceChan(filename)
num_chans = 1
length = chan.create_chan(transmitter.Ntx, nrx)
extname = (
filename.split("/")[-1].split(".")[0]
+ "_"
+ card_type
+ "_"
+ energy_constraint
+ "_pred"
+ str(chan_pred)
+ "_inc"
+ str(increment)
)
# print extname
receiver = PPrReceiver(PPrMinEngRA(card_type, energy_constraint, chan_pred), nrx, extname)
if length > 10000:
length = 10000
# length = 2
for num in range(0, length):
itr_tic = time.clock()
pkt = transmitter.transmit_pkt()
chan.apply_channel(pkt)
# print chan.curr_chan
# print pkt
# Create receiver
receiver.receive_pkt(pkt)
ack_pkt = receiver.get_feedback_pkt()
transmitter.process_ack(ack_pkt)
itr_toc = time.clock()
class Run(object):
def __init__(self):
channel = "/dev/rfcomm8"
self.TR = Transmitter(channel)
self.TR
def main(self):
while True:
#self.TR.sendData("hello")
result = instance.read()
if result.is_valid():
temp = "Temperature: %-3.1f C" % result.temperature
humid = "Humidity: %-3.1f %%" % result.humidity
self.TR.sendData("\n" + temp + '\n' + humid + "\n")
def __init__(self):
self.drive_msg = DriveMessage()
self.check_msg = CheckMessage()
self._bus = can.interface.Bus(bustype='socketcan', channel='can0')
self.transmitter = Transmitter(self._bus)
self.receiver = Receiver(self._bus, self.update)
self.data = CarData()
self.last_update = time.time()
self.notifier = can.Notifier(self._bus, [self.receiver])
self.controller = PIController(proportional=0.05, integral=0.1)
gpsd.connect()
self.send_messages()
def __init__(self):
self.__transmitter = Transmitter()
self.__configpath = self.__set_configpath()
self.__config = self.__init_config()
self.__default_account = AccountManager.get_default_account()
self.__accounts = []
self.__load_accounts_from_config()
def clicked_btn():
string = r'(25[0-5]|2[0-4][0-9]|[0]|[1]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[0]|[1]?[0-9][0-9]?)){3}'
ip = IP_entry.get()
port = int(port_spin.get())
buff_size = int(Buff_size_spin.get())
file_name = open_file_entry.get()
Prog_bar_w.configure(maximum=os.path.getsize(file_name) // buff_size)
if re.fullmatch(string, ip) and 10000 < int(port) < 65535 and 100 <= int(buff_size) <= 8958 and file_name:
sender = Transmitter(ip, file_name, buff_size, port)
t = Thread(target=sender.send, args=(queue,))
txt.insert("insert",
'Sending {} to {} at port {}, UDP data size - {}'.format(os.path.basename(file_name), ip, port,
buff_size) + '\n')
txt.yview('end')
try:
t.start()
check_queue()
except ConnectionRefusedError:
txt.insert("insert", "Error" + '\n')
txt.insert("insert", "-" * 70 + '\n')
txt.yview('end')
messagebox.showinfo("Ошибка", "Удаленный компьютер не отвечает")
Prog_bar_w.stop()
Prog_bar_w["value"] = 0
else:
txt.insert("insert", "Done" + '\n')
txt.insert("insert", "-" * 70 + '\n')
txt.yview('end')
open_file_entry.delete(0, 'end')
Prog_bar_w.stop()
Prog_bar_w["value"] = 0
else:
messagebox.showinfo("Ошибка", "Некоректные данные сетевого соединения или не выбран файл")
def main():
if sys.argv[1] == 'leap_motion':
motion_capturer = MotionCapturerLeapMotion()
elif sys.argv[1] == 'mouse':
motion_capturer = MotionCapturerMouse()
elif sys.argv[1] == 'mix':
motion_capturer = MotionCapturerLeapAndMouse()
transmitter = Transmitter(sys.argv[2])
while True:
try:
(pitch, roll, yaw, throttle) = motion_capturer.get_axis_values()
transmitter.send_axis_values(pitch, roll, yaw, throttle)
except ValueError:
print('Ignoring frame')
except KeyboardInterrupt:
motion_capturer.shutdown()
def __init__(self, daemon = False):
self.__loggingLock = Lock()
self.__lock = RLock()
self.__jails = Jails()
self.__daemon = daemon
self.__transm = Transmitter(self)
self.__asyncServer = AsyncServer(self.__transm)
self.__logLevel = None
self.__logTarget = None
# Set logging level
self.setLogLevel(3)
self.setLogTarget("STDOUT")
def main():
if len(sys.argv) == 7:
filename = sys.argv[1]
card_type = sys.argv[2]
energy_constraint = sys.argv[3]
chan_pred = eval(sys.argv[4])
threshold = eval(sys.argv[5])
increment = eval(sys.argv[6])
print "filename: "+str(filename)
else:
print "Correct usage: python simulate_engtput.py trace_file card_type tx/rx pred(True/False) threshold chan_increment"
sys.exit(1)
nrx=3
# Create a tx
ntx=3
ta = None
transmitter = Transmitter(ntx,ta)
# Create a channel
chan = TraceChan(filename, increment)
length = chan.create_chan(transmitter.Ntx,nrx)
extname=filename.split('/')[-1].split('.')[0]+"_"+card_type+"_"+energy_constraint+"_pred"+str(chan_pred)+"th"+str(threshold)+"_inc"+str(increment)
receiver = Receiver(EngTputRA(card_type,energy_constraint,chan_pred,threshold),nrx,extname)
if length > 10000: length = 10000
for num in range(0,length):
pkt = transmitter.transmit_pkt()
chan.apply_channel(pkt)
#print chan.curr_chan
#print pkt
# Create receiver
receiver.receive_pkt(pkt)
ack_pkt = receiver.get_feedback_pkt()
transmitter.process_ack(ack_pkt)
def __init__(self, midi_in, midi_out, loopback, modes):
self.midi_in = midi_in
self.led_control = Transmitter(midi_out)
self.transmitter = Transmitter(loopback)
self.active_mode = None
self.active_bank = 0
self.button_state = [False] * 12
self.detune = 0
self.octave = [0, 0]
self.split_zone = 0
self.black_key_indices = [
1, 3, 6, 8, 10,
]
self.modes = modes
for mode in self.modes:
mode.register(self)
# set initial mode on start
self.set_mode(0)
print('Ready!')
def test_upload_entry(self):
tt = Transmitter()
tt.set_account(self.account_with_good_password)
filename = 'test_files/entry_test'
entry = ElyxerEntry()
entry.set_transmitter(tt)
entry.load(filename)
entry.set_title('WoooYAH!')
tt.publish_entry(entry)
def main():
if len(sys.argv) == 5:
filename = sys.argv[1]
card_type = sys.argv[2]
energy_constraint = sys.argv[3]
chan_pred = eval(sys.argv[4])
print "filename: "+str(filename)
else:
print "Correct usage: python simulate_effsnr.py trace_file card_type tx/rx pred(True/False)"
sys.exit(1)
nrx=3
# Create a tx
ntx=3
ta = None
transmitter = Transmitter(ntx,ta)
# Create a channel
chan = TraceChan(filename)
num_chans=1
length = chan.create_chan(transmitter.Ntx,nrx)
extname=filename.split('/')[-1].split('.')[0]+"_"+card_type+"_"+energy_constraint+"_pred"+str(chan_pred)
receiver = Receiver(EffSnrRAEng(card_type,energy_constraint,chan_pred),nrx,extname)
for num in range(0,length):
pkt = transmitter.transmit_pkt()
chan.apply_channel(pkt)
#print chan.curr_chan
#print pkt
# Create receiver
receiver.receive_pkt(pkt)
ack_pkt = receiver.get_feedback_pkt()
transmitter.process_ack(ack_pkt)
def test_publish_image(self):
Image.set_abs_reference_dir_from_html_file(self.filename)
account = AccountManager.get_default_account()
tt = Transmitter()
tt.set_account(account)
image = Image("some <img src='Suzanne.jpg' /> string")
before = image.get_remote_src()
self.assertEqual(before, None)
tt.publish_image(image)
after = image.get_remote_src()
self.assertNotEqual(after, None)
def main():
if len(sys.argv) == 5:
filename = sys.argv[1]
card_type = sys.argv[2]
energy_constraint = sys.argv[3]
chan_pred = False
increment = 1
print "filename: "+str(filename)
elif len(sys.argv) == 6:
filename = sys.argv[1]
card_type = sys.argv[2]
energy_constraint = sys.argv[3]
chan_pred = False
increment = eval(sys.argv[5])
print "filename: "+str(filename)
else:
print "Correct usage: python simulate_effsnr.py trace_file card_type tx/rx pred(True/False) chan_increment"
sys.exit(1)
nrx=3
# Create a tx
ntx=3
ta = None
transmitter = Transmitter(ntx,ta)
# Create a channel
chan = TraceChan(filename,increment)
length = chan.create_chan(transmitter.Ntx,nrx)
ta = OraclePPrMaxTputRA(card_type,energy_constraint,chan)
transmitter.set_transmit_ra(ta)
extname=ta.name+"_"+filename.split('/')[-1].split('.')[0]+"_"+card_type+"_"+energy_constraint+"_pred"+str(chan_pred)+"_inc"+str(increment)
receiver = PPrReceiver(RxOracle(card_type,energy_constraint),nrx,extname)
if length > 10000: length = 10000
#length =10
for num in range(0,length):
pkt = transmitter.transmit_pkt()
chan.apply_channel(pkt)
#print chan.curr_chan
#print pkt
# Create receiver
receiver.receive_pkt(pkt)
ack_pkt = receiver.get_feedback_pkt()
transmitter.process_ack(ack_pkt)
)
nodes.append(node)
print(node)
################################################################################
#Determine which node will be the transmitter for the simulation
################################################################################
#boundary check the transmit node index
tx_node = config['tx_node']
if tx_node<1: #choose a random transmit node
tx_node = random.randint(1,config['nodes'])
print("Randomly Chose Node %d as the transmitter" % tx_node)
tx_index=min(tx_node, config['nodes'])
tx_index=max(tx_index, 1)
tx_node = nodes[tx_index-1]
transmitter = Transmitter(port=tx_node.phy_port)
################################################################################
#Save all settings complied from defaults, test specific json and command line args as "last_run.json"
################################################################################
with open("last_run.json", 'w') as f:
json.dump(config, f, indent=2)
################################################################################
#Write a spice file with the system setup
################################################################################
with open("cable.p", 'w') as cable:
cable.write("*lumped transmission line model with %d segments per meter at %d meters\n"\
% (config['segments_per_meter'], config['length']))
cable.write("*and a %f meter long cable\n" % config['length'])
class D3MDevice:
def __init__(self, midi_in, midi_out, loopback, modes):
self.midi_in = midi_in
self.led_control = Transmitter(midi_out)
self.transmitter = Transmitter(loopback)
self.active_mode = None
self.active_bank = 0
self.button_state = [False] * 12
self.detune = 0
self.octave = [0, 0]
self.split_zone = 0
self.black_key_indices = [
1, 3, 6, 8, 10,
]
self.modes = modes
for mode in self.modes:
mode.register(self)
# set initial mode on start
self.set_mode(0)
print('Ready!')
def update(self):
message = self.midi_in.get_message()
if message is None:
return
command = message[0][0]
note = message[0][1]
velocity = message[0][2]
# undefined command, send to both channels
if command != NOTE_ON:
self.transmitter.send(command, note, velocity, SPLIT_LEFT)
self.transmitter.send(command, note, velocity, SPLIT_RIGHT)
return
# check if keybed is pressed
if note >= 36 and note <= 96:
# adjust velocity
if (note % 12) in self.black_key_indices and velocity > 0:
velocity -= (int)(math.log(velocity) * 2)
velocity = max(velocity, 0)
# select output channel
zone = ((note - 36) / 12) % NUM_SPLIT_ZONES
# detune note
note += self.detune
# select zone
if zone >= self.split_zone:
note += self.octave[SPLIT_RIGHT] * 12
self.transmitter.send(NOTE_ON, note, velocity, SPLIT_RIGHT)
else:
note += self.octave[SPLIT_LEFT] * 12
self.transmitter.send(NOTE_ON, note, velocity, SPLIT_LEFT)
# check preset buttons
elif note >= 0 and note < 12:
if not self.button_state[note] and velocity == 127:
self.active_mode.on_preset_pressed(note)
elif self.button_state[note] and velocity == 0:
self.active_mode.on_preset_released(note)
# check preset banks
elif note >= 14 and note < 24 and velocity == 127:
bank_index = note - 14
if bank_index != self.active_bank:
self.set_mode(bank_index)
self.active_bank = bank_index
def cc_send_on(self, note):
self.transmitter.send(NOTE_ON, note, 127, CONTROL_CHANNEL)
def cc_send_off(self, note):
self.transmitter.send(NOTE_OFF, note, 127, CONTROL_CHANNEL)
def toggle_light(self, number, state = True):
self.led_control.send(NOTE_ON, number, 127 if state else 0)
self.button_state[number] = state
def clear_lights(self):
for i in range(12):
self.toggle_light(i, False)
def set_mode(self, bank_index):
# set bank lights
for i in range(10):
self.led_control.send(NOTE_ON, i + 14, 0)
self.led_control.send(NOTE_ON, bank_index + 14, 127)
if self.modes[bank_index] is not self.active_mode:
self.clear_lights()
self.active_mode = self.modes[bank_index]
self.active_mode.on_enter()
def close(self):
self.clear_lights()
for i in range(10):
self.led_control.send(NOTE_ON, i + 14, 0)
class Car:
def __init__(self):
self.drive_msg = DriveMessage()
self.check_msg = CheckMessage()
self._bus = can.interface.Bus(bustype='socketcan', channel='can0')
self.transmitter = Transmitter(self._bus)
self.receiver = Receiver(self._bus, self.update)
self.data = CarData()
self.last_update = time.time()
self.notifier = can.Notifier(self._bus, [self.receiver])
self.controller = PIController(proportional=0.05, integral=0.1)
gpsd.connect()
self.send_messages()
def update(self, data: CarData):
self.last_update = time.time()
self.data = data
if self.tx_check(data.rx_check):
self.periodic_update()
else:
self.send_messages()
def can_error(self):
self.check_msg.invalid_message_received()
self.send_messages()
@property
def is_outdated(self):
return time.time() - self.last_update > 1.0
@property
def is_ok(self):
return self.data.has_control and not self.is_outdated
def periodic_update(self):
self.increment_msg_counts()
self.update_from_controller()
self.send_messages()
self.clear_errors()
def increment_msg_counts(self) -> None:
self.drive_msg.increment_msg_count()
self.check_msg.increment_msg_count()
def update_from_controller(self) -> None:
self.drive_msg.velocity = Driving.to_can(
self.controller.update(self.velocity))
def clear_errors(self) -> None:
self.check_msg.clear_errors()
def send_messages(self):
if self.drive_msg is not None:
self.transmitter.transmit(self.drive_msg)
if self.check_msg is not None:
self.transmitter.transmit(self.check_msg)
def drive(self, v: float, s: float) -> None:
print(f'Setting velocity {Driving.to_can(int(v))}')
self.drive_msg.velocity = Driving.to_can(int(v))
print(f'Setting steering {Steering.to_can(int(s))}')
self.drive_msg.steering = Steering.to_can(int(s))
def release_control(self) -> None:
self.drive_msg.ctrl = 0
def shutdown(self) -> None:
self.release_control()
self.periodic_update()
time.sleep(0.2)
self.transmitter.shutdown()
time.sleep(0.2)
self._bus.shutdown()
def tx_check(self, rx_check: int) -> bool:
if rx_check > self.check_msg.tx_check or self.check_msg.tx_check == 255:
self.check_msg.set_tx_check(rx_check)
return True
return False
@property
def velocity(self) -> float:
return self.data.velocity
@velocity.setter
def velocity(self, velocity: Union[int, float]) -> None:
self.controller.target = velocity
# self.drive_msg.velocity = Driving.to_can(int(velocity))
@property
def steering_angle(self) -> float:
return self.data.steering_angle
@steering_angle.setter
def steering_angle(self, steering: Union[int, float]) -> None:
self.drive_msg.steering = Steering.to_can(int(steering))
@property
def ebrake(self) -> bool:
return self.check_msg.stop
@ebrake.setter
def ebrake(self, enabled: bool) -> None:
self.check_msg.stop = enabled
@property
def gps_position(self):
return gpsd.get_current().position()
def _send_code(code):
pi = pigpio.pi()
tx = Transmitter(pi, PIN)
tx.send(code)
time.sleep(1)
tx.cancel()
class Server:
def __init__(self):
self.message = bytes(0)
self.transmitter = Transmitter(SERIAL)
self.location = 'imgs/foto_nova.png'
def set_location(self):
# name = input('SPECIFY NAME TO SAVE FILE WITHOUT EXTENSION: ')
name = 'foto_new2'
while len(name) < 1:
print('INVALID FILE NAME')
name = input('SPECIFY NAME TO SAVE FILE WITHOUT EXTENSION: ')
self.location = 'imgs/{}.png'.format(name)
def send_confirmation(self):
packet = Datagram()
packet.set_head(
message_type=3,
message_id=1,
num_payloads=0,
payload_index=0,
payload_size=0,
error_type=0,
restart_index=0
)
packet.set_EOP()
self.transmitter.send(packet.get_datagram())
def confirm_handshake(self):
handshake_received = self.transmitter.receive(expected_type='handshake')
print(handshake_received)
while not handshake_received:
print('HANDSHAKE NOT SENT BY CLIENT - LISTENING ON SERIAL PORT {}'.format(SERIAL))
handshake_received = self.transmitter.receive(expected_type='handshake')
print('HANDSHAKE RECEIVED')
self.send_confirmation()
print('HANDSHAKE CONFIRMED')
def send_error(self):
packet = Datagram()
packet.set_head(
message_type=0,
message_id=1,
num_payloads=0,
payload_index=0,
payload_size=0,
error_type=0,
restart_index=0
)
packet.set_EOP()
self.transmitter.send(packet.get_datagram())
def receive_packet(self):
response = self.transmitter.receive(expected_type='data')
if not response:
return 0
return response # response => tuple(payload, payload_index, num_packets)
def receive_message(self):
buffer = bytes()
last_payload = 0
while True:
response = self.receive_packet()
if not response:
print('ENCOUNTERED ERROR RECEIVING DATA')
self.send_error()
break
(payload, payload_index, num_packets) = response
if payload_index != last_payload + 1:
print('PAYLOAD OUT OF ORDER')
self.send_error()
break
last_payload = payload_index
buffer += payload
self.send_confirmation()
print('\n\n\n')
print(buffer)
print(payload_index, num_packets)
print('\n\n\n')
if payload_index == num_packets:
break
with open(self.location, 'wb') as f:
f.write(buffer)
def disable(self):
self.transmitter.disable()
def __init__(self): self.message = bytes(0) self.transmitter = Transmitter(SERIAL) self.location = 'imgs/foto_nova.png'
# Print option summary:
print 'Parameters in experiment:'
print '\tSamples per bit:', opt.spb
print '\tChannel type:', ('Audio' if not opt.bypass else 'Bypass')
if opt.bypass:
print '\t Noise:', opt.noise, ' lag:', opt.lag, 'h: [', opt.h, ']'
print '\tFrequency:', fc, 'Hz'
print '\tHamming code n :', opt.cc_len
########################################################
#instantiate and run the source block
src = Source(opt.monotone, opt.fname)
src_payload, databits = src.process()
# instantiate and run the transmitter block
xmitter = Transmitter(fc, opt.samplerate, opt.one, opt.spb, opt.silence, opt.cc_len)
coded_bits = xmitter.encode(databits)
coded_bits_with_preamble = xmitter.add_preamble(coded_bits)
samples = xmitter.bits_to_samples(coded_bits_with_preamble)
mod_samples = xmitter.modulate(samples)
####################################
# create channel instance
if opt.bypass:
h = [float(x) for x in opt.h.split(' ')]
channel = bch.BypassChannel(opt.noise, opt.lag, h)
else:
channel = ach.AudioChannel(opt.samplerate, opt.chunksize, opt.prefill)
# transmit the samples, and retrieve samples back from the channel
try:
def start():
get_arguments()
# Transmitter.transmit returns the new size of a block
new_block_size = Transmitter.transmit(parameter_dict[K], parameter_dict[F])
# for T trials, repeat the simulation
for i in range(parameter_dict[T]):
# clear this trial's variables
trials_time = 0
trials_received_frames = 0
trials_failed_frames = 0
# Set the first seed for the simulation
Simulator.set_seed(parameter_dict[TSeeds][i])
while (trials_time <= parameter_dict[R]):
trials_received_blocks = 0 # new frame
trials_failed_blocks = 0 # new frame
# set the number of blocks to be transmitted in this frame
transmissions = parameter_dict[K]
if (parameter_dict[K] == 0):
transmissions = 1
# For K blocks (or 1 if K == 0), simulate the transmission
for j in range(transmissions): # range starts at 0
# frame_failure = 0 if block was transmitted successfully
block_failure = handle_block(new_block_size, parameter_dict[E],
parameter_dict[K])
# record block success or failure
if (block_failure > 0):
trials_failed_blocks += 1
else:
trials_received_blocks += 1
# set trials_time to number of bits and response overhead
trials_time += (parameter_dict[F] +
(parameter_dict[K] * Transmitter.r) +
parameter_dict[A])
# update number of transmitted frames
Statistics.update(Statistics.total_frames)
# frame failed, resend the frame
if (trials_failed_blocks >= 1):
trials_failed_frames += 1
# the last frame being sent (no longer needed) see forums
#elif(trials_time > parameter_dict[R]):
# pass
# successful transmition
else:
Statistics.update(Statistics.correctly_received_frames)
trials_received_frames += 1
#a print("Trial number:", i)
#a print("Received Frames", trials_received_frames)
#a print("Failed Frames", trials_failed_frames)
# Assume: Take all K*(F+r) trials_time units into account
# even if in last frame
Statistics.append(
Statistics.throughput_averages,
((parameter_dict[F] * trials_received_frames) / trials_time))
if (trials_received_frames != 0):
# Assume: Take all frames into account, even last frame
Statistics.append(Statistics.frame_averages,
(trials_received_frames + trials_failed_frames) /
trials_received_frames)
else:
Statistics.append(Statistics.frame_averages, 0)
# Add to total time
Statistics.statistics_dict[Statistics.total_time] += trials_time
# Call Print Statements
#a print()
#a print("----------------------------------------------")
print_input(sys.argv)
Statistics.set_final_values(parameter_dict[F], parameter_dict[R])
Statistics.print_frame_ci()
Statistics.print_throughput_ci()
G_0 = np.array(
[[(receivers[0].x - tran.x) / r1 - (receivers[1].x - tran.x) / r2,
(receivers[0].y - tran.y) / r1 - (receivers[1].y - tran.y) / r2],
[(receivers[0].x - tran.x) / r1 - (receivers[2].x - tran.x) / r3,
(receivers[0].y - tran.y) / r1 - (receivers[2].y - tran.y) / r3]])
Q_pinv = np.linalg.pinv(Q)
crlb = np.linalg.pinv(G_0.transpose() @ Q_pinv @ G_0)
return crlb
if __name__ == '__main__':
transmitter = Transmitter([0, 0])
crlbs = []
for loc in range(5000, 1000, -100):
receiver1 = Receiver([-loc, loc], is_center=True)
receiver2 = Receiver([loc, loc], is_center=False)
receiver3 = Receiver([loc, -loc], is_center=False)
receivers = [receiver1, receiver2, receiver3]
crlb = CRLB(receivers, transmitter)
crlbs.append(np.sqrt(np.trace(crlb) / crlb.shape[0]))
print(crlbs)
plt.plot(crlbs)
plt.show()
from flask import Flask
from flask import render_template
from flask import redirect
from transmitter import Transmitter
from config import Config
app = Flask(__name__)
config = Config()
transmitter = Transmitter(config)
@app.route('/')
def index_pimator():
return render_template('index.html',
codes=config.codes,
application_prefix=config.application_prefix)
@app.route('/outlet/<string:outlet>/<string:state>', methods=['POST'])
def apply_state_to_one_outlet(outlet, state):
transmitter.apply_state_to_one_outlet(outlet, state)
return redirect(config.application_prefix, code=302)
@app.route('/outlet/all/<string:state>', methods=['POST'])
def apply_state_to_all_outlets(state):
transmitter.apply_state_to_all_outlets(state)
return redirect(config.application_prefix, code=302)
# if __name__ == "__main__":
# app.run(debug=True, host="0.0.0.0")
#WARNING 'sagemath' required for linear_code.py to run.Run as 'sage main.py'
from sys import argv
from transmitter import Transmitter
from receiver import Receiver
from linear_code import LC
from random import randint
transmitter = Transmitter()
receiver = Receiver()
try:
if (len(argv) > 1):
filename = argv[1]
else:
filename = raw_input("Insert file name: ")
try:
P = list(
input(
"\n(Press ENTER to use a default [12, 3] linear code option)\nInsert P matrix as list of lists(rows): "
))
except SyntaxError:
P = [[0, 1, 1, 1, 0, 1, 0, 1, 0], [0, 0, 0, 1, 1, 1, 0, 1, 0],
[1, 1, 0, 0, 0, 0, 0, 1, 1]]
print(
"Warning: Current code can correct up to {} errors per word!\n".format(
LC.getErrorCorrectingCapability(P)))
maxNoise = int(raw_input("Insert max noise per word: "))
def test_check_credentials_bogus(self):
tt = Transmitter()
tt.set_account(self.bogus_account)
self.assertEquals(tt.check_credentials(), 'host not found')
def runner():
parser = argparse.ArgumentParser()
parser.add_argument(
"process",
help="select whether the module acts as (t)ransmitter or (r)eceiver")
parser.add_argument("-d",
"--debug",
help="turn on extra logging level",
action="store_true")
args = parser.parse_args()
if args.debug:
logging.basicConfig(
stream=sys.stdout,
filemode="a",
format=
"%(asctime)s - %(module)-12s - %(levelname)-8s - %(message)s",
datefmt="%d-%m-%Y %H:%M:%S",
level=logging.DEBUG)
logging.debug("Logging level set to DEBUG")
else:
# filename="/share/log.txt"
logging.basicConfig(
stream=sys.stdout,
filemode="a",
format=
"%(asctime)s - %(module)-12s - %(levelname)-8s - %(message)s",
datefmt="%d-%m-%Y %H:%M:%S",
level=logging.INFO)
if args.process == 't' or args.process == 'T':
role = Role.transmitter
logging.debug("Module acting as transmitter")
elif args.process == 'r' or args.process == 'R':
role = Role.receiver
logging.debug("Module acting as receiver")
else:
print("Cannot parse the argument, use either 't/T' or 'r/R'")
sys.exit(-1)
if role == Role.receiver:
lora = Receiver(verbose=False)
try:
print(lora)
lora.start()
except KeyboardInterrupt:
sys.stdout.flush()
sys.stderr.write("KeyboardInterrupt\n")
finally:
lora.stop()
sys.stdout.flush()
logging.debug("Exiting the program")
elif role == Role.transmitter:
lora = Transmitter(verbose=False)
print(lora)
lora.start()
logging.debug("Stopping transmitter.")
lora.stop()
class ApiServer():
def __init__(self):
mainServerIP = globe.components.mainServerIp
mainServerPort = globe.components.mainServerPort
self.mainServerAddress = 'http://' + mainServerIP + ':' + mainServerPort
# Starting receiver flask server process:
print("Starting the receiver HTTP server...\n")
self.serverThread = threading.Thread(target=initReceiver, args=())
self.serverThread.start()
time.sleep(1)
self.transmitter = Transmitter(self.mainServerAddress)
# Send the content of jsonPath to each devices:
print("\nSending JSON paths to devices...")
archAddress = globe.content[0][:-1]
connMapAddress = globe.content[1][:-1]
data = archAddress + '#' + connMapAddress
for ip in globe.components.devicesIp:
address = f'http://{ip}:8484/updateJsonPath' # f for format
response = requests.post(address, data)
if globe.jupyterFlag == 0:
print(response.ok, response.status_code)
time.sleep(1)
def getWorkersList(self):
return globe.components.toString('w')
def getRoutersList(self):
return globe.components.toString('r')
def getSourcesList(self):
return globe.components.toString('s')
def getTransmitter(self):
return self.transmitter
def stopServer(self):
receiver.stop()
return True
def getQueueData(self):
received = False
while not received:
if not multiProcQueue.empty():
print("~New result has been created successfully~")
multiProcQueue.get() # Get the new result out of the queue
received = True
time.sleep(0.1)
def train(self):
self.transmitter.train()
self.getQueueData()
print('Training - Finished\n')
return globe.trainResults[-1]
def predict(self):
self.transmitter.predict()
self.getQueueData()
print('Prediction - Finished\n')
return globe.predictResults[-1]
def statistics(self):
self.transmitter.statistics()
from transmitter import Transmitter
from receiver import Receiver
import atexit
SEND_ADDRESS = "c"
RECEIVE_ADDRESS = "c"
MINIMUM_BLINK_TIME = 1000
if __name__ == '__main__':
transmitter = Transmitter(minimum_blink_time = MINIMUM_BLINK_TIME, send_address = SEND_ADDRESS)
receiver = Receiver(transmitter, minimum_blink_time = MINIMUM_BLINK_TIME, address = RECEIVE_ADDRESS)
def cleanup():
transmitter.cleanup()
receiver.cleanup()
GPIO.cleanup()
atexit.register(cleanup)
while True:
message = input("message: ")
transmitter.send(message)
def start():
get_arguments()
# Transmitter.transmit returns the new size of a block
new_block_size = Transmitter.transmit(parameter_dict[K],
parameter_dict[F])
# for T trials, repeat the simulation
for i in range(parameter_dict[T]):
# clear this trial's variables
trials_time = 0
trials_received_frames = 0
trials_failed_frames = 0
# Set the first seed for the simulation
Simulator.set_seed(parameter_dict[TSeeds][i])
while (trials_time <= parameter_dict[R]):
trials_received_blocks = 0 # new frame
trials_failed_blocks = 0 # new frame
# set the number of blocks to be transmitted in this frame
transmissions = parameter_dict[K]
if (parameter_dict[K] == 0):
transmissions = 1
# For K blocks (or 1 if K == 0), simulate the transmission
for j in range(transmissions): # range starts at 0
# frame_failure = 0 if block was transmitted successfully
block_failure = handle_block(new_block_size,
parameter_dict[E],
parameter_dict[K])
# record block success or failure
if (block_failure > 0):
trials_failed_blocks += 1
else:
trials_received_blocks += 1
# set trials_time to number of bits and response overhead
trials_time += (parameter_dict[F] +
(parameter_dict[K] * Transmitter.r)
+ parameter_dict[A])
# update number of transmitted frames
Statistics.update(Statistics.total_frames)
# frame failed, resend the frame
if(trials_failed_blocks >= 1):
trials_failed_frames += 1
# the last frame being sent (no longer needed) see forums
#elif(trials_time > parameter_dict[R]):
# pass
# successful transmition
else:
Statistics.update(Statistics.correctly_received_frames)
trials_received_frames += 1
#a print("Trial number:", i)
#a print("Received Frames", trials_received_frames)
#a print("Failed Frames", trials_failed_frames)
# Assume: Take all K*(F+r) trials_time units into account
# even if in last frame
Statistics.append(Statistics.throughput_averages,
((parameter_dict[F] * trials_received_frames)
/ trials_time))
if(trials_received_frames != 0):
# Assume: Take all frames into account, even last frame
Statistics.append(Statistics.frame_averages,
(trials_received_frames + trials_failed_frames) /
trials_received_frames)
else:
Statistics.append(Statistics.frame_averages, 0)
# Add to total time
Statistics.statistics_dict[Statistics.total_time] += trials_time
# Call Print Statements
#a print()
#a print("----------------------------------------------")
print_input(sys.argv)
Statistics.set_final_values(parameter_dict[F], parameter_dict[R])
Statistics.print_frame_ci()
Statistics.print_throughput_ci()
import RPi.GPIO as GPIO
import dht11
import time
import datetime
from transmitter import Transmitter
# initialize GPIO
GPIO.setwarnings(True)
GPIO.setmode(GPIO.BCM)
# read data using pin 17
instance = dht11.DHT11(pin=17)
if __name__ == '__main__':
channel = "/dev/rfcomm8"
TR = Transmitter(channel)
TR
while True:
result = instance.read()
#print("waiting")
if result.is_valid():
date = "Last valid input: " + str(datetime.datetime.now())
temp = "Temperature: %-3.1f C" % result.temperature
humid = "Humidity: %-3.1f %%" % result.humidity
TR.sendData(temp + "\n")
TR.sendData(humid + "\n")
from collector import Ping
from transmitter import Transmitter
output_queue = None
def enqueue_output(data):
""" Accepts a dictionary containg send_time and replies[] """
output_queue.put(data)
print("enqueued output")
def dequeue_output():
""" Pops a dictionary from the output queue """
return output_queue.get()
def collector_run():
hosts = ('192.168.5.5', '192.168.5.18', '8.8.8.8', 'ucla.edu')
pinger = Ping(hosts, enqueue_output)
pinger.run()
if __name__ == '__main__':
output_queue = queue.Queue()
collector_thread = threading.Thread(target=collector_run, name="collector")
recorder_url = 'ws://localhost:8765/'
transmitter = Transmitter(dequeue_output, recorder_url)
collector_thread.start()
transmitter.start()
else:
logging.debug("MC running NOT on RPi")
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED, GPIO.OUT) # status LED
GPIO.output(LED, GPIO.HIGH) # switch on to indicate software startup
GPIO.setup(RELEASE, GPIO.OUT) # release pin
GPIO.output(RELEASE, GPIO.LOW) # disable release
GPIO.setup(RELEASE_FB, GPIO.IN) # release feedback pin
GPIO.setup(HEADSHOT, GPIO.OUT) # set shutoff to output
GPIO.output(HEADSHOT, GPIO.LOW) # disable shutoff
GPIO.setup(CAMERA, GPIO.OUT) # set cam power to output
GPIO.output(CAMERA, GPIO.HIGH) # enable camera power
# setup the transmitter thread
txthread = Transmitter()
txthread.setDaemon(True)
txthread.start()
# setup the GPS-listener thread
gpsthread = GPSListener()
gpsthread.setDaemon(True)
gpsthread.start()
# wait for at least a 2D-Fix from the GPS
while GPSListener.fix < 2:
pass
logging.info("MC GPS fix OK")
# indicate GPS fix on LED
for i in range(1,15):
# Print option summary:
print 'Parameters in experiment:'
print '\tSamples per bit:', opt.spb
print '\tChannel type:', ('Audio' if not opt.bypass else 'Bypass')
if opt.bypass:
print '\t Noise:', opt.noise, ' lag:', opt.lag, 'h: [', opt.h, ']'
print '\tFrequency:', fc, 'Hz'
print '\tHamming code n :', opt.cc_len
########################################################
#instantiate and run the source block
src = Source(opt.monotone, opt.fname)
src_payload, databits = src.process()
# instantiate and run the transmitter block
xmitter = Transmitter(fc, opt.samplerate, opt.one, opt.spb, opt.silence, opt.cc_len)
coded_bits = xmitter.encode(databits)
coded_bits_with_preamble = xmitter.add_preamble(coded_bits)
samples = xmitter.bits_to_samples(coded_bits_with_preamble)
mod_samples = xmitter.modulate(samples)
####################################
# create channel instance
if opt.bypass:
h = [float(x) for x in opt.h.split(' ')]
channel = bch.BypassChannel(opt.noise, opt.lag, h)
else:
channel = ach.AudioChannel(opt.samplerate, opt.chunksize, opt.prefill)
# transmit the samples, and retrieve samples back from the channel
try:
# Print option summary:
print 'Parameters in experiment:'
print '\tSamples per bit:', opt.spb
print '\tChannel type:', ('Audio' if not opt.bypass else 'Bypass')
if opt.bypass:
print '\t Noise:', opt.noise, ' lag:', opt.lag, 'h: [', opt.h, ']'
print '\tFrequency:', fc, 'Hz'
########################################################
#instantiate and run the source block
src = Source(opt.monotone, opt.fname)
src_payload, databits = src.process()
# instantiate and run the transmitter block
xmitter = Transmitter(fc, opt.samplerate, opt.one, opt.spb, opt.silence)
databits_with_preamble = xmitter.add_preamble(databits)
samples = xmitter.bits_to_samples(databits_with_preamble)
mod_samples = xmitter.modulate(samples)
####################################
# create channel instance
if opt.bypass:
h = [float(x) for x in opt.h.split(' ')]
channel = bch.BypassChannel(opt.noise, opt.lag, h)
else:
channel = ach.AudioChannel(opt.samplerate, opt.chunksize, opt.prefill)
# transmit the samples, and retrieve samples back from the channel
try:
samples_rx = channel.xmit_and_recv(mod_samples)
def test_check_credentials_no_password(self):
tt = Transmitter()
tt.set_account(self.account_with_no_password)
self.assertEquals(tt.check_credentials(), True)
logging.basicConfig(level=logging.DEBUG,
format="%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
filename=filename,
filemode="w")
console = logging.StreamHandler()
console.setLevel(logging.NOTSET)
formatter = logging.Formatter("%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s")
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
if __name__ == '__main__':
InitLogging()
handler = Handler()
receiver = Receiver()
transmitter = Transmitter()
receiver.connect()
td1 = threading.Thread(target=handler.run)
td2 = threading.Thread(target=receiver.run)
td3 = threading.Thread(target=transmitter.run)
td1.start()
td2.start()
td3.start()
# main loop
while True:
if handler.is_runing() and receiver.is_runing() and transmitter.is_runing():
msg = receiver.fetch()
while msg != None:
handler.push(msg)
def test_check_credentials_bad_password(self):
tt = Transmitter()
tt.set_account(self.account_with_bad_password)
self.assertEquals(tt.check_credentials(), 'username/password error')
from RgbLed import RgbLed
import serial
from time import sleep
from airbornedata import AirborneData
from transmitter import Transmitter
try:
import struct
except ImportError:
import ustruct as struct
# Data collection variables
sensor_name = "Construction Hallway"
sensor_id = 2
transmitter = Transmitter()
airborne_data_list = []
########################
# Setup LED
led = RgbLed(17, 27, 22)
########################
# Test LED
led.red()
sleep(.25)
led.green()
sleep(.25)
led.blue()
sleep(.25)
led.magenta()
if opt.bypass:
print '\t Noise:', opt.noise, ' lag:', opt.lag, 'h: [', opt.h, ']'
print '\tFrequency:', fc, 'Hz'
print '\tSource coding:', ('On' if opt.compress else 'Off')
print '\tChannel coding:', ('n = %d' % opt.cc_len if opt.cc_len!=0 else 'Off')
print '\tEncryption:', ('On' if opt.encrypt else 'Off')
########################################################
#instantiate and run the source block
src = Source(opt.monotone, opt.fname, opt.compress, opt.encrypt)
src_bits, src_payload, databits, pubkey = src.process()
# instantiate and run the transmitter block
xmitter = Transmitter(fc, opt.samplerate, opt.one, opt.spb, opt.silence, opt.cc_len)
if opt.cc_len!=0:
databits = xmitter.encode(databits, opt.cc_len)
databits_with_preamble = xmitter.add_preamble(databits)
samples = xmitter.bits_to_samples(databits_with_preamble)
mod_samples = xmitter.modulate(samples)
####################################
# create channel instance
if opt.bypass:
h = [float(x) for x in opt.h.split(' ')]
channel = bch.BypassChannel(opt.noise, opt.lag, h)
#channel_2 = ach.AudioChannel(opt.samplerate, opt.chunksize, opt.prefill)
else:
channel = ach.AudioChannel(opt.samplerate, opt.chunksize, opt.prefill)
class AccountManager:
DEFAULT_ACCOUNT_ID = 0
def __init__(self):
self.__transmitter = Transmitter()
self.__configpath = self.__set_configpath()
self.__config = self.__init_config()
self.__default_account = AccountManager.get_default_account()
self.__accounts = []
self.__load_accounts_from_config()
def pass_transmitter(self):
return self.__transmitter
def reset_config(self):
self.__accounts = []
if os.path.exists(self.__configpath):
os.remove(self.__configpath)
self.__config = self.__init_config()
def get_accounts(self):
return [self.__default_account] + self.__accounts
def add_new_account(self, account):
self.__verify_account(account)
self.__set_section_id_and_load_account(account)
self.__add_account_to_config(account)
def get_recent_account(self):
id = self.get_recent_id()
id = int(id)
return self.get_account_by_id(id)
def get_recent_id(self):
id = self.__config.get('DEFAULT', 'last_profile')
return int(id)
def get_account_by_id(self, id):
self.__record_recent_account(id)
if id == 0:
account = self.__default_account
else:
account = self.__accounts[id - 1]
self.__transmitter.set_account(account)
return account
def delete_account_by_id(self, id):
offset_id = id - 1
del self.__accounts[offset_id]
self.__renumber_accounts()
def __set_section_id_and_load_account(self, account):
account.set_section_id(self.__next_id())
self.__accounts.append(account)
def __load_accounts_from_config(self):
for section in self.__config.sections():
section_id = self.__next_id()
url = self.__config.get(section, 'url')
username = self.__config.get(section, 'username')
try:
password = self.__config.get(section, 'password')
if password == '': password = None
except NoOptionError:
password = None
new_account = Account(url, username, password)
new_account.set_section_id(section_id)
self.__set_section_id_and_load_account(new_account)
def __verify_account(self, account):
self.__transmitter.set_account(account)
self.__transmitter.check_credentials()
def __next_id(self):
return len(self.__accounts) + 1
def __add_account_to_config(self, account):
id = int(account.get_section_id()) # This will throw an exception if it's not a number
id = str(id)
try:
self.__config.add_section(id)
except DuplicateSectionError:
# No need to add it if it's already there
message = 'a ok'
self.__config.set(id, 'url', account.get_url())
self.__config.set(id, 'username', account.get_username())
if account.get_password():
self.__config.set(id, 'password', account.get_password())
self.__save_config_to_file()
def __save_config_to_file(self):
with open(self.__configpath, 'wb') as handle:
self.__config.write(handle)
def __record_recent_account(self, id):
self.__config.set('DEFAULT', 'last_profile', str(id))
self.__save_config_to_file()
def __renumber_accounts(self):
counter = 1
renumbered_accounts = []
for account in self.get_accounts():
account.set_section_id(counter)
counter += 1
renumbered_accounts.append(account)
self.__accounts = renumbered_accounts
def __init_config(self):
config = ConfigParser.ConfigParser()
if not os.path.exists(self.__configpath):
# Set up initial config file
config.set('DEFAULT', 'delay', '1.0') # wait while showing author info
config.set('DEFAULT', 'cut_flag', '#! CUT MATERIAL') # we remove anything after this in the html
config.set('DEFAULT', 'last_profile', '0') # use as default input option
config.set('DEFAULT', 'next_section_n', '1') # next usable profile section number
with open(self.__configpath, 'wb') as f: config.write(f)
config.read(self.__configpath)
return config
def __set_configpath(self):
# Determine which operating system is in use
platform = sys.platform
linux_relative_path = "~/.lyxblogger/config.cfg"
try:
relative_configpath = {'win32' : "~\\lyxblogger\\config.cfg",
'darwin' : "~/.lyxblogger/config.cfg",
'linux2' : linux_relative_path,
'linux3' : linux_relative_path}[platform]
except KeyError:
raise SystemNotFoundError(platform)
configpath = os.path.expanduser(relative_configpath)
configdir = os.path.dirname(configpath)
if not os.path.exists(configdir): os.makedirs(configdir)
return configpath
@classmethod
def get_default_account(cls):
# we are not going to set the id, because we never save this
url = 'blogtest.letseatalready.com'
username = '******'
password = '******'
default_account = Account(url, username, password)
default_account.set_section_id(AccountManager.DEFAULT_ACCOUNT_ID)
return default_account
