def read_tags_worker(queue_of_tags: Queue):
"""
"""
reader = mercury.Reader("tmr:///dev/ttyS4", baudrate=115200)
reader.set_region("NA2")
reader.set_read_plan([1], "GEN2", read_power=500)
try:
logger.info("Read Worker is Attempting to read")
while True:
try:
tags = reader.read(timeout=250)
except RuntimeError:
pass
if len(tags) != 0:
for tag in tags:
queue_of_tags.put(tag.epc)
sleep(.25)
except KeyboardInterrupt:
logger.info("keyboard interrupt in Read Worker")
finally:
logger.info("Read Worker done reading")
reader.stop_reading()
queue_of_tags.close()
def readerThread(tempo):
reader = mercury.Reader(rfid[0], baudrate=rfid[5])
reader.set_region(rfid[1])
reader.set_read_plan(rfid[2], rfid[3], read_power=rfid[4])
reader.start_reading(lambda tag: tagFilter(
tag.epc.decode(), datetime.fromtimestamp(tag.timestamp)))
time.sleep(tempo)
reader.stop_reading()
def init_tag_reader():
global greader
#greader = mercury.Reader("tmr:///dev/ttyUSB0", baudrate=115200)
greader = mercury.Reader("tmr:///dev/ttyUSB0", baudrate=19200)
print(greader.get_model())
print(greader.get_supported_regions())
greader.set_region("JP")
greader.set_read_plan([1], "GEN2", read_power=2200)
def readerThreadRfid():
global reader
reader = mercury.Reader(rfid[0], baudrate=rfid[5])
reader.set_region(rfid[1])
reader.set_read_plan(rfid[2], rfid[3], read_power=rfid[4])
reader.start_reading(lambda tag: tagFilter(
tag.epc.decode(), datetime.fromtimestamp(tag.timestamp)))
time.sleep(40)
print('Thread encerrada')
return
def initialize(self):
self.nano = mercury.Reader(self.portName, baudrate=115200)
self.nano.set_region(self.region)
self.nano.set_read_plan([self.antenna],
self.tagsType,
read_power=self.readPower)
print(self.nano.get_power_range())
print(self.nano.get_model())
print(self.nano.get_read_powers())
self.previousEpc = ""
def __init__(self, bin_type):
"""
Contructor
:param bin_type: bin number
"""
Thread.__init__(self)
self.read_tags = []
self.bin_type = bin_type
"""
Bin number :
1 -> Organic waste
2 -> Non-recyclable waste
3 -> Recyclable waste
"""
if self.bin_type == 1:
self.reader = mercury.Reader(os.getenv("READER_BLUE"))
self.list = tag_list.ORGANIC_TAG
self.url_ok = os.getenv("GAME_SERV_URL") + "score-blue-ok-add1"
self.url_ko = os.getenv("GAME_SERV_URL") + "score-blue-ko-add1"
elif self.bin_type == 2:
self.reader = mercury.Reader(os.getenv("READER_GREEN"))
self.list = tag_list.NON_RECYCLABLE_TAG
self.url_ok = os.getenv("GAME_SERV_URL") + "score-green-ok-add1"
self.url_ko = os.getenv("GAME_SERV_URL") + "score-green-ko-add1"
elif self.bin_type == 3:
self.reader = mercury.Reader(os.getenv("READER_YELLOW"))
self.list = tag_list.RECYCLABLE_TAG
self.url_ok = os.getenv("GAME_SERV_URL") + "score-yellow-ok-add1"
self.url_ko = os.getenv("GAME_SERV_URL") + "score-yellow-ko-add1"
# Set reader configuration
self.reader.set_region("EU3")
self.reader.set_read_plan([1],
"GEN2",
read_power=int(os.getenv("READER_POWER")))
# Set new event loop in this thread
asyncio.set_event_loop(asyncio.new_event_loop())
self.loop = asyncio.get_event_loop()
def run(self):
try:
reader = mercury.Reader(self.serial, baudrate=self.baudrate)
reader.set_region(self.region)
reader.set_read_plan([self.antenna],
self.protocol,
read_power=self.frequency)
self.reader = reader
# self.controller.set_sensor(self)
except:
print(
f"{bcolors.RED}Não foi possível conectar à placa...{bcolors.COLOR_OFF}"
)
finally:
self.controller.set_sensor(self)
def get(data):
global tags
global restAPI
data = data.split(':')
if (data[0] == 'autorama/cars'):
reader = mercury.Reader(rfid[0])
reader.set_region(rfid[1])
reader.set_read_plan(rfid[2], rfid[3], read_power=rfid[4])
epcs = map(lambda t: t.epc.decode(), reader.read())
tag = list(epcs)
tagsString = tagToString(tag)
clientSocket.send(bytes(tags[0], 'utf-8'))
elif (data[0] == 'autorama/startQualify'):
readerQualify(restAPI['route'])
elif (data[0] == 'autorama/startRace'):
readerRace(restAPI['route'])
else:
return
def main():
connected = False
# Attempt to establish a connection to the reader. Occasionally, the reader
# fails to connect on the first try, at which point the merucy API will
# throw a TypeError indicating the reader timed out. If we catch a
# TypeError, we'll sleep for a second and try again until it connects.
while not connected:
try:
print(
"Connecting to Simultaneous RFID Reader on device: {}".format(
DEVICE))
reader = mercury.Reader("tmr://{}".format(DEVICE))
connected = True
print("Connected.")
except TypeError as e:
print("Got a TypeError exception: {}, retrying in 1 second".format(
e))
time.sleep(1)
# Set the Region of Operation for the RFID reader to the
reader.set_region("NA2")
# Create a read plan for the protocol and the antennas we'll be using.
reader.set_read_plan(ANTENNAS, PROTOCOL)
# We're going to be doing continuous asynchronous reads, so setup the
# callback to be used when a tag is found.
reader.start_reading(found_tag, on_time=250, off_time=250)
# Keep looking for tags until we get a Ctrl-C, then exit.
print("Looking for RFID tags; Press Ctrl-C to exit")
try:
while 1:
print("Waiting for an RFID tag...")
time.sleep(1)
except KeyboardInterrupt:
print("Ctrl-C pressed; Shutting down RFID reader.")
# Shutdown the reader and antenna.
reader.stop_reading()
print("Done.")
def connect_to_reader(path = READER_PATH, max_port = 10):
"""
Configure ThingMagic RFID Reader.
Args:
max_port: int, attempts to connect to the path[0-max_port]. For example, tmr:///dev/ttyUSB4
Returns:
[response_codes.Response_Codes, mercury.Reader, str]
"""
conn_port = 0
reader = None
while conn_port <= max_port:
try:
reader = mercury.Reader("{}{}".format(path, conn_port))
reader.set_region('NA')
return [reader, "{}{}".format(path, conn_port)]
except: conn_port += 1
return [reader, ""]
#!/usr/bin/env python3
from __future__ import print_function
import time
import mercury
reader = mercury.Reader("tmr:///dev/ttyUSB0", baudrate=115200)
print(reader.get_model())
print(reader.get_supported_regions())
reader.set_region("EU3")
reader.set_read_plan([1], "GEN2", read_power=1900)
print(reader.read())
reader.start_reading(
lambda tag: print(tag.epc, tag.antenna, tag.read_count, tag.rssi))
time.sleep(1)
reader.stop_reading()
import mercury,boto3,botocore, json
reader = mercury.Reader("tmr:///dev/ttyUSB0")
print("Starting RFID Single Read Script...");
reader.set_region("NA2")
reader.set_read_plan([1],"GEN2",bank=["user","epc","tid"])
reader.set_read_powers([1],[500])
readTag = reader.read();
apc_code=str(readTag[0]);
apc = apc_code[2:26]
print("The tag being read is:",apc)
lambda_client = boto3.client('lambda')
test_event = {
"Container_Code": apc
}
testData = json.dumps(test_event)
response = lambda_client.invoke(
FunctionName='RegisterTag',
InvocationType='RequestResponse',
Payload=testData,
)
if (response['StatusCode'] == 200):
print('Registered Tag: ',apc);
else:
print("Error Sending Tag Information");
import mercury
class RfidController:
GPIO_PIN = 15
@classmethod
def scan()
'''
scan multiple times and hold the tags in a set
return iterable
'''
reader = mercury.Reader('tmr:///dev/ttyUSB0')
reader.set_region('EU3')
reader.set_read_plan([1], 'GEN2')
tags_set = {}
for _ in range(10)
for tag in reader.read():
tags_set.add(tag)
return tags_set
def __init__(self, port):
# Create and configure the reader object
self.PORT = port
self.reader = mercury.Reader(self.PORT)
self.reader.set_region("NA")
self.reader.set_read_plan([1], "GEN2")
import base64
import json
import cv2
import time
import argparse
from datetime import datetime
import os
from imutils.video import WebcamVideoStream
from imutils.video import FPS
import mercury
import threading
reader = mercury.Reader("tmr:///dev/cu.usbmodem146101")
rssi_timestamps = []
def start_rfid():
reader.set_region("NA")
reader.set_read_plan([1], "GEN2")
max = reader.get_power_range()[1]
print(reader.set_read_powers([(1, 3000)]))
def readCamera(tag):
print(tag.rssi)
encoded = tag.epc.decode('utf-8')
# print(type(time.time()))
rssi_timestamps.append(
(encoded, tag.rssi, tag.phase, time.time() * 1000))
reader.start_reading(readCamera)
import mercury
import json
from datetime import datetime
import time
from threading import *
configuracoes = {}
file = open("Configuracao.json")
configuracoes = json.load(file)
leitor = mercury.Reader(configuracoes.get('porta serial'),configuracoes.get('taxa em baud'))
leitor.set_region(configuracoes.get('regiao'))
leitor.set_read_plan([configuracoes.get('antena')],configuracoes.get('protocolo'), None, [], configuracoes.get("potencia do sinal"))
listaTagsNaoFiltradas=[]
globalIsOver = False
listAuxiliar = []
listaTagsFiltradas = []
now = datetime.now()
ultimaLeitura = now.strftime("%Y-%m-%d %H:%M:%S")
tempoMinimo = configuracoes.get('tempo minimo de volta')
t = (configuracoes.get('tempo de classificacao')
informacoesTAGs = {}
semaforo = Semaphore(1)
class Tag:
def __init__(self, tag, ultimaLeitura):
self.Tag = tag
self.ultimaLeitura = ultimaLeitura
def lerTAG():
leitor.start_reading(listaTagsNaoFiltradas.append)
time.sleep(0.5)
regiao = ""
antena = 0
protocolo = ""
readPower = 0
voltas = 0
tempoMin = 0
tempoQuali = 0
dadosDaLeitura = []
cicloLeitura = 0
length_max = 0
trava = BoundedSemaphore(1)
online = False # False = pausar as threads, True = continuar as threads
threadInit = True #Lógica inversa (True = não está iniciada)
conectado = True #Lógica inversa (True = cliente não conectado)
reader = mercury.Reader(
"tmr:///dev/ttyUSB0", baudrate=230400
) #Inicialização do reader para ele ser um objeto da mercury
'''
* Inicia o leitor com as configurações fornecidas pelo cliente.
'''
def iniciaLeitor():
global portaSerial, baud, regiao, antena, protocolo, readPower
reader = mercury.Reader(portaSerial, baudrate=baud)
reader.set_region(regiao)
reader.set_read_plan([antena], protocolo, read_power=readPower)
return reader
'''
########################################
def status():
hostmqtt.status({
"model": reader.get_model(),
"region": "AU",
#"temp": reader.get_temperature(),
"power_range": reader.get_power_range(),
"antennas": reader.get_antennas(),
# "power": reader.get_read_powers(),
"status": "listening"})
########################################
reader = mercury.Reader("tmr:///dev/ttyACM0")
reader.set_region("AU")
reader.set_read_plan([1], "GEN2")
reader.set_read_powers([1], [2700])
#using this causes the python to hang
#reader.set_read_plan([1], "GEN2", bank=["reserved"], read_power=2700)
lastStatus = datetime.datetime.now()
status()
reader.start_reading(rfidTagDataCallback, on_time=100, off_time=0)
while True:
if datetime.timedelta.total_seconds(datetime.datetime.now()-lastStatus) > (2*60):
def iniciaLeitor():
global portaSerial, baud, regiao, antena, protocolo, readPower
reader = mercury.Reader(portaSerial, baudrate=baud)
reader.set_region(regiao)
reader.set_read_plan([antena], protocolo, read_power=readPower)
return reader
