def test_boleta():
channel = init_channel()
agent = Agent(channel)
init = agent.initialize()
printer = Printer(channel)
rfid = RFID(channel)
device = Device(channel)
printer = Printer(channel)
print('set autofeed')
printer.set_autofeed(True, -128)
printer.register_paper_inserted()
while True:
levels = []
esperar_evento(device, DEV_PRINTER, EVT_PRINTER_PAPER_INSERTED)
for i in range(10):
tags_data = rfid.get_tags()[0]
if tags_data['number'] == 1:
rec_level = tags_data['reception_level'][0][0]
levels.append(rec_level)
#serial_number = tags_data['serial_number'][0]
#blocks_to_write = [
# "hola", "lipe", "chau", "chan", "pato", "mono", "juan",
# "gato", "casa", "masa", "pasa", "gabi", "aaaa", "bbbb",
# "cccc", "dddd", "eeee", "ffff","gggg", "hhhh", "iiii",
# "jjjj", "kkkk", "llll", "mmmm", "nnnn", "oooo"]
#rfid.write_blocks(serial_number, 0, 26, blocks_to_write)
sleep(0.2)
if len(levels):
data = max(levels), min(levels), sum(levels)/len(levels)
print(">>> Recepcion Minima %s, Maxima %s, Promedio %s" % data)
printer.paper_eject()
def connect_and_load(self):
self.buffer = self._init_channel()
if self.buffer is not None:
logger.debug("Canal Inicializado")
logger.debug("Flusheando buffer")
self._flush_all(self.buffer)
logger.debug("Creando agent")
self.agent = Agent(self.buffer)
if not self.agent:
self._conn = False
return self.connection(self._conn)
sleep(1)
self.initialize()
def test_boleta():
channel = init_channel()
agent = Agent(channel)
init = agent.initialize()
rfid = RFID(channel)
device = Device(channel)
rfid.register_new_tag()
while True:
tags_data = esperar_evento(device, DEV_RFID, EVT_RFID_NEW_TAG)
for serial_number in tags_data[0]['serial_number']:
blocks_to_write = ["\x00\x00\x00\x00"] * 28
rfid.write_blocks(serial_number, 0, 27, blocks_to_write)
def read_and_process(device, channel):
"""Lee la informacion del dispositivo y la procesa."""
# cambiar esta linea por el codigo que lee el canal
#mock_arm(channel)
if channel is None:
channel = init_channel()
agent = Agent(channel)
agent.unregister_events()
channel.flushInput()
channel.flushOutput()
data = channel.read()
#processed_data = device._process(data)
#print "(con)<<<", processed_data
#return processed_data
print data
def test_boleta():
channel = init_channel()
agent = Agent(channel)
init = agent.initialize()
printer = Printer(channel)
rfid = RFID(channel)
device = Device(channel)
#esperar_evento(device, DEV_PRINTER, EVT_PRINTER_PAPER_INSERTED)
#print rfid.get_multitag_data()
tags_data = rfid.get_tags()[0]
serial_number = tags_data['serial_number'][0]
rfid.write_tag(
serial_number, 4, "1C",
"--00--01--02--03--04--05--06--07--08--09--10--11--12"
"--13--14--15--16--17--18--19--20--21--22--23--24--25"
"--26--27--28--29--30--31--32--33--34--35--36--37--38"
"--39--40--41--42--43--44--45--46--47--48--49--50--51")
rfid.get_multitag_data()
def test_movimiento_y_eventos():
channel = init_channel()
printer = Printer(channel)
device = Device(channel)
agent = Agent(channel)
agent.unregister_events()
for j in range(20):
if not printer.has_paper():
printer.register_paper_inserted()
esperar_evento(device, DEV_PRINTER, EVT_PRINTER_PAPER_INSERTED)
else:
printer.register_paper_start()
printer.paper_start()
esperar_evento(device, DEV_PRINTER, CMD_PRINTER_PAPER_START)
for i in range(1, 1500, 300):
printer.register_move()
printer.move(i)
esperar_evento(device, DEV_PRINTER, CMD_PRINTER_MOVE)
printer.register_move()
printer.move(-i)
esperar_evento(device, DEV_PRINTER, CMD_PRINTER_MOVE)
printer.paper_eject()
def test_boleta():
channel = init_channel()
agent = Agent(channel)
init = agent.initialize()
free_page_mem = init[0]['free_page_mem']
# free_page_mem = 50740
printer = Printer(channel)
rfid = RFID(channel)
device = Device(channel)
print 'set autofeed'
printer.set_autofeed(True, -120)
for i in range(1, 2):
# print 'unregister events'
# agent.unregister_events()
channel.flushInput()
channel.flushOutput()
print "___ITERACION %d___" % i
print "!!!!-> testeando status de papel"
paper_in = False
# print "!!!!-> limpiando buffer"
# inicio = time()
# printer.clear_buffer()
# print "!!!!-> tiempo transcurrido de clear_buffer", time() - inicio
while not paper_in:
paper_in = printer.has_paper()
sleep(1)
print "!!!!-> papel_encontrado"
print "registro eventos eventuales mover y eject"
printer.register_move() # eventual
printer.register_paper_eject() # eventual
printer.register_print_finished() # eventual
#test_rfid(channel, False)
#buffer_file_cmp(printer, 'boleta2.png')#'voto.prn')
print "!!!!-> cargando buffer de impresion"
inicio = time()
img = Image.open('testeo_form.png')
#img = Image.open('boleta2.png')
data = img.getdata()
# Impresión comprimida do_print=True
# printer.load_buffer_compressed(data, 10000, print_immediately=True, clear_buffer=True)
# printer.load_buffer_compressed(data, free_page_mem, print_immediately=True, clear_buffer=False)
# printer.load_buffer_compressed(data, free_page_mem, print_immediately=True)
# printer.load_buffer_compressed_fast(data)
# printer.load_buffer_compressed(data, 0, print_immediately=True)
# Fin ejemplo do_print=True
# Impresión comprimida do_print=False
printer.register_load_buffer_compressed()
printer.load_buffer_compressed(data, free_page_mem)
# printer.load_buffer_compressed_fast(data)
print "!!!!-> tiempo transcurrido de buffer de impresion", time(
) - inicio
inicio = time()
esperar_evento(device, DEV_PRINTER, CMD_PRINTER_LOAD_COMP_BUFFER)
print "!!!!-> tiempo transcurrido de listo para impresion", time(
) - inicio
printer.do_print()
# Fin ejemplo do_print=False
esperar_evento(device, DEV_PRINTER, CMD_PRINTER_PRINT)
print "!!!!-> tiempo transcurrido de impresion", time() - inicio
print "eventos"
agent.list_events()
printer.move(350)
print "!!!!-> Esperando evento de mover papel"
esperar_evento(device, DEV_PRINTER, CMD_PRINTER_MOVE)
printer.paper_eject()
print "!!!!-> Esperando evento de papel expulsado"
esperar_evento(device, DEV_PRINTER, CMD_PRINTER_PAPER_REMOVE)
def test_rfid(channel=None, quemar=False):
if channel is None:
channel = init_channel()
agent = Agent(channel)
agent.unregister_events()
channel.flushInput()
channel.flushOutput()
rfid = RFID(channel)
device = Device(channel)
print "!!!!-> limpiando buffer de RFID"
inicio = time()
rfid.clear_buffer()
print "!!!!-> tiempo transcurrido de clear_buffer", time() - inicio
tags = rfid.get_tags()
if tags[0]['number'] == 0:
rfid.register_new_tag()
print 'esperando evento...'
esperar_evento(device, DEV_RFID, EVT_RFID_NEW_TAG)
print 'gotcha!'
tags = rfid.get_tags()
serial_number = tags[0]['serial_number'][0]
print "!!!->SERIAL", serial_number
serial_number = array_to_string(serial_number)
#rfid.select_tag(serial_number)
#serial_number = "\x00"*8
blocks = rfid.read_blocks(serial_number, 0, 4)
print "!!!-> read blocks:", blocks_to_string(blocks[0])
blocks_to_write = [
"hola", "lipe", "chau", "chan", "pato", "mono", "juan", "gato", "casa",
"masa", "pasa", "gabi", "aaaa", "bbbb", "cccc", "dddd", "eeee", "ffff",
"gggg", "hhhh", "iiii", "jjjj", "kkkk", "llll", "mmmm", "nnnn", "oooo"
]
rfid.write_blocks(serial_number, 0, 26, blocks_to_write)
blocks = rfid.read_blocks(serial_number, 0, 26)
read_blocks = blocks_to_string(blocks[0])
if read_blocks == blocks_to_write:
print "!!!!-> test de escritura de bloques pasado"
else:
print "!!!!-> test de escritura de bloques NO pasado!!!!!!"
blocks_to_write.reverse()
for i, block_to_write in enumerate(blocks_to_write):
rfid.write_block(serial_number, i, block_to_write)
blocks = rfid.read_blocks(serial_number, 0, 26)
read_blocks = blocks_to_string(blocks[0])
if read_blocks == blocks_to_write:
print "!!!!-> test de escritura de bloque pasado"
else:
print "!!!!-> test de escritura de bloque NO pasado!!!!!!"
if quemar:
write_status = rfid.is_read_only(serial_number, 0, 26)
rfid.set_read_only_blocks(serial_number, 0, 20)
rfid.set_read_only_block(serial_number, 26)
write_status = rfid.is_read_only(serial_number, 0, 27)
write_status = [block.byte for block in write_status[0]]
expected = [
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
0, 0, 0, 0, 1, 0
]
if write_status == expected:
print "test de quemado OK"
else:
print "test de quemado FAIL"
else:
print "ojo que no estoy quemando"
def test_eventos():
channel = init_channel()
device = Device(channel)
agent = Agent(channel)
batt = PowerManager(channel)
printer = Printer(channel)
rfid = RFID(channel)
pir = PIR(channel)
batt.register_battery_discharge()
batt.register_battery_unplugged()
batt.register_switch_ac()
batt.register_battery_empty()
batt.register_battery_level_critical()
batt.register_battery_level_max()
batt.register_battery_level_min()
printer.register_paper_eject()
printer.register_paper_start()
printer.register_paper_inserted()
printer.register_paper_out_1()
printer.register_paper_out_2()
printer.register_lever_open()
pir.register_detected()
pir.register_not_detected()
rfid.register_new_tag(100)
try:
while True:
event = agent.list_events()
if event is not None:
if hasattr(event[0], "event"):
event = event[0].event
#print "eventos", event
status = batt.get_status()[0]['batt_data'][0]
#print status
print "remaining %s/%s (%s)" % (status['remaining'],
status['full_charge'],
status['corriente'])
ret = device.read()
if ret is not None:
print ret
print "device", device._devices.get(ret[1])
print device.get_device_instance(ret[1])._command_dict.get(
ret[2])
#sleep(2)
except KeyboardInterrupt:
print "Desregistrando eventos"
batt.unregister_battery_discharge()
batt.unregister_battery_unplugged()
batt.unregister_switch_ac()
batt.unregister_battery_empty()
batt.unregister_battery_level_critical()
batt.unregister_battery_level_max()
batt.unregister_battery_level_min()
printer.unregister_paper_eject()
printer.unregister_paper_start()
printer.unregister_paper_inserted()
printer.unregister_paper_out_1()
printer.unregister_paper_out_2()
printer.unregister_lever_open()
pir.unregister_detected()
pir.unregister_not_detected()
rfid.unregister_new_tag()
sleep(2)
print "eventos", agent.list_events()[0].event
agent.unregister_events()
sleep(2)
print "eventos", agent.list_events()[0].event
print 'Error', str(e)
# Inicialización del Channel (Puerto Serie)
port = get_arm_port()
if not port:
port = '/tmp/ttyACM0' # pruebo un puerto remoto
channel = Serial(port, timeout=3)
if not channel.isOpen():
channel.open()
channel.flushInput()
channel.flushOutput()
# Objetos disponibles
dev = Device(channel)
agent = Agent(channel)
batt = PowerManager(channel)
printer = Printer(channel)
rfid = RFID(channel)
backlight = Backlight(channel)
fan = FanCoolers(channel)
pir = PIR(channel)
buzzer = Buzzer(channel)
print """\nObjetos disponibles:
- agent
- batt
- printer
- rfid
- backlight
- fan
