def __init__(self):
"""
position: degrees of antenna's base rotated by motor
counter_for_overlap: counter to check for overlap
overlap_thress: maximun degrees that antenna is able to rotate = 360 + overlap
"""
if Antenna.__instance is not None:
raise Exception("This class is a singleton!")
else:
try:
self.paths = paths.Paths()
file_name = "{dir}/{filename}".format(dir="Logs",
filename='adcs.log')
with FileReadBackwards(file_name,
encoding="utf-8") as log_file:
for line in log_file:
position = line.decode().split(',')[0]
counter = line.decode().split(',')[1]
theta_antenna_pointing = line.split(',')[2]
theta = line.split(',')[3]
break
except:
#@TODO change the default init position and counter
position = 0
counter = 0
theta_antenna_pointing = 0
theta = 0
self.position = position
self.counter_for_overlap = counter
self.theta = theta
self.theta_antenna_pointing = theta_antenna_pointing
self.overlap_thress = 380
self.sign_for_counter = +1
self.angle_plot = 0
Antenna.__instance = self
def __init__(self, ground_ip):
self.status_vector = dict()
self.command_vector = dict()
self.ground_ip = ground_ip
self.info_logger = InfoLogger()
self.data_logger = DataLogger()
self.adcs_logger = AdcsLogger()
#@TODO where antenna to start
#self.adcs_logger.write_info(' {}, {}, {}, {}'.format(0, 0, 0, 0))
self.elink = elinkmanager.ELinkManager(self, self.ground_ip)
self.thread_elink = None
self.data_manager = DataManager(self, self.info_logger,
self.data_logger)
self.thread_data_manager = None
self.dmc = dmc.DMC(self)
self.thread_dmc = None
self.heat = heat.HEAT(self)
self.thread_heat = None
self.adc = adc.ADC(self)
self.thread_adc = None
self.tx = tx.TX(self)
self.thread_tx = None
self.counterdown = CounterDown(self)
self.paths = paths.Paths()
GPIO.setmode(GPIO.BOARD)
Master.__instance = self
def __init__(self, master_):
if TX.__instance is not None:
raise Exception('This class is a singleton!')
else:
self.master = master_
self.info_logger = self.master.info_logger
self.counterdown = CounterDown(master_)
self.sdr_process = None
self.file_name_temperature = paths.Paths().tx_file
self.file_name_predefined_data = paths.Paths().tx_file_pre_data
self.file_img_spon = paths.Paths().tx_img_spon
self.file_img_fam = paths.Paths().tx_img_fam
self.TX_code_file = 'sdr_TX.py'
self.TX_code_sin = 'sin_TX.py'
self.TX_code_spon = 'img_TX.py'
self.TX_code_fam = 'fam_TX.py'
self.pin_led_tx = pins.Pins().pin_led_tx
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.pin_led_tx, GPIO.OUT)
GPIO.output(self.pin_led_tx, GPIO.LOW)
def __init__(self):
self.status_vector = dict()
self.command_vector = dict()
self.info_logger = InfoLogger()
self.data_logger = DataLogger()
self.data_manager = DataManager(self, self.info_logger,
self.data_logger)
self.thread_data_manager = None
self.heat = heat.HEAT_HAI(self)
self.thread_heat = None
self.counterdown = CounterDown(self)
self.paths = paths.Paths()
self.pin_powerB = pins.Pins(
).pin_powerB # @TODO change it in boot/config.txt
GPIO.setmode(GPIO.BOARD)
#GPIO.setup(self.pin_powerB, GPIO.OUT)
Master.__instance = self
def __init__(self, ground_ip):
self.status_vector = dict()
self.command_vector = dict()
self.ground_ip = ground_ip
self.info_logger = InfoLogger()
self.data_logger = DataLogger()
self.adcs_logger = AdcsLogger()
self.elink = elinkmanager.ELinkManager(self,self.ground_ip)
self.thread_elink = None
# self.data_manager = DataManager(self, self.info_logger, self.data_logger)
# self.thread_data_manager = None
self.tx = tx.TX(self)
self.thread_tx = None
self.counterdown = CounterDown(self)
self.paths = paths.Paths()
self.pin_powerB = pins.Pins().pin_powerB # @TODO change it in boot/config.txt
#GPIO.setmode(GPIO.BOARD)
#GPIO.setup(self.pin_powerB, GPIO.OUT)
Master.__instance = self
import json
import Paths as paths
if __name__ == '__main__':
path = paths.Paths()
status_vector = {
"TEMP_A": 1,
"TEMP_B": 1,
"HEAT_B_ON": 0,
"HEAT_A_ON": 0,
"IMU": 1,
"GPS": 1,
"DEP_READY": 0,
"KILL": 0,
"DMC_SLEEP": 0,
"TX_ON": 0,
"ADC_MAN": 0,
"DEP_CONF": 0,
"COMPASS": 1,
"DEP_SUCS": 0,
"RET_AB": 0,
"RET_READY": 0,
"RET_CONF": 0,
"HEAT_SLEEP": 0,
"RET_SUCS": 0,
"ALTIMETER": 1,
"AMP_TEMP": 1,
"INFRARED": 1
}
command_vector = {
"ADC_MAN": 0,
from IK import *
import multiprocessing
from threading import *
from tkinter import *
from Paths import *
from Plot import *
from Velocity import *
D = Derivatives()
FK = ForwardKinematics()
IK = InverseKinematics()
P = Parameters()
Plot = Plot()
T = Paths()
V = Velocity()
q = np.zeros(P.links().shape[0])
signal = np.zeros(P.links().shape[0])
p = np.zeros(3)
o = np.zeros(1)
a = np.zeros(1)
v = np.zeros(3)
w = np.zeros(P.links().shape[0])
time = 0
dt = 0
counter = 0
class trunk:
@staticmethod
def algorithm(u, z):
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License 3 as published by
# the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
from CCParser import CCParser
from Paths import *
paths = Paths()
class Configuration(object):
"""
This is the real class used to manage the configuration of the program
"""
def __init__(self):
self._ccp = CCParser(paths.configuration, '7zrecover_configuration')
self._password_length_end = 3
self.set_password_length_start(
self._ccp.get_int_defval('StartPassLenght', 2))
self.set_password_length_end(
self._ccp.get_int_defval('PasswordLenght', 3))
self.set_number_of_process(
while len(branch) < 3:
if unique_frame_sequence[i][0] not in branch:
branch.append(unique_frame_sequence[i][0])
position.append(unique_frame_sequence[i][1])
i += 1
branches.append(zip(branch, position))
unique_frame_sequence.pop(0)
print branches
print
Branches = list()
for b in branches:
Branches.append(Branch(Node(*b[0]), Node(*b[1]), Node(*b[2])))
p = Paths()
for B in Branches:
print B
p.extend(B)
for i in p.branches:
print i
print p.branches[i]
all_paths = p.get_all_path_sequences()
all_paths.sort()
print all_paths, len(all_paths)
print
for p in all_paths:
print p, len(p), sum(p)
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License 3 as published by
# the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
import traceback
from functools import wraps
from Paths import *; PATHS=Paths()
def W_try_or_log(func):
@wraps(func)
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception as e:
debug(traceback.format_exc())
return wrapper
def debug(string):
with open(PATHS.debug_file, encoding='utf-8', mode='at') as f:
- I tried to use regex for the "remove tests" option, but it seemed to fail. Sometimes it was returning true when
the test didn't existed. More information at the doc: Regex test
"""
import os
import time
import threading
import traceback
import socket
from datetime import datetime
# Local imports
from Paths import *
PATHS = Paths()
from Debug import W_try_or_log
Queue = []
WRITE_LOOP = False #used to write_errors, it will write the cracking code
TAB = ''' '''
REMOVE_COMBINATIONS = '''
{tab}if remove_combinations.search(test_word{level}):
{tab} self._count+=len_word_list**({lnb}-{inb})
{tab} continue\n
'''
# Should the word be removed? remove_tests.remove(word) ?
def main():
s = RandomFSSequence(no_of_shifts=2, min_length=50, max_length=100)
s.generate()
print s.info("without UGA")
# a Sequence object
#t = BiologicalSequence( s.sequence )
#t = BiologicalSequence( "GCTGGTGGGGTAGCAGGTGTTTCTGTTGACTTGATATTATTTCCTCTGGATACCATTAAAACCAGGCTGCAGAGTCCCCAAGGATTTAGTAAGGCTGGTGGTTTTCATGGAATATATGCTGGCGTTCCTTCTGCTGCTATTGGATCCTTTCCTAATG" )
t = BiologicalSequence(
"AAATGACGAACACAGAGGAAAGAAGAGAGGCAACTGCTGAGGTCCCCTAGGCCTTTGAGAAAACGGAGTTGTACCTTTGGCAACATAAGTGCATATCTACAAGAAAGGCGATAATGTAGACACCAAGGGAATGGGTACTGTCCAAAAAGAAATGCCTCACAAATGTCACCATGGCAAAACTAAAAGAGTCTACAAAGTTACCTAGCATGCTGTTGGCATCATTGTAAACAAACAAGTTAAGGGCAAGATTCTTGCCAAGAGAATTAATATGCATATTGGGCATATTAAGCACTCTAAGAGCCAAGATGATTTCCTGAAAGTGTGTGAAGGAAAATAACCAGCATAAAGAGGGAAGCTAAAGAGAAACCTGAAGCTGCAGCCTGTTCCACCCAGAGAAGCACACTTTGTAAGAACCAATGAAAAGGAGCCTGAGCTGCTGGAGTCTATTAACTGAATTCATGGT"
)
#t = RandomSequence( 100 )
#t.generate()
# t.stops.append( "UGA" )
print
print t.info()
for i in xrange(3):
print t.colour_frame(i, sep="")
print " |" * ((s.length) // 10)
t.get_stop_sequence()
print "The raw stop sequence (%s)..." % len(t.stop_sequence)
print t.stop_sequence
print
# now to create paths
p = Paths(t.stop_sequence)
print "The sanitised stop sequence (%d)..." % len(p.unique_frame_sequence)
print p.unique_frame_sequence
print
print "Create the branches from the stop sequence..."
p.create_branches()
print
print "Create a tree..."
T = Tree()
print "View and graft the branches..."
for B in p.branches:
#print B
T.graft(B)
print T
print "Build the paths..."
paths = T.get_paths(simplify=True)
print paths
print
for frame in xrange(3):
print "Frameshift sequences for frame %d:" % frame
for j in T.get_frame_paths(frame):
print len(j), " : ", j
print
"""
frameshifted_sequence, fragments = t.frameshift_from_path( all_paths[0] )
q = BiologicalSequence( s.sequence )
print s.info()
for i in xrange( 3 ):
print q.colour_frame( i, sep="" )
print " |"*(( s.length )//10 )
print
print " ".join( fragments )
print
print t.path
print t.colour_frameshifted_sequence( sep="" )
print " |"*(( s.length )//10 )
"""
for i in xrange(3):
all_paths = T.get_frame_paths(i)
for a in all_paths:
frameshifted_sequence, fragments, frameshift_signals = t.frameshift_from_path(
a)
print t.path
print t.colour_frameshifted_sequence(sep="")
print " ".join(fragments)
print " ".join(frameshift_signals)
print
