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