def main():
dn = DisplayNumber()
dd = DigitDetection()
ampel = MainAmpelerkennung()
sRead = SerialRead()
ser = Serial()
process2 = multiprocessing.Process(target=ampel.detect_light)
dn.start()
dd.start()
sRead.start()
process2.start()
finish = False
while not finish:
msg = sRead.getMsg()
if "F" in str(msg):
#if msg == "b'Finish'":
finish = True
number = dd.getNumber()
print("number main: " + str(number))
if number == 0:
number = randint(1, 5)
print("number main definitive: " + str(number))
dd.cancel()
dn.setNumber(number)
dn.cancel()
ser.sendText(str(number))
time.sleep(0.5)
print("pink panzer finish")
def openPort(self, settings=None):
if not settings:
settings = self.ui.getPortSettings()
if not settings["port"]:
return False, u"错误的串口号"
self.serial = Serial()
self.connect(self.serial.qtobj, QtCore.SIGNAL(Serial.SIG_NEWDATA), self.onRecvData)
self.connect(self.serial.qtobj, QtCore.SIGNAL(Serial.SIG_RECVEXCEPTION), self.onRecvException)
ret, msg = self.serial.open(settings)
return ret, msg
def chunkBlater(Input, CHUNK):
"""
__HELP__
type 'help(Serial)' in command window to get methods.
"""
elements = len(Input)
packets = elements / CHUNK
offset = elements - packets * CHUNK
from time import sleep
from Serial import Serial
print "\nInput:\t" + str(Input)
COMPORT = Serial()
COMPORT.begin('COM6', 9600)
block = []
received = []
if packets > 0:
for i in range(0, packets):
block = Input[i * CHUNK:(i + 1) * CHUNK]
print block
j = 0
for j in range(j, CHUNK):
COMPORT.sprintln(block[j])
capture = COMPORT.sread()
received.extend(capture)
print "Packet Index:\t" + str(i) + "\tChunk Index:\t" + str(
j) + "\tReceived:\t" + capture
if offset > 0:
block = Input[elements - offset:elements]
print block
k = 0
for k in range(k, offset):
COMPORT.sprintln(block[k])
capture = COMPORT.sread()
received.extend(capture)
print "Offset Index:\t" + str(k) + "\tReceived:\t" + capture
return distil(received)
def self_test(server):
import Serial.Serial as ser
try:
while True:
#val = ser.read()
ser.read()
data = json.dumps({"measure": "25"})
server.send_message_to_all(data)
time.sleep(0.1)
data = json.dumps({"measure": "35"})
server.send_message_to_all(data)
time.sleep(0.1)
except Exception as e:
print(e.message)
def __init__(self, serialDev):
self.logger = logging.getLogger('BleuettePi')
self.serial = Serial()
self.serial.connect(serialDev)
self.mcp = MCP230XX(self.MCP_ADDRESS, 16)
self.Servo = Servo.Servo(self.serial, fakemode=Config.FAKE_MODE)
self.Servo.init()
Servo.Servo_Trim.values = Data.Instance().get(['servo', 'trims'])
Servo.Servo_Limit.values = Data.Instance().get(['servo', 'limits'])
self.Analog = Analog(self.serial)
self.Compass = BleuettePi_Compass()
self.Accelerometer = BleuettePi_Accelerometer()
self.GroundSensor = BleuettePi_GroundSensor(self.mcp)
# Init mode
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.INTA, GPIO.IN)
GPIO.setup(self.INTB, GPIO.IN)
GPIO.setup(self.INTC, GPIO.IN)
GPIO.setup(self.INTD, GPIO.IN)
GPIO.add_event_detect(self.INTA,
GPIO.RISING,
callback=self.interrupt,
bouncetime=300)
GPIO.add_event_detect(self.INTB,
GPIO.RISING,
callback=self.interrupt,
bouncetime=300)
GPIO.add_event_detect(self.INTC,
GPIO.RISING,
callback=self.interrupt,
bouncetime=300)
GPIO.add_event_detect(self.INTD,
GPIO.RISING,
callback=self.interrupt,
bouncetime=300)
self.mcp.config(self.RESET_PIN, MCP230XX.OUTPUT)
#self.mcp.pullup(self.RESET_PIN, True)
self.mcp.output(self.RESET_PIN, 1)
def __init__(self, device):
serial = Serial(device, 57600, 1)
self._pins = [
DigitalPin("D10", "DIGITAL", 10, "INPUT"),
DigitalPin("D11", "DIGITAL", 11, "INPUT"),
]
super(YangBoard, self).__init__("Yang", serial, [])
def __init__(self, executable_path):
super(Ui, self).__init__()
ui_file = executable_path + QDir.separator() + 'Serial.ui'
uic.loadUi(ui_file, self)
self.serial = Serial()
self.__signals()
self.show()
class Serial_Manager:
def __init__(self, Admission_Control):
self.admission_control = Admission_Control
self.serial = Serial(self)
def write(self, data):
if data:
print("Writing on serial succes")
else:
print("Writing on serial fail")
def handle_serial_request(self, data):
print(data)
if (data[Index.TYPE] == Request_Type.SENSOR):
sensor = self.extract_sensor_data(data)
self.admission_control.handle_new_sensor_request(sensor)
else:
interest = self.extract_interest_data(data)
self.admission_control.handle_new_interest_request(interest)
def extract_sensor_data(self, data):
x = data[Index.X]
y = data[Index.Y]
radius = data[Index.RADIUS]
return Sensor(x, y, radius)
def extract_interest_data(self, data):
x = data[Index.X]
y = data[Index.Y]
radius = data[Index.RADIUS]
period = data[Index.PERIOD]
expiry = data[Index.EXPIRY]
return Interest(x, y, radius, period, expiry)
def write(self, data):
self.serial.write(data)
def new_sensor_request(self, x, y):
print("Serial recevied new sensor request with coordinates", x, y)
sensor = Sensor(x, y)
self.admission_control.handle_new_sensor_request(sensor)
def new_interest_request(self, x, y, radius, period, expiracy):
print("Serial recevied new interest request with coordinates", x, y)
interest = Interest(x, y, radius, period, expiracy)
self.admission_control.handle_new_interest_request(interest)
def __init__(self,device):
serial = Serial(device,57600,1)
self._pins = [
DigitalPin("D01","DIGITAL",1,"OUTPUT"),
DigitalPin("D02","DIGITAL",1,"OUTPUT"),
]
super(YinBoard,self).__init__("Yin",serial,self._pins)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.orientation = 'horizontal'
# box dei widgets
self.widget_box = BoxLayout()
# self.serial è l'instanza principale di serial cui dovranno essere modificati gli attributi come port master angles
self.serial = Serial()
# contesto gl
self.gl = glContext()
# sliderBox è il widget contenente gli sliderAngles e i Label corrispondenti
self.sliderBox = SliderAnglesBox(axis=RootWidget.axis)
# master_cheker è il widget contenente delle checkerBox che permette di modificare master
self.master_cheker = MasterChecker()
# textInputPort è il text input dal quale viene modificata la porta in serial
self.textInputPort = TextInputPort()
# size dei widget
self.textInputPort.size_hint = [1, .05]
self.master_cheker.size_hint = [1, .05]
self.sliderBox.size_hint = [1, .9]
# aggiunta dei widget a widget_box
self.widget_box.orientation = 'vertical'
self.widget_box.add_widget(self.textInputPort)
self.widget_box.add_widget(self.master_cheker)
self.widget_box.add_widget(self.sliderBox)
# size di widget_box e gl
self.widget_box.size_hint = [.3, 1]
self.gl.size_hint = [.7, 1]
# aggiunta di widget_box e gl al BoxLayout
self.add_widget(self.widget_box)
self.add_widget(self.gl)
Clock.schedule_interval(self.print_var_state, 1)
def sendSerial(self,command):
"""
Prepare and send a serial command to Serial class
@param cmd string command
"""
wdg_retorno = self.get_wdg("txtRetorno")
if(self.first_command):
self.first_command=False
buffer = gtk.TextBuffer()
wdg_retorno.set_buffer(buffer)
command = self.get_wdg("cbSerialCommand").get_active_text()
for ip in self.stbip:
ser = Serial(ip)
cmds = serial_commands[command]['serial']
if (serial_commands[command]['complemento'] == False):
retorno = ser.process(cmds)
msg = "ip: %s\n"%(ip)
self.show_message(msg + self.__make_serial_readable(command, retorno) + "\n")
else:
mb = MessageBox('error')
mb.mostrar('Not implemented yet')
class Serial_Manager:
def __init__(self):
self.admission_control = None;
self.serial = None
def set_admission_control(self, admission_control):
self.admission_control = admission_control
self.serial = Serial()
self.serial.set_serial_manager(self)
def handle_serial_request(self, type, data):
if(type == Request_Type.SENSOR):
unpacked_data = struct.unpack('=3l1L', data)
sensor = self.extract_sensor_data(unpacked_data)
self.admission_control.handle_new_sensor_request(sensor)
if(type == Request_Type.INTEREST):
unpacked_data = struct.unpack('=3l1L2Q1i', data)
interest = self.extract_interest_data(unpacked_data)
self.admission_control.handle_new_interest_request(interest)
if(type == Request_Type.CONFIG):
unpacked_data = struct.unpack('=1L1I', data)
self.admission_control.config(unpacked_data[0], unpacked_data[1])
def extract_sensor_data(self, data):
x = data[Index.X]
y = data[Index.Y]
radius = data[Index.RADIUS]
return Sensor(x, y, radius)
def extract_interest_data(self, data):
x = data[Index.X]
y = data[Index.Y]
radius = data[Index.RADIUS]
period = data[Index.PERIOD]
expiry = data[Index.EXPIRY]
ref = data[Index.REF]
return Interest(x, y, radius, period, expiry, ref)
def write_response_message(self, result, interest_ref):
self.write_header(1);
self.write_msg(result, interest_ref)
def write_header(self, times):
header = bytes('^', 'ascii') + bytes(str(times), 'ascii') + bytes('$', 'ascii')
self.serial.write(header)
def write_msg(self, result, interest_ref):
ref = bytes(str(interest_ref), 'ascii')
msg = ref + b'X' + bytes(str(int(result)), 'ascii')
self.serial.write(msg)
def updatePortComBox(self, isOpening=False):
""" 更新串口列表, 暂不删除已不存在的端口
若没有已打开的串口则将最新发现的串口设置为当前串口
"""
newCount = 0
for port in Serial.getActivePorts():
if self.port_comboBox.findText(port) > -1:
continue
self.port_comboBox.addItem(port)
newCount += 1
if newCount == 0:
return 0
if not isOpening:
lastIndex = self.port_comboBox.count() - 1
if lastIndex > -1:
self.port_comboBox.setCurrentIndex(lastIndex)
return newCount
def __init__(self, mixed):
self.serial = Serial()
self.serial.connect(mixed)
self.Servo = Servo(self.serial, fakemode = Config.FAKE_MODE)
self.Analog = Analog(self.serial)
self.Compass = BleuettePi_Compass()
self.Accelerometer = BleuettePi_Accelerometer()
self.GroundSensor = BleuettePi_GroundSensor()
# Init mode
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.INTA, GPIO.IN)
GPIO.setup(self.INTB, GPIO.IN)
GPIO.setup(self.INTC, GPIO.IN)
GPIO.setup(self.INTD, GPIO.IN)
GPIO.add_event_detect(self.INTA, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTB, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTC, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTD, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
def __init__(self, serialDev):
self.logger = logging.getLogger('BleuettePi')
self.serial = Serial()
self.serial.connect(serialDev)
self.mcp = MCP230XX(self.MCP_ADDRESS, 16)
self.Servo = Servo.Servo(self.serial, fakemode = Config.FAKE_MODE)
self.Servo.init()
Servo.Servo_Trim.values = Data.Instance().get(['servo', 'trims'])
Servo.Servo_Limit.values = Data.Instance().get(['servo', 'limits'])
self.Analog = Analog(self.serial)
self.Compass = BleuettePi_Compass()
self.Accelerometer = BleuettePi_Accelerometer()
self.GroundSensor = BleuettePi_GroundSensor(self.mcp)
# Init mode
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.INTA, GPIO.IN)
GPIO.setup(self.INTB, GPIO.IN)
GPIO.setup(self.INTC, GPIO.IN)
GPIO.setup(self.INTD, GPIO.IN)
GPIO.add_event_detect(self.INTA, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTB, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTC, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTD, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
self.mcp.config(self.RESET_PIN, MCP230XX.OUTPUT)
#self.mcp.pullup(self.RESET_PIN, True)
self.mcp.output(self.RESET_PIN, 1)
<<<<<<< HEAD
if Config.FAKE_MODE:
obj = SerialFake
else:
obj = '/dev/ttyAMA0'
=======
if True:
obj = '/dev/ttyAMA0'
fake = False
else:
obj = SerialFake
fake = True
>>>>>>> e9ffd7ef371450a29e24962357af5942710c8547
serial = Serial()
serial.connect(obj)
<<<<<<< HEAD
servo = Servo(serial, fakemode = Config.FAKE_MODE)
=======
servo = Servo(serial, fakemode = fake)
>>>>>>> e9ffd7ef371450a29e24962357af5942710c8547
servo.init()
#ServoSeq = Servo_Sequencer(servo)
#ServoSeq.daemon = True;
#ServoSeq.start()
#sspeed = Servo_SpeedStep(servo)
sspeed = Servo_SpeedDelay(servo)
data_list.append(line.strip().rstrip())
binary_data = ''.join(data_list)
print('The statistical test of the Binary Expansion of SQRT(3)')
print('2.1. Frequency Test:\t\t\t\t\t\t\t\t\t', FrequencyTest.monobit_test(binary_data[:1000000]))
print('2.2. Block Frequency Test:\t\t\t\t\t\t\t\t', FrequencyTest.block_frequency(binary_data[:1000000]))
print('2.3. Run Test:\t\t\t\t\t\t\t\t\t\t\t', RunTest.run_test(binary_data[:1000000]))
print('2.4. Run Test (Longest Run of Ones): \t\t\t\t\t', RunTest.longest_one_block_test(binary_data[:1000000]))
print('2.5. Binary Matrix Rank Test:\t\t\t\t\t\t\t', Matrix.binary_matrix_rank_text(binary_data[:1000000]))
print('2.6. Discrete Fourier Transform (Spectral) Test: \t\t', SpectralTest.sepctral_test(binary_data[:1000000]))
print('2.7. Non-overlapping Template Matching Test:\t\t\t', TemplateMatching.non_overlapping_test(binary_data[:1000000], '000000001'))
print('2.8. Overlappong Template Matching Test: \t\t\t\t', TemplateMatching.overlapping_patterns(binary_data[:1000000]))
print('2.9. Universal Statistical Test:\t\t\t\t\t\t', Universal.statistical_test(binary_data[:1000000]))
print('2.10. Linear Complexity Test:\t\t\t\t\t\t\t', ComplexityTest.linear_complexity_test(binary_data[:1000000]))
print('2.11. Serial Test:\t\t\t\t\t\t\t\t\t\t', Serial.serial_test(binary_data[:1000000]))
print('2.12. Approximate Entropy Test:\t\t\t\t\t\t\t', ApproximateEntropy.approximate_entropy_test(binary_data[:1000000]))
print('2.13. Cumulative Sums (Forward):\t\t\t\t\t\t', CumulativeSums.cumulative_sums_test(binary_data[:1000000], 0))
print('2.13. Cumulative Sums (Backward):\t\t\t\t\t\t', CumulativeSums.cumulative_sums_test(binary_data[:1000000], 1))
result = RandomExcursions.random_excursions_test(binary_data[:1000000])
print('2.14. Random Excursion Test:')
print('\t\t STATE \t\t\t xObs \t\t\t\t P-Value \t\t\t Conclusion')
for item in result:
print('\t\t', repr(item[0]).rjust(4), '\t\t', item[1], '\t\t', repr(item[2]).ljust(14), '\t\t',
(item[3] >= 0.01))
result = RandomExcursions.variant_test(binary_data[:1000000])
print('2.15. Random Excursion Variant Test:\t\t\t\t\t\t')
print('\t\t STATE \t\t COUNTS \t\t\t P-Value \t\t Conclusion')
def execute(self):
print('Execute')
input = ''
self.__test_results = [(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),()]
if (not len(self.__binary_data.get().strip()) == 0) and (not len(self.__file_name.get()) == 0):
messagebox.showwarning("Warning", 'You can only either input the binary data or read the data from from the file.')
elif not len(self.__binary_data.get().strip()) == 0:
print('User Input')
input = self.__binary_data.get()
elif not len(self.__file_name.get()) == 0:
print('File Input')
print(self.__file_name.get())
handle = open(self.__file_name.get())
data_list = []
for line in handle:
data_list.append(line.strip().rstrip())
input = ''.join(data_list)
else:
messagebox.showwarning("Warning", 'You must enter either input data or file name to read before you can execute the test.')
if len(input) > 1000000:
input = input[:1000000]
checked = False
for item in self.__chb_var:
if item.get() == 1:
checked = True
break
if not checked:
messagebox.showwarning("Warning", "you must select a test to execute")
else:
if self.__chb_var[0].get() == 1:
print(self.__test_type[0], 'selected.')
result = ft.monobit_test(input)
self.__monobit_p_value.set(result[0])
self.__monobit_result.set(self.get_conclusion(result[1]))
self.__test_results[0] = result
if self.__chb_var[1].get() == 1:
print(self.__test_type[1], 'selected.')
result = ft.block_frequency(input)
self.__block_p_value.set(result[0])
self.__block_result.set(self.get_conclusion(result[1]))
self.__test_results[1] = result
if self.__chb_var[2].get() == 1:
print(self.__test_type[2], 'selected.')
result = rt.run_test(input)
self.__run_p_value.set(result[0])
self.__run_result.set(self.get_conclusion(result[1]))
self.__test_results[2] = result
if self.__chb_var[3].get() == 1:
print(self.__test_type[3], 'selected.')
result = rt.longest_one_block_test(input)
self.__long_run_p_value.set(result[0])
self.__long_run_result.set(self.get_conclusion(result[1]))
self.__test_results[3] = result
if self.__chb_var[4].get() == 1:
print(self.__test_type[4], 'selected.')
result = mt.binary_matrix_rank_text(input)
self.__matrix_p_value.set(result[0])
self.__matrix_result.set(self.get_conclusion(result[1]))
self.__test_results[4] = result
if self.__chb_var[5].get() == 1:
print(self.__test_type[5], 'selected.')
result = st.sepctral_test(input)
self.__spectral_p_value.set(result[0])
self.__spectral_result.set(self.get_conclusion(result[1]))
self.__test_results[5] = result
if self.__chb_var[6].get() == 1:
print(self.__test_type[6], 'selected.')
result = tm.non_overlapping_test(input)
self.__non_overlapping_p_value.set(result[0])
self.__non_overlapping_result.set(self.get_conclusion(result[1]))
self.__test_results[6] = result
if self.__chb_var[7].get() == 1:
print(self.__test_type[7], 'selected.')
result = tm.overlapping_patterns(input)
self.__overlapping_p_value.set(result[0])
self.__overlapping_result.set(self.get_conclusion(result[1]))
self.__test_results[7] = result
if self.__chb_var[8].get() == 1:
print(self.__test_type[8], 'selected.')
result = ut.statistical_test(input)
self.__statistical_p_value.set(result[0])
self.__statistical_result.set(self.get_conclusion(result[1]))
self.__test_results[8] = result
if self.__chb_var[9].get() == 1:
print(self.__test_type[9], 'selected.')
result = ct.linear_complexity_test(input)
self.__linear_p_value.set(result[0])
self.__linear_result.set(self.get_conclusion(result[1]))
self.__test_results[9] = result
if self.__chb_var[10].get() == 1:
print(self.__test_type[10], 'selected.')
result = serial.serial_test(input)
self.__serial_p_value_01.set(result[0][0])
self.__serial_p_result_01.set(self.get_conclusion(result[0][1]))
self.__serial_p_value_02.set(result[1][0])
self.__serial_p_result_02.set(self.get_conclusion(result[1][1]))
self.__test_results[10] = result
if self.__chb_var[11].get() == 1:
print(self.__test_type[11], 'selected.')
result = aet.approximate_entropy_test(input)
self.__entropy_p_value.set(result[0])
self.__entropy_result.set(self.get_conclusion(result[1]))
self.__test_results[11] = result
if self.__chb_var[12].get() == 1:
print(self.__test_type[12], 'selected.')
result = cst.cumulative_sums_test(input, 0)
self.__cusum_f_p_value.set(result[0])
self.__cusum_f_result.set(self.get_conclusion(result[1]))
self.__test_results[12] = result
if self.__chb_var[13].get() == 1:
print(self.__test_type[13], 'selected.')
result = cst.cumulative_sums_test(input, 1)
self.__cusum_r_p_value.set(result[0])
self.__cusum_r_result.set(self.get_conclusion(result[1]))
self.__test_results[13] = result
if self.__chb_var[14].get() == 1:
print(self.__test_type[14], 'selected.')
self.__excursion_result = ret.random_excursions_test(input)
for item in self.__excursion_result:
if self.__state_01.get() == item[0]:
self.__xObs_chi_01.set(item[2])
self.__p_value_01.set(item[3])
self.__conclusion_01.set(self.get_conclusion(item[4]))
self.__test_results[14] = self.__excursion_result
if self.__chb_var[15].get() == 1:
print(self.__test_type[15], 'selected.')
__variant_result = ret.variant_test(input)
self.__variant_result = ret.variant_test(input)
for item in self.__variant_result:
print(item)
if self.__state_02.get() == item[0]:
self.__count.set(item[2])
self.__p_value_02.set(item[3])
self.__conclusion_02.set(self.get_conclusion(item[4]))
self.__test_results[15] = self.__variant_result
from Serial import Serial
s = Serial(debug=True)
for i in s.devices:
if "hmp2030" in s.devices[i].device_id.lower():
while 1:
s.devices[0].write("SYSTem:BEEPer[:IMMediate]")
from Database import Database
import json
import pigpio
GPIO.setmode(GPIO.BCM)
# INIT THE APP
app = Flask(__name__)
# SETTINGS
CORS(app)
app.config['SECRET_KEY'] = 'Secret!'
socket = SocketIO(app)
conn = Database(app=app, user='******', password='******', db='mydb')
Serial()
CheckPawns(socket, conn)
ledColor = '00FFFF'
ledMode = 'auto'
ledPins = [5, 17, 27]
piGPIO = pigpio.pi()
for i in range(3):
piGPIO.set_PWM_frequency(ledPins[i], 500)
piGPIO.set_PWM_dutycycle(ledPins[i], 0)
@socket.on('connect')
def connect():
import cv2
import time
from TrafficLightDetection import *
from Serial import Serial
print('Start Capture')
# initialize serial connection
ser = Serial()
# start the video capture
camera = cv2.VideoCapture(0)
# initialize variables for traffic light detection
# loop: initial state TRUE to run the loop and FALSE to stop the loop
# traffic_light: initial state red = FALSE and green = TRUE
# emergency_counter: a counter to prevent the pink panzer form never starting
# even if no signal from the traffic light can be detected
loop = True
traffic_light = 'ps'
emergency_counter = 0
# looping while video capture is active
if (camera.isOpened()):
while (loop):
# if the counter reaches 500, the go siganl will be given
# regardless of the traffic light
if (emergency_counter < 500):
print(traffic_light)
def __init__(self, Admission_Control):
self.admission_control = Admission_Control
self.serial = Serial(self)
RunTest.longest_one_block_test(binary_data[:1000000]))
print('2.05. Binary Matrix Rank Test:\t\t\t\t\t\t',
Matrix.binary_matrix_rank_text(binary_data[:1000000]))
print('2.06. Discrete Fourier Transform (Spectral) Test:\t',
SpectralTest.sepctral_test(binary_data[:1000000]))
print(
'2.07. Non-overlapping Template Matching Test:\t\t',
TemplateMatching.non_overlapping_test(binary_data[:1000000], '000000001'))
print('2.08. Overlappong Template Matching Test: \t\t\t',
TemplateMatching.overlapping_patterns(binary_data[:1000000]))
print('2.09. Universal Statistical Test:\t\t\t\t\t',
Universal.statistical_test(binary_data[:1000000]))
print('2.10. Linear Complexity Test:\t\t\t\t\t\t',
ComplexityTest.linear_complexity_test(binary_data[:1000000]))
print('2.11. Serial Test:\t\t\t\t\t\t\t\t\t',
Serial.serial_test(binary_data[:1000000]))
print('2.12. Approximate Entropy Test:\t\t\t\t\t\t',
ApproximateEntropy.approximate_entropy_test(binary_data[:1000000]))
print('2.13. Cumulative Sums (Forward):\t\t\t\t\t',
CumulativeSums.cumulative_sums_test(binary_data[:1000000], 0))
print('2.13. Cumulative Sums (Backward):\t\t\t\t\t',
CumulativeSums.cumulative_sums_test(binary_data[:1000000], 1))
result = RandomExcursions.random_excursions_test(binary_data[:1000000])
print('2.14. Random Excursion Test:')
print('\t\t STATE \t\t\t xObs \t\t\t\t P-Value \t\t\t Conclusion')
for item in result:
print('\t\t',
repr(item[0]).rjust(4), '\t\t', item[2], '\t\t',
repr(item[3]).ljust(14), '\t\t', (item[4] >= 0.01))
def set_admission_control(self, admission_control):
self.admission_control = admission_control
self.serial = Serial()
self.serial.set_serial_manager(self)
class BleuettePi(Serial):
INTA = 26
INTB = 15
INTC = 22
INTD = 12
STATUS_MAX_CURRENT_REACHED = 0
MCP_ADDRESS = 0x20
RESET_PIN = 14
serial = None
mcp = None
Servo = None
Compass = None
Accelerometer = None
GroundSensor = None
def __init__(self, serialDev):
self.logger = logging.getLogger('BleuettePi')
self.serial = Serial()
self.serial.connect(serialDev)
self.mcp = MCP230XX(self.MCP_ADDRESS, 16)
self.Servo = Servo.Servo(self.serial, fakemode=Config.FAKE_MODE)
self.Servo.init()
Servo.Servo_Trim.values = Data.Instance().get(['servo', 'trims'])
Servo.Servo_Limit.values = Data.Instance().get(['servo', 'limits'])
self.Analog = Analog(self.serial)
self.Compass = BleuettePi_Compass()
self.Accelerometer = BleuettePi_Accelerometer()
self.GroundSensor = BleuettePi_GroundSensor(self.mcp)
# Init mode
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.INTA, GPIO.IN)
GPIO.setup(self.INTB, GPIO.IN)
GPIO.setup(self.INTC, GPIO.IN)
GPIO.setup(self.INTD, GPIO.IN)
GPIO.add_event_detect(self.INTA,
GPIO.RISING,
callback=self.interrupt,
bouncetime=300)
GPIO.add_event_detect(self.INTB,
GPIO.RISING,
callback=self.interrupt,
bouncetime=300)
GPIO.add_event_detect(self.INTC,
GPIO.RISING,
callback=self.interrupt,
bouncetime=300)
GPIO.add_event_detect(self.INTD,
GPIO.RISING,
callback=self.interrupt,
bouncetime=300)
self.mcp.config(self.RESET_PIN, MCP230XX.OUTPUT)
#self.mcp.pullup(self.RESET_PIN, True)
self.mcp.output(self.RESET_PIN, 1)
def interrupt(self, index):
if index == self.INTA:
self.logger.info("Interrupt from GPA")
elif index == self.INTB:
self.logger.info("Interrupt from GPB")
elif index == self.INTC:
self.logger.info("Interrupt from RTC")
elif index == self.INTD:
self.logger.info("Interrupt from PIC")
self.getStatus()
'''
def setCurrentAlarmLevel(self, level):
print "Level", level
if level >= 1024:
raise Exception('Max current alarm level is 1024 !')
data = struct.pack("@i", level)
level = [ data[0], data[1] ]
return self.command(BPi_Cmd.SET_MAX, level)
'''
# Hard reset
def reset(self):
self.mcp.output(self.RESET_PIN, 0)
time.sleep(1)
self.mcp.output(self.RESET_PIN, 1)
time.sleep(1)
self.Servo.init()
def getStatus(self):
self.serial.write(self.HEADER)
self.serial.write(BPi_Cmd.STATUS)
status = self.serial.read(1)
if ord(status) & (1 << self.STATUS_MAX_CURRENT_REACHED):
self.logger.warning("Max current reached !")
return status
old_data = data
# print("not movement")
# ui.textBrowser.setText("")
if __name__ == '__main__':
net = nn.loadFromFile("Neural_Networks/.neuralnetwork.pkl")
old_gesture = None
old_vector = 0
old_data = None
listening = False
serial = Serial("/dev/ttyUSB0")
# reset Arduino
serial.setDTR(False)
serial.flushInput()
serial.setDTR(True)
serial.start()
# tick = perf_counter()
# serial.serialEvent.connect(shift_frame)
# serial.serialEvent.connect(print)
serial.serialEvent.connect(test_movement)
frame = deque(maxlen=360)
app = QtWidgets.QApplication(sys.argv)
def detect_light(self):
print('Start Capture')
# initialize serial connection
ser = Serial()
# start the video capture
camera = cv2.VideoCapture(1)
# Load an image
#frame = cv2.imread('images/ampel_red.png')
#frame = cv2.imread('images/ampel_green.png')
#frame = cv2.imread('images/color_gradient.png')
# Load a video
#camera = cv2.VideoCapture('videos/AmpelTest.mp4')
# initialize variables for traffic light detection
# loop: initial state TRUE to run the loop and FALSE to stop the loop
# traffic_light: initial state red = FALSE and green = TRUE
# emergency_counter: a counter to prevent the pink panzer form never starting
# even if no signal from the traffic light can be detected
loop = True
traffic_light = 's'
debug_mode = False
begin = datetime.datetime.now()
begin = begin+30
# looping while video capture is active
if (camera.isOpened()):
while (loop):
#Auskommentiert durch Lukas 30.06.2017
#print (traffic_light)
# grab the current frame
_, frame = camera.read()
# prepare the frame for color detection
prepped_frame = frame_prep(frame)
# set the color for color detection and create
# a mask by checking for red and green traffic lights
mask = color_detection(prepped_frame, 'green')
# find contours in the mask and initialize the current
# (x, y) center of the ball
contour = contour_detection(mask)
# give the go-signal when a matching contour was found
traffic_light = go_time(contour)
# stop the loop if it is go time
if (traffic_light == 'g'):
print (traffic_light)
print ('Green Light detected')
loop = False
if (debug_mode):
cv2.imshow('frame', frame)
cv2.imshow('prepped_frame', prepped_frame)
cv2.imshow('mask', mask)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
now = datetime.datetime.now()
if now > begin:
loop = False
else:
print('No Video Capture detected')
print ('Go Time')
camera.release()
cv2.destroyAllWindows()
ser.sendText(traffic_light)
def _init_serial(self):
ser = Serial("98:D3:32:70:8B:76")
return ser
rainbowHandler = RainbowLoggingHandler(sys.stdout)
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
rainbowHandler.setFormatter(formatter)
logger.addHandler(rainbowHandler)
logger.setLevel(logging.DEBUG)
if True:
obj = '/dev/ttyAMA0'
fake = False
else:
obj = SerialFake
fake = True
serial = Serial()
serial.connect(obj)
servo = Servo(serial, fakemode=fake)
#Servo.init()
#ServoSeq = Servo_Sequencer(servo)
#ServoSeq.daemon = True;
#ServoSeq.start()
engine = Servo_Engine(servo)
engine.start()
SPEED = 1
CONSIGNE = 170
from USBTMC import USBTMC
from GPIB import GPIB
from Serial import Serial
import time
import TermOut.Logging as Logging
usb = USBTMC()
gpib = GPIB()
serial = Serial()
devices = []
for i in usb.devices:
devices.append(usb.devices[i])
for i in gpib.devices:
devices.append(gpib.devices[i])
for i in serial.devices:
devices.append(serial.devices[i])
print(devices)
while 1:
k = 0
for i in devices:
Logging.info(i.get("*IDN?").rstrip())
k += 1
Logging.header("Got answer from %s devices." % str(k))
time.sleep(2)
def detect_light(self):
print('Start Capture')
# initialize serial connection
ser = Serial()
# start the video capture
camera = cv2.VideoCapture(1)
# Load an image
#frame = cv2.imread('images/ampel_red.png')
#frame = cv2.imread('images/ampel_green.png')
#frame = cv2.imread('images/color_gradient.png')
# Load a video
#camera = cv2.VideoCapture('videos/AmpelTest.mp4')
# initialize variables for traffic light detection
# loop: initial state TRUE to run the loop and FALSE to stop the loop
# traffic_light: initial state red = FALSE and green = TRUE
# emergency_counter: a counter to prevent the pink panzer form never starting
# even if no signal from the traffic light can be detected
loop = True
traffic_light = 's'
emergency_counter = 0
# looping while video capture is active
if (camera.isOpened()):
while (loop):
# if the counter reaches 200, the go siganl will be given
# regardless of the traffic light
if (emergency_counter < 200):
print(traffic_light)
# grab the current frame
_, frame = camera.read()
# prepare the frame for color detection
prepped_frame = frame_prep(frame)
# set the color for color detection and create
# a mask by checking for red and green traffic lights
mask = color_detection(prepped_frame, 'green')
# find contours in the mask and initialize the current
# (x, y) center of the ball
contour = contour_detection(mask)
# give the go-signal when a matching contour was found
traffic_light = go_time(contour)
# stop the loop if it is go time
if (traffic_light == 'g'):
print(traffic_light)
print('Green Light detected')
loop = False
# increase the emergency counter
emergency_counter += 1
cv2.imshow('frame', frame)
cv2.imshow('prepped_frame', prepped_frame)
cv2.imshow('mask', mask)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
else:
# stop the loop if the emergency counter reaches 100
# and set the traffic light variable accordingly
traffic_light = 'g'
loop = False
print(traffic_light)
print('Emergency Loop exeeded')
cv2.imshow('frame', frame)
cv2.imshow('prepped_frame', prepped_frame)
cv2.imshow('mask', mask)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
else:
print('No Video Capture detected')
print('Go Time')
camera.release()
cv2.destroyAllWindows()
ser.sendText(traffic_light)
isWorkingWithModem = True
isModemRequired = True
isACKwaiting = False
if REAL_TEST:
#subprocess.call(["sudo","pigpiod"])
pi = pigpio.pi()
#if not pi.connected:
# exit()
baudrate = int(Config.get('BAUDRATE'))
txPin = int(Config.get('TX_PIN'))
rxPin = int(Config.get('RX_PIN'))
modems = Serial(baudrate, txPin, rxPin)
ph_numb = Config.get('ALRM_NUMBS').split(",") #список телефонов для оповещения
fullInfo = '' #
lastUsedPhNumb = '' # телефон с которого пришёл запрос
modem_alive = False #флаг признака модема в рабочем состоянии
error_try = 0
modem_try = 0
MODEM_PWR_PIN = int(Config.get('MODEM_PWR_PIN'))
if REAL_TEST:
pi.set_mode(MODEM_PWR_PIN, pigpio.OUTPUT)
class BleuettePi(Serial):
INTA = 26
INTB = 15
INTC = 22
INTD = 12
STATUS_MAX_CURRENT_REACHED = 0
MCP_ADDRESS = 0x20
RESET_PIN = 14
serial = None
mcp = None
Servo = None
Compass = None
Accelerometer = None
GroundSensor = None
def __init__(self, serialDev):
self.logger = logging.getLogger('BleuettePi')
self.serial = Serial()
self.serial.connect(serialDev)
self.mcp = MCP230XX(self.MCP_ADDRESS, 16)
self.Servo = Servo.Servo(self.serial, fakemode = Config.FAKE_MODE)
self.Servo.init()
Servo.Servo_Trim.values = Data.Instance().get(['servo', 'trims'])
Servo.Servo_Limit.values = Data.Instance().get(['servo', 'limits'])
self.Analog = Analog(self.serial)
self.Compass = BleuettePi_Compass()
self.Accelerometer = BleuettePi_Accelerometer()
self.GroundSensor = BleuettePi_GroundSensor(self.mcp)
# Init mode
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.INTA, GPIO.IN)
GPIO.setup(self.INTB, GPIO.IN)
GPIO.setup(self.INTC, GPIO.IN)
GPIO.setup(self.INTD, GPIO.IN)
GPIO.add_event_detect(self.INTA, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTB, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTC, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTD, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
self.mcp.config(self.RESET_PIN, MCP230XX.OUTPUT)
#self.mcp.pullup(self.RESET_PIN, True)
self.mcp.output(self.RESET_PIN, 1)
def interrupt(self, index):
if index == self.INTA:
self.logger.info("Interrupt from GPA")
elif index == self.INTB:
self.logger.info("Interrupt from GPB")
elif index == self.INTC:
self.logger.info("Interrupt from RTC")
elif index == self.INTD:
self.logger.info("Interrupt from PIC")
self.getStatus()
'''
def setCurrentAlarmLevel(self, level):
print "Level", level
if level >= 1024:
raise Exception('Max current alarm level is 1024 !')
data = struct.pack("@i", level)
level = [ data[0], data[1] ]
return self.command(BPi_Cmd.SET_MAX, level)
'''
# Hard reset
def reset(self):
self.mcp.output(self.RESET_PIN, 0)
time.sleep(1)
self.mcp.output(self.RESET_PIN, 1)
time.sleep(1)
self.Servo.init()
def getStatus(self):
self.serial.write(self.HEADER)
self.serial.write(BPi_Cmd.STATUS)
status = self.serial.read(1)
if ord(status) & (1 << self.STATUS_MAX_CURRENT_REACHED):
self.logger.warning("Max current reached !")
return status
class MainWindow(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self)
self.autoSend = False # TODO: read config
self.incPrefix = False # TODO: read config
self.incStartVal = 0
self.autoSendTimes = 0
self.ui = Ui_Proxy()
self.flags = {"__isopen__": False, "__datatype__": config.ASCII_TYPE}
self.ui.setupUi(self)
self.ui.setupWidget(self)
self.tipWidget = TipWidget(self)
self.setupSignals()
self.filterParent = re.compile("")
def closeEvent(self, e):
if self.flags["__isopen__"]:
self.serial.terminate()
e.accept()
config.saveSettings(self.ui.getCurrentConfigDict())
def setupSignals(self):
self.ui.open_pushButton.clicked.connect(self.onOpenPort)
self.ui.updatePort_pushButton.clicked.connect(self.onUpdatePort)
self.ui.send_pushButton.clicked.connect(self.onSendData)
self.ui.clear_pushButton.clicked.connect(
self.ui.recv_TextBrowser.clear)
self.ui.autoSend_checkBox.stateChanged.connect(self.onAutoSend)
self.ui.sendType_comboBox.currentIndexChanged.connect(
self.ui.onSendTypeChanged)
self.ui.inc_checkBox.stateChanged.connect(
self.onIncCheckBoxStateChanged)
self.ui.resetStartVal_pushButton.clicked.connect(self.resetIncStartVal)
self.ui.clearLcdNumber_pushButton.clicked.connect(
self.ui.clearLcdNumber)
self.ui.about_action.triggered.connect(self.onAbout)
self.ui.settings_action.triggered.connect(self.onSettings)
self.ui.saveData_action.triggered.connect(self.onSaveData)
def openPort(self, settings=None):
if not settings:
settings = self.ui.getPortSettings()
if not settings["port"]:
return False, u"错误的串口号"
self.serial = Serial()
self.connect(self.serial.qtobj, QtCore.SIGNAL(Serial.SIG_NEWDATA),
self.onRecvData)
self.connect(self.serial.qtobj,
QtCore.SIGNAL(Serial.SIG_RECVEXCEPTION),
self.onRecvException)
ret, msg = self.serial.open(settings)
return ret, msg
def closePort(self):
self.serial.terminate()
self.ui.onPortClosed()
self.flags["__isopen__"] = False
def onOpenPort(self):
if self.flags["__isopen__"]:
return self.closePort()
self.ui.onPortOpening()
ret, msg = self.openPort()
if not ret:
QtGui.QMessageBox.critical(self, u"打开串口失败", u"设备正忙或已移除, 请重新尝试打开")
else:
self.flags["__isopen__"] = True
self.serial.start()
self.ui.onPortOpened()
def onUpdatePort(self):
newCount = self.ui.updatePortComBox(self.flags["__isopen__"])
self.tipWidget.makeInfoText(u"更新了 " + ` newCount ` + u" 个串口")
def onSendData(self):
if not self.flags["__isopen__"]:
return
data, _type = self.ui.getDataAndType()
ret, msg = util.checkData(data, _type)
if not ret:
QtGui.QMessageBox.critical(self, "Error", u"%s" % msg)
return
if self.autoSend:
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.onTimeout)
self.timer.start(self.ui.getAutoSendInterval())
self.ui.onAutoSendStarted()
else:
self.sendData()
def sendData(self):
data, _type = self.ui.getDataAndType()
ret, buff = DataManager.getDataToSend(data, _type,
self.ui.getAsciiTail())
if not ret:
QtGui.QMessageBox.critical(self, u"发送数据错误", buff)
return
# 以PB协议模式发送时, 在收发区显示协议编码后的HEX
if _type == config.ASCII_TYPE:
if self.incPrefix:
buff = ` self.incStartVal ` + buff
data = ` self.incStartVal ` + data
self.incStartVal += 1
self.ui.onSendData(unicode(data, "utf-8"), _type)
try:
self.serial.send(buff, _type)
self.ui.addTXBytesNumber(len(buff))
except Exception as e:
if self.autoSend:
self.ui.autoSend_checkBox.setChecked(False)
QtGui.QMessageBox.critical(self, "", u"发送失败, 可能串口已关闭")
def onRecvData(self, nData):
self.ui.addRXBytesNumber(len(nData))
text = DataManager.getVisualizedData(nData, self.ui.getRecvType())
if self.filterParent.match(text):
self.ui.onRecvData(text)
def onRecvException(self):
QtGui.QMessageBox.critical(self, u"接收异常",
u"串口设备故障或已移除\n请先排查问题，再尝试请新打开串口")
self.onOpenPort()
# TODO: 更新串口列表
def onAutoSend(self, status):
self.autoSend = status == 2
self.ui.onAutoSend(status)
self.autoSendTimes = 0
def onIncCheckBoxStateChanged(self, status):
self.incPrefix = status == 2
def resetIncStartVal(self):
self.incStartVal = 0
def onTimeout(self):
if not self.autoSend:
self.timer.stop()
del self.timer
return
self.sendData()
self.autoSendTimes += 1
self.ui.updateAutoSendTimes(self.autoSendTimes)
def onSettings(self):
value, ret = QtGui.QInputDialog.getInt(self, u"数据合并",
u"合并指定时间(毫秒)内收到的数据 ",
config.mergeInterval)
if not ret:
return
if value > 20:
ret = QtGui.QMessageBox.question(self, u"提醒", u"过长的时间可能会造成数据丢失",
u"仍要设置", u"放弃设置")
if ret != 0:
return
if value >= 0:
config.mergeInterval = value
def onSaveData(self):
fileName = QtGui.QFileDialog.getSaveFileName(self, u"保存数据", "",
"Data File(*.txt)")
if fileName == "":
return
if not util.writeToFile(fileName, self.ui.getRecvWidgetContent()):
QtGui.QMessageBox.critical(self, u"错误", u"保存文件失败")
def onAbout(self):
QtGui.QMessageBox.information(self, u"关于", config.ABOUT_MESSAGE)
from Serial import Serial
from RCRFile import File
from Analytics import Analytics
#Don't forget to update the serial port location!!
serial_port = Serial('COM8')
header = ["time", "response"]
data_file = File(header=header)
serial_port.listen_and_log(data_file)
Analytics.sr_test(data_file)
data_file.close()
try:
while True:
pass
except KeyboardInterrupt:
pass
class BleuettePi(Serial):
INTA = 26
INTB = 15
INTC = 22
INTD = 12
STATUS_MAX_CURRENT_REACHED = 0
serial = None
Compass = None
Accelerometer = None
GroundSensor = None
def __init__(self, mixed):
self.serial = Serial()
self.serial.connect(mixed)
self.Servo = Servo(self.serial, fakemode = Config.FAKE_MODE)
self.Analog = Analog(self.serial)
self.Compass = BleuettePi_Compass()
self.Accelerometer = BleuettePi_Accelerometer()
self.GroundSensor = BleuettePi_GroundSensor()
# Init mode
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.INTA, GPIO.IN)
GPIO.setup(self.INTB, GPIO.IN)
GPIO.setup(self.INTC, GPIO.IN)
GPIO.setup(self.INTD, GPIO.IN)
GPIO.add_event_detect(self.INTA, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTB, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTC, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
GPIO.add_event_detect(self.INTD, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
def interrupt(self, index):
if index == self.INTA:
print "Interrupt from GPA"
elif index == self.INTB:
print "Interrupt from GPB"
elif index == self.INTC:
print "Interrupt from RTC"
elif index == self.INTD:
print "Interrupt from PIC !"
self.getStatus()
'''
def setCurrentAlarmLevel(self, level):
print "Level", level
if level >= 1024:
raise Exception('Max current alarm level is 1024 !')
data = struct.pack("@i", level)
level = [ data[0], data[1] ]
return self.command(BPi_Cmd.SET_MAX, level)
'''
def getStatus(self):
self.serial.write(self.HEADER)
self.serial.write(BPi_Cmd.STATUS)
status = self.serial.read(1)
if ord(status) & (1 << self.STATUS_MAX_CURRENT_REACHED):
print "Max current reached !"
return status
