def main():
tagReader = TagReader(serialPort, True, timeOutSecs=0.05, kind='ID')
tagReader.installCallback(tag_in_range_pin)
print("Waiting for tags....")
while True:
try:
"""
Loop with a brief sleep, waiting for a tag to be read.
After reading the tag, it is printed. This is the point
where you might do something interesting
"""
while RFIDTagReader.globalTag == 0:
sleep(0.02)
print('Tag = ', RFIDTagReader.globalTag)
"""
Loop with a brief sleep, waiting for a tag to exit reading range
"""
while RFIDTagReader.globalTag != 0:
sleep(0.02)
print('Tag went away')
except KeyboardInterrupt:
del tagReader
GPIO.cleanup()
print("Quitting")
break
def main():
global globalReader
global globalTag
globalReader = TagReader(serialPort, True, timeOutSecs=0.05, kind='ID')
globalReader.installCallback(tag_in_range_pin,
callbackFunc=tagReaderGraceCallback)
print("Waiting for tags....")
while True:
try:
"""
Loop with a brief sleep, waiting for a tag to be read.
After reading the tag, it is printed. This is the point
where you might do something interesting
"""
while globalTag == 0:
sleep(0.02)
tag = globalTag
print('Tag = {:d}'.format(tag))
while globalTag == tag:
sleep(0.02)
print('Tag went away, really.')
except KeyboardInterrupt:
del globalReader
print("Quitting")
break
def main():
global globalReader
global globalTag
global cage
global log
global mice_dic
globalReader = TagReader(serialPort, True, timeOutSecs=0.05, kind='ID')
globalReader.installCallback(tag_in_range_pin)
now = dt.datetime.now()
mice_dic = SPT.mice_dict(cage)
txtspacer = input('txt spacer?')
while True:
# loops to check date and if date passes the define time settings, a new day/file is started
now = dt.datetime.now()
print("Waiting for mouse....")
log = SPT.data_logger(cage, txtspacer)
#switches the spout for L/R every indicated time interval (in hours)
mice_dic.spout_swtich()
while dt.datetime.now() - now < dt.timedelta(minutes=hours * 60):
if RFIDTagReader.globalTag == 0:
sleep(0.02)
else:
tag = RFIDTagReader.globalTag
filename = vs.record(tag)
print(mice_dic.mice_config)
print(str(tag))
print(filename)
log.event_outcome(mice_dic.mice_config, str(tag), 'VideoStart',
filename)
# provides the mouse at level 0 an entry reward; the reward is given randomly at r or l at 50% each
if mice_dic.mice_config[str(tag)]['SPT_level'] == 0:
if mice_dic.mice_config[str(tag)]['SPT_Pattern'] == 'R':
solenoid_LW.activate(0.5)
log.event_outcome(mice_dic.mice_config, str(tag),
'Entered', 'Entry_Reward')
pass
elif mice_dic.mice_config[str(tag)]['SPT_Pattern'] == 'L':
solenoid_RW.activate(0.5)
log.event_outcome(mice_dic.mice_config, str(tag),
'Entered', 'Entry_Reward')
pass
else:
log.event_outcome(mice_dic.mice_config, str(tag),
'Entered', 'No_Entry_Reward')
#tag is read and checks the mouse spt level
#level 0: a water reward is given
#level 1: only one the spt pattern spout will dispense water, licking the other will give a buzz
#level 2: the spt preference test, spt dispensed at the spt pattern spout
while RFIDTagReader.globalTag == tag:
while GPIO.input(tag_in_range_pin) == GPIO.HIGH:
if lickdector[0].value:
if mice_dic.mice_config[str(
tag)]['SPT_level'] == 0:
solenoid_RW.activate(0.1)
log.event_outcome(mice_dic.mice_config,
str(tag), 'licked-Rightside',
'Water_Reward')
elif mice_dic.mice_config[str(
tag)]['SPT_level'] == 1:
if mice_dic.mice_config[str(
tag)]['SPT_Pattern'] == 'R':
solenoid_RW.activate(0.1)
log.event_outcome(mice_dic.mice_config,
str(tag),
'licked-Rightside',
'Water_Reward')
elif mice_dic.mice_config[str(
tag)]['SPT_Pattern'] == 'L':
#speaker on
print('Speaker on\n')
buzzer.buzz()
log.event_outcome(mice_dic.mice_config,
str(tag),
'licked-Rightside',
'No_Reward')
sleep(0.2)
elif mice_dic.mice_config[str(
tag)]['SPT_level'] == 2:
if mice_dic.mice_config[str(
tag)]['SPT_Pattern'] == 'R':
solenoid_RW.activate(0.1)
log.event_outcome(mice_dic.mice_config,
str(tag),
'licked-Rightside',
'Sucrose_Reward')
elif mice_dic.mice_config[str(
tag)]['SPT_Pattern'] == 'L':
solenoid_LW.activate(0.1)
log.event_outcome(mice_dic.mice_config,
str(tag),
'licked-Rightside',
'Water_Reward')
elif lickdector[1].value:
if mice_dic.mice_config[str(
tag)]['SPT_level'] == 0:
solenoid_LW.activate(0.1)
log.event_outcome(mice_dic.mice_config,
str(tag), 'licked-Leftside',
'Water_Reward')
elif mice_dic.mice_config[str(
tag)]['SPT_level'] == 1:
if mice_dic.mice_config[str(
tag)]['SPT_Pattern'] == 'R':
print('Speaker on\n')
buzzer.buzz()
log.event_outcome(mice_dic.mice_config,
str(tag),
'licked-leftside',
'No_Reward')
sleep(0.2)
elif mice_dic.mice_config[str(
tag)]['SPT_Pattern'] == 'L':
solenoid_LW.activate(0.1)
log.event_outcome(mice_dic.mice_config,
str(tag),
'licked-Leftside',
'Water_Reward')
elif mice_dic.mice_config[str(
tag)]['SPT_level'] == 2:
if mice_dic.mice_config[tag][
'SPT_Pattern'] == 'R':
solenoid_LW.activate(0.1)
log.event_outcome(mice_dic.mice_config,
str(tag),
'licked-Leftside',
'Water_Reward')
elif mice_dic.mice_config[str(
tag)]['SPT_Pattern'] == 'L':
solenoid_LS.activate(0.1)
log.event_outcome(mice_dic.mice_config,
str(tag),
'licked-Leftside',
'Sucrose_Reward')
else:
sleep(0.02)
vs.stop_record()
log.event_outcome(mice_dic.mice_config, str(tag), 'VideoEnd',
filename)
###sleep time must match reward and buzzer sleep time
sleep(0.05)
log.event_outcome(mice_dic.mice_config, str(tag), 'Exit',
'None')
print('Waiting for mouse')
def main():
"""
Read in settings from AMW_config.jsn. If we don't find the file, make it.
Note that we save the file with new line as a separator, but can't load it with a non-standard separator,
so we replace new lines with commas, he default separator character
"""
try:
with open('AMW_config.jsn', 'r') as fp:
data = fp.read()
data = data.replace('\n', ',')
configDict = json.loads(data)
fp.close()
# Constants for saving data
# cage name, to tell data from different cages
kCAGE_NAME = configDict.get('Cage Name')
# path where data from each day will be saved
kCAGE_PATH = configDict.get('Data Path')
# rollover time, 0 to start the file for each day at 12 midnight. Could set to 7 to synch files to mouse day/night cycle
kDAYSTARTHOUR = configDict.get('Day Start Hour')
# size of array used for threaded reading from load cell amplifier
kTHREADARRAYSIZE = configDict.get('Thread Array Size')
# cuttoff weight where we stop the thread from reading when a mouse steps away
kMINWEIGHT = configDict.get('Minimum Weight')
# GPIO pin numbers and scaling for HX711, adjust as required for individual setup
kDATA_PIN = configDict.get('GPIO Data Pin')
kCLOCK_PIN = configDict.get('GPIO Clock Pin')
kGRAMS_PER_UNIT = configDict.get('Grams Per Unit')
# RFID Reader. Note that code as written only works with ID tag readers not RDM readers because of reliance on Tag-In-Range Pin
kSERIAL_PORT = configDict.get('Serial Port')
kTIR_PIN = configDict.get('GPIO Tag In Range Pin')
#whether data is saved locally 1 or, not yet supported, sent to a server 2, or both, 3
kSAVE_DATA = configDict.get('Data Save Options')
# a dictionary of ID Tags and cutoff weights, as when monitoring animal weights over time
kHAS_CUTOFFS = configDict.get('Has Cutoffs')
if kHAS_CUTOFFS:
kCUT_OFF_DICT = configDict.get('Cutoff Dict')
else:
kCUT_OFF_DICT = None
# can call get day weights code and email weights, needs extra options
kEMAIL_WEIGHTS = configDict.get('Email Weights')
if kEMAIL_WEIGHTS:
kEMAIL_DICT = configDict.get('Email Dict')
else:
kEMAIL_DICT = None
except (TypeError, IOError, ValueError) as e:
#we will make a file if we didn't find it, or if it was incomplete
print(
'Unable to load configuration data from AMW_config.jsn, let\'s make a new AMW_config.jsn.\n'
)
jsonDict = {}
kCAGE_NAME = input(
'Enter the cage name, used to distinguish data from different cages:'
)
kCAGE_PATH = input(
'Enter the path where data from each day will be saved:')
kDAYSTARTHOUR = int(
input(
'Enter the rollover hour, in 24 hour format, when a new data file is started (0=midnight):'
))
kTHREADARRAYSIZE = int(
input(
'Enter size of array used for threaded reading from Load Cell:'
))
kMINWEIGHT = float(
input(
'Enter cutoff weight where we stop the thread from reading:'))
kDATA_PIN = int(
input(
'Enter number of GPIO pin connected to data pin on load cell:')
)
kCLOCK_PIN = int(
input(
'Enter number of GPIO pin connected to clock pin on load cell:'
))
kGRAMS_PER_UNIT = float(
input(
'Enter the scaling of the load cell, in grams per A/D unit:'))
kSERIAL_PORT = input(
'Enter the name of serial port used for tag reader,e.g. serial0 or ttyAMA0:'
)
kTIR_PIN = int(
input(
'Enter number of the GPIO pin connected to the Tag-In-Range pin on the RFID reader:'
))
kSAVE_DATA = int(
input(
'To save data locally, enter 1; to send data to a server, not yet supported, enter 2:'
))
tempInput = input('Track weights against existing cutoffs(Y or N):')
kHAS_CUTOFFS = bool(tempInput[0] == 'y' or tempInput[0] == 'Y')
if kHAS_CUTOFFS:
kCUT_OFF_DICT = {}
while True:
tempInput = input(
'Enter a Tag ID and cuttoff weight, separated by a comma, or return to end entry:'
)
if tempInput == "":
break
entryList = tempInput.split(',')
try:
kCUT_OFF_DICT.update({entryList[0]: float(entryList[1])})
except Exception as e:
print('bad data entered', str(e))
else:
kCUT_OFF_DICT = None
jsonDict.update({
'Has Cutoffs': kHAS_CUTOFFS,
'Cutoff Dict': kCUT_OFF_DICT
})
tempInput = input('Email weights every day ? (Y or N):')
kEMAIL_WEIGHTS = bool(tempInput[0] == 'y' or tempInput[0] == 'Y')
if kEMAIL_WEIGHTS:
kEMAIL_DICT = {}
kFROMADDRESS = input(
'Enter the account used to send the email with weight data:')
kPASSWORD = input(
'Enter the password for the email account used to send the mail:'
)
kSERVER = input(
'Enter the name of the email server and port number, e.g., smtp.gmail.com:87, with separating colon:'
)
kRECIPIENTS = tuple(
input(
'Enter comma-separated list of email addresses to get the daily weight email:'
).split(','))
kEMAIL_DICT.update({
'Email From Address': kFROMADDRESS,
'Email Recipients': kRECIPIENTS
})
kEMAIL_DICT.update({
'Email Password': kPASSWORD,
'Email Server': kSERVER
})
else:
kEMAIL_DICT = None
jsonDict.update({
'Email Weights': kEMAIL_WEIGHTS,
'Email Dict': kEMAIL_DICT
})
# add info to a dictionay we will write to file
jsonDict.update({
'Cage Name': kCAGE_NAME,
'Data Path': kCAGE_PATH,
'Day Start Hour': kDAYSTARTHOUR,
'Thread Array Size': kTHREADARRAYSIZE
})
jsonDict.update({
'Minimum Weight': kMINWEIGHT,
'GPIO Data Pin': kDATA_PIN,
'GPIO Clock Pin': kCLOCK_PIN
})
jsonDict.update({
'GPIO Tag In Range Pin': kTIR_PIN,
'Grams Per Unit': kGRAMS_PER_UNIT,
'Serial Port': kSERIAL_PORT
})
jsonDict.update({
'Data Save Options': kSAVE_DATA,
'Email Weights': kEMAIL_WEIGHTS
})
with open('AMW_config.jsn', 'w') as fp:
fp.write(
json.dumps(jsonDict, sort_keys=True, separators=('\r\n', ':')))
"""
Initialize the scale from variables listed above and do an initial taring
of the scale with 10 reads. Because pins are only accessed from C++, do not call
Python GPIO.setup for the dataPin and the clockPin
"""
scale = Scale(kDATA_PIN, kCLOCK_PIN, kGRAMS_PER_UNIT, kTHREADARRAYSIZE)
scale.weighOnce()
scale.tare(10, True)
"""
Setup tag reader and GPIO for TIR pin, with tagReaderCallback installed as
an event callback when pin changes either from low-to-high, or from high-to-low.
"""
tagReader = TagReader('/dev/' + kSERIAL_PORT,
doChecksum=False,
timeOutSecs=0.05,
kind='ID')
tagReader.installCallback(kTIR_PIN)
"""
A new binary data file is opened for each day, with a name containing the
current date, so open a file to start with
"""
now = datetime.fromtimestamp(int(time()))
startDay = datetime(now.year, now.month, now.day, kDAYSTARTHOUR, 0, 0)
if startDay > now: # it's still "yesterday" according to kDAYSTARTHOUR definition of when a day starts
startDay = startDay - timedelta(hours=24)
startSecs = startDay.timestamp(
) # used to report time of an entry through the weighing tube
nextDay = startDay + timedelta(hours=24)
filename = kCAGE_PATH + kCAGE_NAME + '_' + str(
startDay.year) + '_' + '{:02}'.format(
startDay.month) + '_' + '{:02}'.format(startDay.day)
if kSAVE_DATA & kSAVE_DATA_LOCAL:
print('opening file name = ' + filename)
outFile = open(filename, 'ab')
from OneDayWeights import get_day_weights
"""
Weight data is written to the file as grams, in 32 bit floating point format. Each run of data is
prefaced by metadata from a 32 bit floating point metaData array of size 2. The first point contains
the last 6 digits of the RFID code, as a negative value to make it easy for analysis code to find the
start of each run. The second point contains the time in seconds since the start of the day.
Both data items have been selected to fit into a 32 bit float.
"""
metaData = array('f', [0, 0])
while True:
try:
"""
Loop with a brief sleep, waiting for a tag to be read
or a new day to start, in which case a new data file is made
"""
while RFIDTagReader.globalTag == 0:
if datetime.fromtimestamp(int(time())) > nextDay:
if kSAVE_DATA & kSAVE_DATA_LOCAL:
outFile.close()
print('save data date =', startDay.year,
startDay.month, startDay.day)
try:
get_day_weights(kCAGE_PATH, kCAGE_NAME,
startDay.year, startDay.month,
startDay.day, kCAGE_PATH, False,
kEMAIL_DICT, kCUT_OFF_DICT)
except Exception as e:
print('Error getting weights for today:' + str(e))
startDay = nextDay
nextDay = startDay + timedelta(hours=24)
startSecs = startDay.timestamp()
filename = kCAGE_PATH + kCAGE_NAME + '_' + str(
startDay.year) + '_' + '{:02}'.format(
startDay.month) + '_' + '{:02}'.format(
startDay.day)
if kSAVE_DATA & kSAVE_DATA_LOCAL:
outFile = open(filename, 'ab')
print('opening file name = ' + filename)
else:
sleep(kTIMEOUTSECS)
"""
A Tag has been read. Fill the metaData array and tell the C++ thread to start
recording weights
"""
thisTag = RFIDTagReader.globalTag
startTime = time()
print('mouse = ', thisTag)
#scale.turnOn()
metaData[0] = -(thisTag % 1000000)
metaData[1] = startTime - startSecs
scale.threadStart(scale.arraySize)
nReads = scale.threadCheck()
lastRead = 0
"""
Keep reading weights into the array until a new mouse is read by
the RFID reader, or the last read weight drops below 2 grams, or
the array is full, then stop the thread print the metaData array
and the read weights from the thread array to the file
"""
while ((RFIDTagReader.globalTag == thisTag or
(RFIDTagReader.globalTag == 0
and scale.threadArray[nReads - 1] > kMINWEIGHT))
and nReads < scale.arraySize):
if nReads > lastRead:
print(nReads, scale.threadArray[nReads - 1])
lastRead = nReads
sleep(0.05)
nReads = scale.threadCheck()
nReads = scale.threadStop()
if kSAVE_DATA & kSAVE_DATA_LOCAL:
metaData.tofile(outFile)
scale.threadArray[0:nReads - 1].tofile(outFile)
if kSAVE_DATA & kSAVE_DATA_REMOTE:
# modify to send : Time:UNIX time stamp, RFID:FULL RFID Tag, CageID: id, array: weight array
response = requests.post(
kSERVER_URL,
data={
'tag':
thisTag,
'cagename':
kCAGE_NAME,
'datetime':
int(startTime),
'array':
str((metaData +
scale.threadArray[0:nReads - 1]).tobytes(),
'latin_1')
}).text
if response != '\nSuccess\n':
print(reponse)
#scale.turnOff()
except KeyboardInterrupt:
#scale.turnOn()
event = scale.scaleRunner('10:\tQuit AutoMouseWeight program\n')
if event == 10:
if kSAVE_DATA & kSAVE_DATA_LOCAL:
outFile.close()
GPIO.cleanup()
return
except Exception as error:
print("Closing file...")
outFile.close()
GPIO.cleanup()
raise error