def __init__(self, N):
Py_Module.__init__(self)
self.name = "py_Modem"
t_mod = self.create_task("modulate")
sb = self.create_socket_in (t_mod, "b", N, np.int32 )
sx = self.create_socket_out(t_mod, "x", N, np.float32)
self.create_codelet(t_mod, lambda m,l,f: m.modulate(l[0], l[1]))
def __init__(self, N):
Py_Module.__init__(self)
self.N = N
#infos
self.F_ID = 0 #16 bits, file id (65536 file)
self.F_TYPE = 0 #1 bit , file type (0 .Ts file, 1 img any type
self.PACKET_ID = 0 #16 bits, packet order received for a ts file used to reorder in another
self.PACKET_TYPE = 0 #2 bits to encode 3 types of frames ;1 start// 0 mid// 2 end//
#total 59 bits ########## [P_TYPE P_ID F_ID F_TYPE F_SIZE]
self.INFO_SIZE = 60
dt_dec = self.create_task("decapsulate")
# preferably input window should be smaller thacn frame size bigger than data size
b_in_dec = self.create_socket_in(dt_dec, "IN", self.N + self.INFO_SIZE,
np.int32)
b_out_dec = self.create_socket_out(dt_dec, "OUT", self.N,
np.int32) # return frame size
b_p_type = self.create_socket_out(dt_dec, "p_type", 1, np.int32)
out_p_id = self.create_socket_out(dt_dec, "Packet_ID", 1, np.int32)
out_f_id = self.create_socket_out(dt_dec, "Frame_ID", 1, np.int32)
out_f_type = self.create_socket_out(dt_dec, "out_f_type", 1, np.int32)
out_f_size = self.create_socket_out(dt_dec, "out_f_size", 1, np.int32)
b_ts = self.create_socket_out(dt_dec, "ts_type", 1, np.int32)
b_jpeg = self.create_socket_out(dt_dec, "jpeg_type", 1, np.int32)
self.create_codelet(
dt_dec,
lambda slf, lsk, fid: slf.decapsulate(lsk[b_in_dec], lsk[
b_out_dec], lsk[b_p_type], lsk[out_p_id], lsk[out_f_type], lsk[
out_f_id], lsk[out_f_size], lsk[b_ts], lsk[b_jpeg]))
def __init__(self, K, path):
self.end = 0
self.start = 0
Py_Module.__init__(self)
self.name = "detect"
self.K = K
self.path_dir = path
self.count = 0
self.pream = np.zeros((1, K))
self.pream[0, ::2] = np.ones((1, K // 2))
self.last = np.ones((1, K))
self.reception = 0
self.nb_packet = -1
self.file = None
self.count_image = 0
self.count_video = 0
t_func = self.create_task('detect')
sin = self.create_socket_in(t_func, "X_N", self.K, np.int32)
sout = self.create_socket_out(t_func, "Y_N", self.K, np.int32)
s_end_packet = self.create_socket_out(t_func, "end_packet", 1,
np.int32)
tram_type = self.create_socket_in(t_func, "T_Type", 1, np.int32)
sout_itr = self.create_socket_out(t_func, "itr", 1, np.int32)
self.create_codelet(
t_func, lambda slf, lsk, fid: self.func(lsk[sin], lsk[sout], lsk[
sout_itr], lsk[s_end_packet], lsk[tram_type]))
def __init__(self, len_pream, len_frame):
Py_Module.__init__(self)
self.name = 'preamble'
self.len_frame = len_frame
self.len_pream = len_pream
#self.header1=self.create_preamble() #creer
self.header = np.array(self.get_header("header.txt")).reshape(
1,
2 * len_pream) #utiliser le preambule dans le fishier header.txt
t_ins_pream = self.create_task('insert_preamble')
sin = self.create_socket_in(t_ins_pream, "s_in", len_frame, np.float32)
sout = self.create_socket_out(t_ins_pream, "s_out",
len_frame + 2 * len_pream, np.float32)
self.create_codelet(
t_ins_pream,
lambda slf, lsk, fid: self.insert_preamble(lsk[sin], lsk[sout]))
t_rem_pream = self.create_task('remove_preamble')
s_in = self.create_socket_in(t_rem_pream, "s_in", self.len_frame,
np.float32)
s_out = self.create_socket_out(t_rem_pream, "s_out",
len_frame - 2 * len_pream, np.float32)
self.create_codelet(
t_rem_pream,
lambda slf, lsk, fid: self.remove_preamble(lsk[s_in], lsk[s_out]))
def __init__(self, fse, N):
Py_Module.__init__(self)
self.name = "py_sync_freq_fine"
self.N = N
self.Bn = 0.01
self.zeta = sqrt(2)/2
self.Kp = 2
self.SPS = fse
self.teta = (self.Bn * self.SPS) / \
((self.zeta + 0.25/self.zeta)*self.SPS)
self.d = 1+2*self.zeta*self.teta+self.teta**2
self.gI = (4*(self.teta**2)/self.d)/(self.Kp*self.SPS)
self.gP = (4*(self.teta*self.zeta)/self.d)/(self.Kp*self.SPS)
self.previousSample = 1
self.phase = 0
self.loopFiltState = 0
self.DDSPreviousInp = 0
self.IntegFiltState = 0
t_source = self.create_task('synchronize')
s_in = self.create_socket_in(t_source, 'sync_in', N, np.float32)
s_out = self.create_socket_out(t_source, 'sync_out', N, np.float32)
self.create_codelet(t_source, lambda slf, lsk,
fid: slf.func(lsk[s_in], lsk[s_out]))
def __init__(self, path, N, auto_reset=False):
Py_Module.__init__(self)
if path:
self.src = py_aff3ct.module.source.Source_user_binary(
N, path, auto_reset=False)
self.path = path
self.N = N
self.frame_nb = 1
self.name = "source_file"
self.tmp = 0
self.number_packet = self.compute_packet_number()
#infos
self.F_ID = 0 #16 bits, file id (65536 file)
self.F_TYPE = 0 #1 bit , file type (0 .Ts file, 1 img any type
self.F_SIZE = int(
self.number_packet
) + 1 #24 bits to encode file size in bytes (< 16Mbytes)
self.PACKET_ID = 0 #16 bits, packet order received for a ts file used to reorder in another
self.PACKET_TYPE = 0 #2 bits to encode 3 types of frames ;1 start// 0 mid// 2 end//
#total 59 bits ########## [P_TYPE P_ID F_ID F_TYPE F_SIZE]
self.INFO_SIZE = 60
self.build_info_header()
t_generate = self.create_task('generate')
_out = self.create_socket_out(t_generate, 'U_K', N + self.INFO_SIZE,
np.int32)
nb = self.create_socket_out(t_generate, 'NB', 1, np.int32)
id = self.create_socket_out(t_generate, 'ID', 1, np.int32)
type = self.create_socket_out(t_generate, "type", 1, np.int32)
self.create_codelet(
t_generate, lambda slf, lsk, fid: slf.generate(
lsk[_out], lsk[nb], lsk[id], lsk[type]))
def __init__(self, window, len, header, alpha=0.9):
self.len = len
# HEADER not yet Conjugated and "turned-around" version of the actual header ) to defined when framing
self.HEADER = header[0]
self.size_header = header.size // 2
# keep incomplete corr
self.buff = np.zeros(self.size_header - 1, dtype=complex)
# buffer to temporarly store the frame
self.frame = np.zeros(self.len // 2, dtype=complex)
self.buff_empty = 1
self.left = np.zeros(
self.len // 2,
dtype=complex) # size left to complete current frame
self.prev_delay = 0
self.score = np.zeros(self.len // 2)
self.alpha = alpha
Py_Module.__init__(self)
self.name = "Frame_sync"
tr_synch = self.create_task("tr_synchronize")
# preferably input window should be smaller thacn frame size bigger than data size
s_in_sig = self.create_socket_in(tr_synch, "IN", window, np.float32)
s_out_main = self.create_socket_out(tr_synch, "OUT", len,
np.float32) # return frame size
s_out_delay = self.create_socket_out(tr_synch, "delay", 1,
np.int32) # delay
s_out_bool = self.create_socket_out(
tr_synch, "itr_tr", 1, np.int32) # 0 if output1 contains data
self.create_codelet(
tr_synch,
lambda slf, lsk, fid: slf.synchronize(lsk[s_in_sig], lsk[
s_out_main], lsk[s_out_delay], lsk[s_out_bool]))
def __init__(
self,
N,
):
Py_Module.__init__(self)
self.name = "Frequency_Synchronizer"
t_synch = self.create_task("synchronize")
s_in = self.create_socket_in(t_synch, "IN", N, np.float32)
s_in_M = self.create_socket_in(t_synch, "IN_m", 1, np.int32)
s_in_ts = self.create_socket_in(t_synch, "IN_ts", 1, np.float32)
s_in_fft = self.create_socket_in(t_synch, "IN_fft", N // 2, np.float32)
s_in_alpha = self.create_socket_in(t_synch, "IN_alpha", 1, np.float32)
s_out_fft = self.create_socket_out(t_synch, "OUT_fft", N // 2,
np.float32)
s_out = self.create_socket_out(t_synch, "OUT", N, np.float32)
self.create_codelet(
t_synch, lambda slf, lsk, fid: slf.synchronize(
lsk[s_in], lsk[s_in_M], lsk[s_in_ts], lsk[s_in_fft], lsk[
s_in_alpha], lsk[s_out], lsk[s_out_fft]))
t_desynch = self.create_task("desynchronize")
s_in1 = self.create_socket_in(t_desynch, "IN_1", N, np.float32)
s_in_ts1 = self.create_socket_in(t_desynch, "IN_ts1", 1, np.float32)
s_out1 = self.create_socket_out(t_desynch, "OUT_1", N, np.float32)
self.create_codelet(
t_desynch, lambda slf, lsk, fid: slf.desynchronize(
lsk[s_in1], lsk[s_in_ts1], lsk[s_out1]))
def __init__(self):
Py_Module.__init__(self) # Call the aff3ct Py_Module __init__
self.name = "s_catcher" # Set your module's name
tsk = self.create_task("do_nothing") # create a task for your module
self.create_fake_codelet(tsk) # create codelet
signal.signal(signal.SIGINT, self.signal_handler)
def __init__(self, dc=50):
# init
Py_Module.__init__(self)
self.name = "display_info"
self.dc = dc
t_dis = self.create_task('display')
self.frame = 0
self.init = True
self.socket_name = []
self.sepa = "#" + 20 * "-" + "|"
def __init__(self, alpha, K):
Py_Module.__init__(self)
self.name = 'py_ampli'
self.alpha = alpha
t_amp = self.create_task('amplify')
sin = self.create_socket_in(t_amp, "amp_in", K, np.float32)
sout = self.create_socket_out(t_amp, "amp_out", K, np.float32)
self.create_codelet(
t_amp, lambda slf, lsk, fid: self.ampli(lsk[sin], lsk[sout]))
def __init__(self, size_pream, N):
Py_Module.__init__(self)
self.name = "py_sync_pream"
self.N = N
self.size_pream = size_pream
self.pream = [cos(3*np.pi/4), sin(3*np.pi/4)]*(size_pream//2)
t_source = self.create_task('sync_pream')
s_in = self.create_socket_in(t_source, 'sync_in', N, np.float32)
s_out = self.create_socket_out(t_source, 'sync_out', N, np.float32)
self.create_codelet(t_source, lambda slf, lsk,
fid: slf.func(lsk[s_in], lsk[s_out]))
def __init__(self, K, scramble):
# init
Py_Module.__init__(self)
self.name = "scrambler"
t_amp = self.create_task('scramble')
self.scram = self.get_scram(scramble)
sin = self.create_socket_in(t_amp, "X_N", K, np.int32)
sout = self.create_socket_out(t_amp, "Y_N", K, np.int32)
# properties
self.create_codelet(
t_amp, lambda slf, lsk, fid: self.scramble(lsk[sin], lsk[sout]))
def __init__(self, fech, K):
# init
Py_Module.__init__(self)
self.name = "frequency_sync"
t_amp = self.create_task('sync')
self.fech = fech
sin = self.create_socket_in(t_amp, "sync_in", K, np.float32)
sout = self.create_socket_out(t_amp, "sync_out", K, np.float32)
# properties
self.create_codelet(
t_amp, lambda slf, lsk, fid: self.sync(lsk[sin], lsk[sout]))
def __init__(self, loop_max):
Py_Module.__init__(self) # Call the aff3ct Py_Module __init__
self.name = "loop_cnt" # Set your module's name
self.loop_max = loop_max
self.cnt = 0
tsk = self.create_task("increment") # create a task for your module
self.create_socket_out(
tsk, "ctrl", 1,
np.int8) # create an input socket for the task t_mod
self.create_codelet(
tsk, lambda slf, lsk, fid: slf.count(lsk[0])) # create codelet
def __init__(self, path, N):
Py_Module.__init__(self)
self.name = "py_Source_image"
self.path = path
self.N = N
self.K = N
self.pream = True
self.offset = 0
self.tabpream = fairepream.fairepream(128)
t_source = self.create_task('generate')
s_out = self.create_socket_out(t_source, 'img', N, np.int32)
self.create_codelet(t_source,
lambda slf, lsk, fid: slf.imgToBits(lsk[s_out]))
def __init__(self, N):
Py_Module.__init__(self)
t_plot = self.create_task("plot")
self.create_socket_in(t_plot, "x", N, np.float32)
self.create_codelet(t_plot, lambda m, l, f: m.plot(l[0]))
self.fig = plt.figure()
self.ax = self.fig.add_subplot(1, 1, 1)
self.line, = self.ax.plot([], '.b')
self.i_plt = 0
plt.xlabel("Real part")
plt.ylabel("Imaginary part")
plt.ylim(-2, 2)
plt.xlim(-2, 2)
def __init__(self, K, header):
# init
Py_Module.__init__(self)
self.name = "sync"
self.header = header
t_amp = self.create_task('sync')
sin = self.create_socket_in(t_amp, "X_N", K, np.float32)
sout = self.create_socket_out(t_amp, "Y_N", K, np.float32)
sout_jump = self.create_socket_out(t_amp, "phase_jump", 1, np.float32)
# properties
self.create_codelet(
t_amp, lambda slf, lsk, fid: self.sync(lsk[sin], lsk[sout], lsk[
sout_jump]))
def __init__(self, out_amp, varNoise, K):
# init
Py_Module.__init__(self)
self.name = "agc"
t_amp = self.create_task('amplify')
self.out_amp = out_amp
self.varNoise = varNoise
sin = self.create_socket_in(t_amp, "amp_in", K, np.float32)
sout = self.create_socket_out(t_amp, "amp_out", K, np.float32)
# properties
self.gain = 1
self.create_codelet(
t_amp, lambda slf, lsk, fid: self.ampli(lsk[sin], lsk[sout]))
def __init__(self, ref, K):
# init
Py_Module.__init__(self)
self.ref = ref
self.name = "agc"
t_amp = self.create_task('amplify')
sin = self.create_socket_in(t_amp, "amp_in", K, np.float32)
sout2 = self.create_socket_out(t_amp, "gain_out", 1, np.float32)
itr = self.create_socket_out(t_amp, "itr", 1, np.int32)
sout = self.create_socket_out(t_amp, "amp_out", K, np.float32)
# properties
self.gain = 1
self.create_codelet(
t_amp, lambda slf, lsk, fid: self.ampli(lsk[sin], lsk[sout], lsk[
sout2], lsk[itr]))
def __init__(self, K, alpha):
# init
Py_Module.__init__(self)
self.name = "est_noise"
self.alpha = alpha
self.prev_snr = 0
t_estimate = self.create_task('estimate')
sin = self.create_socket_in(t_estimate, "y", K, np.float32)
sout1 = self.create_socket_out(t_estimate, "cp", 1, np.float32)
sout2 = self.create_socket_out(t_estimate, "snr", 1, np.float32)
# properties
self.gain = 1
self.create_codelet(
t_estimate, lambda slf, lsk, fid: self.estimate(
lsk[sin], lsk[sout1], lsk[sout2]))
def __init__(self, N,window):
Py_Module.__init__(self) # Call the aff3ct Py_Module __init__
self.name = "py_plot" # Set your module's name
t_plot = self.create_task("plot") # create a task for your module
self.create_socket_in (t_plot, "x", N, np.float32)
self.create_codelet(t_plot, lambda slf, lsk, fid: slf.plot(lsk[0])) # create codelet
self.fig = plt.figure()
self.ax = self.fig.add_subplot(1, 1, 1)
self.line, = self.ax.plot([], '*b')
self.i_plt = 0
plt.xlabel("Real part")
plt.ylabel("Imaginary part")
plt.ylim(-window,window)
plt.xlim(-window,window)
def __init__(self, len):
#infos
self.F_ID = 0 #16 bits, file id (65536 file)
self.F_TYPE = 0 #1 bit , file type (0 .Ts file, 1 img any type)
self.F_SIZE = 0 #24 bits to encode file size in bytes (< 16Mbytes)
self.PACKET_ID = 0 #16 bits, packet order received for a ts file used to reorder in another
self.PACKET_TYPE = 0 #2 bits to encode 3 types of frames ;1 start// 0 mid// 2 end//
#total 59 bits ########## [P_TYPE P_ID F_ID F_TYPE F_SIZE]
#
self.PACKET_SIZE = len #packet size
self.INFO_SIZE = 59
self.F_PATH = './test_tmp/test.ts'
#create/update info header
self.build_info_header() #
print(self.INFO)
Py_Module.__init__(self)
self.name = "data_encapsulation"
dt_enc = self.create_task("encapsulate")
b_in_enc = self.create_socket_in(
dt_enc, "IN", self.PACKET_SIZE, np.int32
) #preferably input window should be smaller thacn frame size bigger than data size
b_out_enc = self.create_socket_out(dt_enc, "OUT",
self.PACKET_SIZE + self.INFO_SIZE,
np.int32) #return frame size
self.create_codelet(
dt_enc, lambda slf, lsk, fid: slf.encapsulate(
lsk[b_in_enc], lsk[b_out_enc]))
dt_dec = self.create_task("decapsulate")
b_in_dec = self.create_socket_in(
dt_enc, "IN", self.PACKET_SIZE, np.int32
) #preferably input window should be smaller thacn frame size bigger than data size
b_out_dec = self.create_socket_out(dt_enc, "OUT",
self.PACKET_SIZE + self.INFO_SIZE,
np.int32) #return frame size
self.create_codelet(
dt_enc, lambda slf, lsk, fid: slf.decapsulate(
lsk[b_in_dec], lsk[b_out_dec]))
def __init__(self):
# init
Py_Module.__init__(self)
self.name = "power_control"
switch = 18 #physical pin num attached to the switch
GPIO.setmode(GPIO.BOARD)
GPIO.setup(switch, GPIO.OUT)
self.state = 0
swtch = self.create_task('change_state')
sin_change_state = self.create_socket_in(
swtch, "X_N", 1, np.int32) # send 1 to change state
sout_state = self.create_socket_out(swtch, "Y_N", 1,
np.int32) #current state of switch
# properties
self.create_codelet(
swtch, lambda slf, lsk, fid: self.change_state(
lsk[sin_change_state], lsk[sout_state]))