OSCR

Low-cost, open-source, full-stack software and Arduino-based hardware for control of commercially available animal behavior systems.

Code ↔ Paper

15 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 15 matches · 2 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Methods › Programmable microstimulator ↔ Flask Project Files/pythonBackend/serial_functions.py, lines 280–310 · score 0.92 · inter phase interval, change stimulation parameters, pulse width, pulse trains, deliver stimulation, aperiodic
  2. [2] § Operant conditioning tasks ↔ Flask Project Files/pythonBackend/serial_functions.py, lines 61–120 · score 0.78 · house light, left port, right port, initiated, unpausing, tone
  3. [3] § Flask micro-framework ↔ Flask Project Files/pythonBackend/application.py, lines 1–16 · score 0.78 · virtual environment, end service, Flask Project, GitHub, RESTful, py
  4. [4] § Methods › Angular framework ↔ Angular Files/src/app/device-startup/device-startup.component.ts, lines 1–62 · score 0.76 · device startup, BehaviorSubject, SSEService, FlaskService, tool, Angular
  5. [5] § Methods › Angular framework ↔ Angular Files/src/app/device-startup/sse.service.ts, the whole file · a weak match · score 0.76 · BehaviorSubject, event source, SSEService, RESTful, reconnect, error
  6. [6] § Methods › Angular framework ↔ Angular Files/src/app/device-startup/sse.service.ts, the whole file · a weak match · score 0.72 · device startup, BehaviorSubject, SSEService, RESTful, Angular, components
  7. [7] § Methods › Programmable microstimulator ↔ Flask Project Files/pythonBackend/application.py, lines 27–104 · score 0.72 · pulse width, stimulation parameters, aperiodic, coefficient, variation, inter
  8. [8] § Methods › Angular framework ↔ Angular Files/src/app/total.service.ts, lines 1–58 · score 0.69 · SSEService, FlaskService, RESTful, selection, POST, services
  9. [9] § Methods › Angular framework ↔ Angular Files/src/app/device-startup/device-startup.component.ts, lines 190–247 · score 0.68 · device startup, view port, selection, exporting, events, fields
  10. [10] § Methods › Operant chamber ↔ Arduino Files/operant_task_control/SPOUT.h, lines 9–28 · score 0.61 · solenoid valves, water reward, delivery, pin, operant, Arduino
  11. [11] § Flask micro-framework ↔ Flask Project Files/pythonBackend/application.py, lines 1–16 · score 0.61 · helper_functions.py, serial_functions.py, Python, Flask, services, logic
  12. [12] § Flask micro-framework ↔ Angular Files/src/app/device-startup/device-startup.component.ts, lines 64–125 · score 0.57 · button presses, RESTful, loop, client, stream, Flask
  13. [13] § Methods › Operant chamber ↔ Flask Project Files/pythonBackend/serial_functions.py, lines 61–120 · score 0.54 · reward delivery, operant chamber, sensor, components, Arduino
  14. [14] § Operant conditioning tasks ↔ Flask Project Files/pythonBackend/serial_functions.py, lines 142–278 · score 0.54 · left port response, right port response, incorrect, Forced, detection, stimulus
  15. [15] § Flask micro-framework ↔ Flask Project Files/pythonBackend/application.py, lines 27–104 · score 0.51 · simple welcome, alongside, serial port, Flask, services, Arduino

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 516 lines · 22 KB · BSD-3-Clause · 4 matches

  1. # Functions for Arduino Communication
  3. import serial
  4. import serial.tools.list_ports as port_list
  5. import time
  6. import random
  8. def findPorts(): #finds and returns devices ocnnected to serial port
  9. ports = list(port_list.comports())
  11. return ports
  13. def changeSessionParams(ard, params, y):
  14. """ changes all rrelevant session parameters for running 2AFC experiments
  15. # Inputs:
  16. # ard - serial port object for task arduino
  17. # params - dict of paramaters to updated, ex: params = ['Initial Training', 'Detection', '60', '10', 'Yes', '3']
  18. # y - data stream variable for storing/sending display information to angular
  19. """
  20. com = []
  21. # sets session
  22. if params[0] == "Initial Training":
  23. ard.write('P42'.encode('utf-8'))
  24. else:
  25. ard.write('P41'.encode('utf-8'))
  27. # sets session length
  28. ard.write(('P1' + params[2]).encode('utf-8'))
  30. # sets response time
  31. ard.write(('P2' + params[3]).encode('utf-8'))
  33. # sets forced trials
  34. if params[4] == "Yes":
  35. ard.write('P51'.encode('utf-8'))
  36. else:
  37. ard.write('P50'.encode('utf-8'))
  39. # set consecutive error
  40. ard.write(('P3' + params[5]).encode('utf-8'))
  42. #def manualControlDic(ard,com):
  43. com_lookup = {'left-door-true': 'D',
  44. 'left-door-false': 'D',
  45. 'right-door-true': 'd',
  46. 'right-door-false': 'd',
  47. 'left-flush-true': 'L',
  48. 'left-flush-false': 'L',
  49. 'right-flush-true': 'R',
  50. 'right-flush-false': 'R',
  51. 'house-light-true': 'H',
  52. 'house-light-false':'H',
  53. 'buzzer-true': 'B1',
  54. 'buzzer-false': 'B0',
  55. 'test-sensors-true': 'J',
  56. 'test-sensors-false': 'K',
  57. 'pause-true': 'p',
  58. 'pause-false': 'u',
  59. 'stop-N/A': 'Q'}
  61. ## manualControl replaced by above dictionary. Thought that all the if-statements were causing a lot of lag
  62. # between converting the HTTP POST to serial command but it ended up being on the arduino program side.
  63. def manualControl(ard, component, state, y):
  64. """ Commands sent to arduino to control various components in the operant chamber.
  65. # Manual control is only enable before a session is started and during pauses (or fored trials)
  66. # may do something like: comp = {'left-door':{'true':'D1','false':'D0'},'right-door':{'true':'d1','false':'d0'},'left-flush':'L','right-flush':'R'}
  67. # Inputs:
  68. # ard - serial port object for task arduino
  69. # component - string indicating component to control (ex: "right-door")
  70. # state - string indicating button/switch state ("true", "false", or "NAN"
  71. """
  72. if component == "left-door": # open/close left door
  73. if state == "true":
  74. com = 'D1'
  75. else:
  76. com = 'D0'
  78. elif component == "right-door": # open/close right door
  79. if state == "true":
  80. com = 'd1'
  81. else:
  82. com = 'd0'
  84. elif component == "left-flush": # flushes/stop flushes left port
  85. com = 'L'
  87. elif component == "right-flush": # flushed/stop flushed right port
  88. com = 'R'
  90. elif component == "house-light": # turns houselight on/off
  91. if state == "true":
  92. com = 'H1'
  93. else:
  94. com = 'H0'
  96. elif component == "buzzer": # plays short/long buzzer tone
  97. if state == "true":
  98. com = 'B1' # short
  99. else:
  100. com = 'B0' # long
  102. elif component == "test-sensors": # allows for testing of sensors and reward delivery
  103. if state == "true":
  104. com = 'J' # initiates sensor testing
  105. else:
  106. com = 'K' # ends sensor testing
  108. elif component == "start": # starts session (isn't used here)
  109. com = 'b'
  111. elif component == "stop": # stops session
  112. com = 'Q'
  114. elif component == "pause": # pauses session
  115. if state == "true":
  116. com = 'p' # pause
  117. else:
  118. com = 'u' # unpause
  120. ard.write(com.encode('utf-8'))
  122. def randomizeAmplitude(gib, stimParams, y):
  123. """ function for randomizing amplitude of stimulation
  124. # Inputs:
  125. # gib - serial port object for stimulator
  126. # stimParams - dict of stimulation params (ex: line 76 in application.py
  127. # y - data stream variable for storing/sending display information to angular
  128. """
  129. if stimParams["amp_indx"] == len(stimParams["task_amps"]): #check if every amplitude in stimParams["task_amps"] has been used
  130. stimParams["amp_indx"] = 0 #reset index
  131. print("Amp_indx asaa: " + str(stimParams["amp_indx"]))
  132. stimParams["shuffled_amps"] = random.sample(
  133. stimParams["task_amps"],
  134. len(stimParams["task_amps"])) #reshuffle amplitudes
  135. y.append("amplitude index: " + str(stimParams["amp_indx"])) #update display in anglar
  136. stimParams["amplitude"] = stimParams["shuffled_amps"][stimParams["amp_indx"]]
  137. changeAmplitude(gib, stimParams["amplitude"], y)
  138. stimParams["amp_indx"] = stimParams["amp_indx"] + 1
  142. def arduinoTask(ard, gib, y, sessionData, currentTrialData, stimParams):
  143. """serial port "listener" to perform specific actions depending on what arduino writes to port
  144. # Inputs:
  145. # ard - serial port object for task arduino
  146. # gib - serial port object for stimulator
  147. # y - data stream variable for storing/sending display information to angular
  148. # sessionData - dict to store relevant behavioral data during session
  149. # currentTrialData - dict to update trial table in angular
  150. # stimParams - dict containing parameters of stimulation
  151. """
  152. break_flag = 0 # flag to break external while loop if present
  153. while ard.in_waiting == 0: #do nothing until bytes are available to read
  154. pass
  155. x = ard.read_until(expected=b'\r\n').decode("utf").rstrip()
  156. print(x)
  157. data = x.split(',')
  158. if data[0] == "Connected":
  159. print("Arduino " + data[0])
  160. print("Manual Control Enabled")
  161. y.append("Arduino " + data[0])
  162. y.append("Manual Control Enabled")
  163. break_flag = 1
  164. elif data[0] == "Start":
  165. print("Beginning Session")
  166. y.append("Beginning Session")
  168. elif data[0] == "Trial":
  169. print("Trial time: " + data[1])
  170. print("Trial Number: " + data[2])
  171. y.append("Trial Number: " + data[2])
  172. trial_time = int(data[1]) / 1000 # to seconds
  173. ## update data
  174. currentTrialData["sess_time"] = str(round(trial_time / 60,2)) #to minutes
  175. currentTrialData["trial_n"] = data[2]
  176. currentTrialData["trial_type"] = "-"
  177. currentTrialData["stim_A"] = "-"
  178. currentTrialData["stim_fre"] = "-"
  179. currentTrialData["CV"] = "-"
  180. currentTrialData["trial_res"] = "-"
  181. sessionData["trial_time"].append(trial_time)
  182. sessionData["trial_number"].append(int(data[2]))
  184. elif data[0] == "Type":
  186. if data[1] == "2": #right trial, no stimulation for detection experiment
  188. sessionData["amplitude"].append([])
  189. sessionData["frequency"].append([])
  190. sessionData["CV"].append([])
  191. else: #left trial, stimulation if CV experiment is selected
  193. if stimParams["stim_enable"] == 1:
  194. if stimParams["randomize"] == 1:
  195. randomizeAmplitude(gib, stimParams, y)
  197. currentTrialData["stim_A"] = str(stimParams["amplitude"])
  198. currentTrialData["stim_fre"] = str(stimParams["frequency"])
  199. currentTrialData["CV"] = str(stimParams["CV"])
  200. sessionData["amplitude"].append(stimParams["amplitude"])
  201. sessionData["frequency"].append(stimParams["frequency"])
  202. sessionData["CV"].append(stimParams["CV"])
  203. else:
  204. sessionData["amplitude"].append([])
  205. sessionData["frequency"].append([])
  206. sessionData["CV"].append([])
  208. datStr = ard.read_until(expected=b'\r\n').decode("utf").rstrip()
  209. y.append(datStr)
  210. currentTrialData["trial_type"] = data[1]
  211. currentTrialData["forced"] = data[2]
  212. sessionData["trial_type"].append(int(data[1]))
  213. sessionData["forced"].append(int(data[2]))
  214. sessionData["randomized"].append(stimParams["randomize"])
  215. sessionData["response"].append([])
  216. sessionData["response_time"].append([])
  217. sessionData["correct"].append([])
  218. sessionData["percent"].append([])
  220. elif data[0] == "Stim":
  221. if data[1] == "1": #left trial
  222. if gib.is_open == 1: #stimParams["stimEnable"] == 1
  223. stimulate(gib, stimParams, y)
  224. print("Stim")
  225. y.append("Stim")
  226. else:
  227. print("No stim")
  228. y.append("No stim")
  230. elif data[0] == "Response":
  231. res_time = int(data[1]) / 1000
  232. if data[3] == "1":
  233. datStr = "correct."
  234. elif data[3] == "0":
  235. datStr = "incorrect."
  236. elif data[3] == "5":
  237. #data[3] = "0"
  238. datStr = "forced."
  239. print("Response Time: " + str(res_time) + "sec")
  241. if data[2] == "1":
  242. datStr = "Left Port Response, " + datStr
  243. elif data[2] == "2":
  244. datStr = "Right Port Response, " + datStr
  245. elif data[2] == "5":
  246. datStr = "No response."
  248. print(datStr)
  249. y.append(datStr)
  250. currentTrialData["trial_res"] = data[2]
  251. sessionData["response_time"][-1] = res_time
  252. sessionData["response"][-1] = int(data[2])
  253. sessionData["correct"][-1] = int(data[3])
  256. elif data[0] == "Percent":
  257. percent = float(data[1]) * 100
  258. currentTrialData["per_cor"] = str(percent)
  259. sessionData["percent"][-1] = percent
  260. y.append("Running percentage correct: " + str(percent) + "%")
  262. elif data[0] == "End":
  263. print("Session Ended")
  264. y.append("Session Ended")
  265. break_flag = 1
  266. elif data[0] == "Wait":
  267. print("Manual Control Enabled")
  268. y.append("Manual Control Enabled")
  269. #break_flag = 1
  270. elif data[0] == "Wait for Response":
  271. print("Waiting for response...")
  272. y.append("Waiting for response...")
  273. #elif data[0] == "Paused":
  274. # print("Paused")
  275. # y.append(data[0])
  276. else:
  277. y.append(data[0])
  278. return break_flag
  280. '''
  281. The following functions are used for communication with the gibson stimulator:
  282. - 'waitForGibson' = establishes connection to stimulator
  283. - 'readGibData' = reads/clears data written by stimulator on serial port
  284. - 'convertToBytes' = configures command to stimulator to change parameters
  285. - 'currentConfig' = configures current for writing to gibson
  286. - 'changePulseNumber' = changes the number of pulses in stimulation pulse-train
  287. - 'changePulseWidth' = changes the pulse-width of stimulation pulse-train (us)
  288. - 'changeIPI' = changes the inter-phase interval (us)
  289. - 'changeFrequency' = changes frequency (Hz)
  290. - 'changeAmplitude' = changes amplitude of pulse-train (uA)
  291. - 'changeCV' = changes the coefficient of variation (aperiodicity) of pulse-train (can be 0, 0.1, 0.2,..., 1.0)
  292. - 'changeStimParams' = changes all stimulation parameters, primarily used for initial setup
  293. - 'stimulate' = sends command to deliver stimulation based on parameters set by the previous functions
  295. To change stimulation parameters:
  296. 1. the stimulation channel must first be selected (ch)
  297. -In the case here, only a single channel is used (channel 0) and is hard coded. This may be changed for future applications
  298. 2. the parameter to be changed is selected (val_ind)
  299. -pulse number -> 1
  300. -pulse width -> 2
  301. -inter-phase interval -> 3
  302. -frequency -> 4
  303. -amplitude requires sequence of three bytes:
  304. -> 5, 6, 7
  305. -CV -> 8
  306. 3. the corresponding parameter value is written (val)
  307. -ex: for pulse width -> 256
  308. -ex: for frequency -> 50
  309. 4. Function 'convertToBytes' takes the 3 aformentioned values and appropriately configures them for writing to serial port
  310. '''
  312. def waitForGibson(gib, y):
  313. """ establishes connection to stimulator
  314. Inputs:
  315. gib - serial port object for stimulator
  316. y - data stream variable for storing/sending display information to angular
  317. """
  318. gib.write((1).to_bytes(1, byteorder="big"))#write_uint8(gib,0)
  319. msg = ""
  320. while msg.find("Connected") == -1:
  321. while gib.in_waiting == 0:
  322. pass
  323. msg = gib.read_until(expected=b'\r\n').decode("utf").rstrip()
  324. print(msg)
  325. y.append("Gibson " + msg)
  327. def readGibData(gib, r_max, y):
  328. """ reads serial port of stimulator
  329. Inputs:
  330. gib - serial port object for stimulator
  331. r_max - indicate number of reponses (lines) from device
  332. y - data stream variable for storing/sending display information to angular
  333. """
  334. while gib.in_waiting == 0: # wait until bytes are on the serial port
  335. pass
  336. i = 0
  337. while i < r_max:
  338. x = gib.read_until(expected=b'\r\n').decode("utf").rstrip()
  339. print(x)
  340. y.append(x)
  341. i = i + 1
  343. def convertToBytes(ch, val_ind, val):
  344. """ Converts channel (ch), parameter index (val_ind), and parameter value (val) to
  345. bytes and joins them together.
  346. Inputs:
  347. ch - stimulation channel, zero-index (0-3, but 0 is only in use)
  348. val_ind - value specifying the parameter to be changed
  349. val - value of parameter to change
  350. """
  351. CH = ch.to_bytes(1, byteorder="big")
  352. VAL_IND = val_ind.to_bytes(1, byteorder="big")
  353. if val_ind == 1: #pulse number can be greater than 255
  354. VAL = val.to_bytes(2, byteorder="little") #give pulse number 2 bytes
  355. else:
  356. VAL = val.to_bytes(1, byteorder="big")
  357. COM = b''.join([CH, VAL_IND, VAL])
  358. return COM
  361. def currentConfig(current):
  362. '''
  363. -converted from matlab script 'currentconfig.m'
  364. 0-800 for current <---> 0-4095 decimal
  365. 800 / 4095 = 5.11875
  366. value = current * 5.11875 (round to positive int)
  367. convert to 12-bit binary
  368. '''
  369. dac_volt = format(int(round(current * 5.11875)), '012b')
  371. '''
  372. Correction factor required? Add here ------
  374. Take last 8-bits of dac_volt, convert to uint8 dec and assign to ab_byte
  375. '''
  376. ab_byte = int(dac_volt[4:12], 2).to_bytes(1, byteorder='big')
  378. # Take 1st 4-bits of dac_volt and add to back of dac_A configuration
  379. # Convert to uint8 dec and assign to a_byte
  380. dacAconfig = format(1, '04b') # 1 = 0001
  381. a_byte = int(dacAconfig + dac_volt[0:4], 2).to_bytes(1, byteorder='big')
  383. # Take 1st 4-bits of dac_volt and add to back of dac_B configuration
  384. # Convert to uint8 dec and assign to b_byte
  385. dacBconfig = format(9, '04b') # 9 = 1001
  386. b_byte = int(dacBconfig + dac_volt[0:4], 2).to_bytes(1, byteorder='big')
  388. return a_byte, b_byte, ab_byte
  390. def changePulseNumber(gib, pnVal, y):
  391. """ changes pulse number value.
  392. # Inputs:
  393. # gib - serial port object for stimulator
  394. # pnVal - number of pulses, string (ex: '300')
  395. # y - data stream variable for storing/sending display information to angular
  396. """
  397. COM = convertToBytes(0, 1, int(pnVal))
  398. gib.write(COM)
  399. readGibData(gib, 2, y)
  401. def changePulseWidth(gib, pwVal, y):
  402. """ changes pulse width.
  403. # Inputs:
  404. # gib - serial port object for stimulator
  405. # pwVal - pulse width in us, string (ex: '200')
  406. # y - data stream variable for storing/sending display information to angular
  407. """
  408. COM = convertToBytes(0, 2, int(pwVal))
  409. gib.write(COM)
  410. readGibData(gib, 2, y)
  412. def changeIPI(gib, ipiVal, y):
  413. """ changes inter-phase interval.
  414. # Inputs:
  415. # gib - serial port object for stimulator
  416. # ipiVal - inter-phase interval in us, string (ex: '50')
  417. # y - data stream variable for printing reads from serial port
  418. """
  419. COM = convertToBytes(0, 3, int(ipiVal))
  420. gib.write(COM)
  421. readGibData(gib, 2, y)
  424. def changeFrequency(gib, freqVal, y):
  425. """ changes frequency.
  426. # Inputs:
  427. # gib - serial port object for stimulator
  428. # freqVal - frequency in Hz, string (ex: '50')
  429. # y - data stream variable for storing/sending display information to angular
  430. """
  431. COM = convertToBytes(0, 4, int(freqVal))
  432. gib.write(COM)
  433. readGibData(gib, 2, y)
  436. def changeAmplitude(gib, ampVal, y):
  437. """ changes amplitde.
  438. # Inputs:
  439. # gib - serial port object for stimulator
  440. # ampVal - amplitude in uA, string (ex: '250')
  441. # y - data stream variable for storing/sending display information to angular
  442. """
  443. a_byte, b_byte, ab_byte = currentConfig(int(ampVal))
  444. a_int = int.from_bytes(a_byte, byteorder='big')
  445. b_int = int.from_bytes(b_byte, byteorder='big')
  446. ab_int = int.from_bytes(ab_byte, byteorder='big')
  448. aCOM = convertToBytes(0, 5, a_int)
  449. gib.write(aCOM)
  451. bCOM = convertToBytes(0, 6, b_int)
  452. gib.write(bCOM)
  454. abCOM = convertToBytes(0, 7, ab_int)
  455. gib.write(abCOM)
  456. readGibData(gib, 3, y)
  458. def changeCV(gib, cvVal, y):
  459. """ changes CV value.
  460. Inputs:
  461. gib - serial port object for stimulator
  462. cvVal - coeficient of variation value, string (ex: '0.8')
  463. y - data stream variable for storing/sending display information to angular
  464. """
  465. COM = convertToBytes(0, 8, int(float(cvVal) * 10)) #cv is read as 0-10 so multiply by 10
  466. gib.write(COM)
  467. readGibData(gib, 2, y)
  469. def changeStimParams(gib, params, stimParams, y):
  470. """ sequentially changes all stimulation parameters
  471. Inputs:
  472. gib - serial port object for stimulator
  473. params - list of parameters as strings sent from angular to be changed
  474. stimParams - dict containing parameters of stimulation
  475. y - data stream variable for storing/sending display information to angular
  476. """
  477. ampStr = params[0]
  478. stimParams["amplitude"] = int(ampStr)
  479. stimParams["base_amp"] = int(ampStr)
  480. freqStr = params[1]
  481. stimParams["frequency"] = int(freqStr)
  482. pwStr = params[2]
  483. stimParams["pulse_width"] = int(pwStr)
  484. ipiStr = params[3]
  485. stimParams["ipi"] = int(ipiStr)
  486. pnStr = params[4]
  487. stimParams["pulse_num"] = int(pnStr)
  488. cvStr = params[5]
  489. stimParams["CV"] = float(cvStr)
  490. if stimParams["CV"] > 0:
  491. stimParams["periodic"] = 1
  492. else:
  493. stimParams["periodic"] = 0
  495. changeAmplitude(gib, ampStr, y)
  496. changeFrequency(gib, freqStr, y)
  497. changePulseWidth(gib, pwStr, y)
  498. changeIPI(gib, ipiStr, y)
  499. changePulseNumber(gib, pnStr, y)
  500. changeCV(gib, cvStr, y)
  502. def stimulate(gib, stimParams, y):
  503. """ delivers stimulation based on set stimulation parameters
  504. Inputs:
  505. gib - serial port object for stimulator
  506. stimParams - dict containing parameters of stimulation
  507. y - data stream variable for storing/sending display information to angular
  508. """
  509. gib.write((0 + 4).to_bytes(1, "big")) # '0' is the channel, stim command is channel + 4
  510. if stimParams["periodic"] == 0:
  511. readGibData(gib, 1, y)
  512. else:
  513. readGibData(gib, 2, y)

serial_functions.py at commit 5ff84c9, under BSD-3-Clause · at the source

Overview

Authors: Scott Miller1, Jacob C. Slack2, Amol P. Yadav2,3,4
ORCID iDs: Jacob C. Slack
  1. Department of Biomedical Engineering, University of Michigan,Ann Arbor, MI USA
  2. Lampe Joint Department of Biomedical Engineering, University of North Carolina at Chapel Hill and North Carolina State University,Chapel Hill, NC USA
  3. Neurosurgery, School of Medicine, University of North Carolina at Chapel Hill,Chapel Hill, NC USA
  4. Neuroscience Center, School of Medicine, University of North Carolina at Chapel Hill,Chapel Hill, NC USA
Institutions: University of Michigan (United States); North Carolina State University (United States); University of North Carolina at Chapel Hill (United States)
Journal: Behavior research methods, volume 58, issue 8, article 211
Dates: received 10 March 2025; accepted 27 May 2026; published online 29 June 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3758/s13428-026-03096-9 · PMID 42373986 · PMCID PMC13315479 · OpenAlex W7166509320
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: behavior only (modality), rat (organism), methods / tools (subfield)
Methods: Spectral & time-frequency, Statistics
Keywords: Open-source, Operant conditioning, Behavioral experiments, Full stack, Arduino
MeSH: Behavior, Animal*, Behavioral Research*, Conditioning, Operant*, Software*, Animals, Electric Stimulation, Male, Rats (* major topic)
Journal subjects: Original Manuscript
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NIH (7DP2NS136872-02); Indiana State Department of Health
Citations: not cited yet (Europe PMC); 31 references in the paper

Abstract

Behavioral neuroscience relies heavily on controlled environments, such as operant chambers or “Skinner boxes,” to characterize relationships between external stimuli and the resulting animal behavior. Increasingly, these methodologies are critical for the development of neural interfaces which seek to provide or restore sensations via electrical stimulation. To conduct behavioral experiments, researchers have commonly trusted commercial systems, like those from Med Associates, Inc. While offering reliability, high costs and limited customizability have motivated a push towards open-source alternatives, which often involve the use of inexpensive microcontrollers, custom printed circuit boards (PCBs), and freely available codebases. However, despite these developments, there is a lack of comprehensive software solutions that can integrate seamlessly with commercial or custom hardware for behavioral experiments. In this study, we developed a full-stack application utilizing Angular and Flask frameworks to conduct two-alternative forced choice (2AFC) tasks controlled by an Arduino which interfaces with Med Associates, Inc. operant chamber equipment via a custom PCB. The system was tested by conducting a simple operant conditioning procedure and a spinal cord stimulation (SCS) sensory detection experiment using a custom microstimulator in rodents. The analyzed data demonstrated appropriate behavioral learning and sensory detection thresholds, in alignment with previous SCS behavioral studies which utilized commercial or single-tier systems for control of operant chambers. This work demonstrates the effective integration of an open-source full-stack application with existing commercial hardware that can provide adaptable and scalable means for conducting behavioral experiments, crucial for advancing neural interface technologies.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 15 matches between paragraphs and lines of code.

yadavlabs/open-source-rat-behavior

License: BSD-3-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 5ff84c93c6b6700e4e5e8fd4360d87e728144505, 7 May 2026
Languages: Python (14), TypeScript (13), C++ (3), C/C++ (3)
Size: 79 files, 33 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt, Testing/requirements.txt), tests, documentation
Not found: CITATION.cff, continuous integration
Tools: pandas (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
35 files
At the source: github.com/yadavlabs/open-source-rat-behavior

Code availability

Code is available at the repository (GitHub Repository (https://github.com/yadavlabs/open-source-rat-behavior)).

Reproduced under the paper's license (CC BY), from the paper cited above.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 33 scripts, each with its path and the digest of its content;
  • 15 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability

Design files, user manuals, and documentation are available at the repository (GitHub Repository (https://github.com/yadavlabs/open-source-rat-behavior)). Links to specific locations in the repository are referenced throughout the paper when applicable. Behavioral data can be made available upon reasonable request.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 2, 28 September 2026

  • Publisher: n/a → Springer Science+Business Media

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 5 keywords, 8 MeSH terms, 2 funders, 28 references.

Cite

This paper

Miller, S., Slack, J. C., & Yadav, A. P. (2026). Low-cost, open-source, full-stack software and Arduino-based hardware for control of commercially available animal behavior systems. Behavior research methods, 58(8), 211. https://doi.org/10.3758/s13428-026-03096-9

BibTeX

@article{miller2026low,
author = {Miller, Scott and Slack, Jacob C. and Yadav, Amol P.},
title = {{Low-cost, open-source, full-stack software and Arduino-based hardware for control of commercially available animal behavior systems}},
journal = {Behavior research methods},
year = {2026},
month = jun,
volume = {58},
number = {8},
pages = {211},
publisher = {Springer Science+Business Media},
issn = {1554-351X},
doi = {10.3758/s13428-026-03096-9},
url = {https://doi.org/10.3758/s13428-026-03096-9},
pmid = {42373986},
pmcid = {PMC13315479}
}

RIS

TY - JOUR
AU - Miller, Scott
AU - Slack, Jacob C.
AU - Yadav, Amol P.
TI - Low-cost, open-source, full-stack software and Arduino-based hardware for control of commercially available animal behavior systems
T2 - Behavior research methods
J2 - Behav Res Methods
PY - 2026
DA - 2026/06/29
VL - 58
IS - 8
SP - 211
SN - 1554-351X
PB - Springer Science+Business Media
DO - 10.3758/s13428-026-03096-9
UR - https://doi.org/10.3758/s13428-026-03096-9
LA - en
ER -

CSL-JSON

{
"id": "10.3758/s13428-026-03096-9",
"type": "article-journal",
"title": "Low-cost, open-source, full-stack software and Arduino-based hardware for control of commercially available animal behavior systems",
"container-title": "Behavior research methods",
"author": [
{
"family": "Miller",
"given": "Scott"
},
{
"family": "Slack",
"given": "Jacob C."
},
{
"family": "Yadav",
"given": "Amol P."
}
],
"container-title-short": "Behav Res Methods",
"volume": "58",
"issue": "8",
"page": "211",
"DOI": "10.3758/s13428-026-03096-9",
"PMID": "42373986",
"PMCID": "PMC13315479",
"ISSN": "1554-351X",
"publisher": "Springer Science+Business Media",
"URL": "https://doi.org/10.3758/s13428-026-03096-9",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
29
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41467-026-76109-y [code]
Assistive algorithms influence neural representations in motor brain-computer interfaces.
Journal: Nature communications
In common: pandas, 2 references
[2] doi:10.1126/sciadv.aef0343 [code]
Learning induces activation-mechanism-dependent neural plasticity in an intracortical microstimulation task.
Journal: Science advances
In common: pandas, 2 references
[3] doi:10.1002/brb3.71654 [code]
HIF-1α and HIF-2α Are Upregulated in the Hippocampus but Not in the Medial Prefrontal Cortex in Experimental PTSD.
Journal: Brain and behavior
In common: pandas, behavior only, rat
[4] doi:10.1126/sciadv.adw3876 [code]
Intracortical brain-computer interface for navigation in virtual reality in macaque monkeys.
Journal: Science advances
In common: pandas, 1 reference
[5] doi: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: pandas, 1 reference
[6] doi:10.1016/j.celrep.2026.117420 [code]
Neural population dynamics of direct electrical stimulation of neocortex.
Journal: Cell reports
In common: pandas, 1 reference
[7] doi:10.1016/j.crmeth.2026.101421 [code]
EthoPy provides an accessible platform for reproducible behavioral neuroscience.
Journal: Cell reports methods
In common: pandas, behavior only, methods / tools
[8] doi:10.1117/1.nph.13.s3.s32603 [code]
SNIRF2BIDS: a GUI-based tool for converting functional near-infrared spectroscopy data to the Brain Imaging Data Structure in R.
Journal: Neurophotonics
In common: methods / tools, 1 reference
[9] doi:10.1007/s12021-026-09814-0 [code]
Application of Machine Learning Models to Identify Differences in Neural Electrophysiological Properties Across Estrous Cycle Phases.
Journal: Neuroinformatics
In common: pandas, rat, methods / tools
[10] doi:10.1038/s41467-026-76939-w [code]
HIPPIE: a generative model for electrophysiological analysis across species, technologies, and modalities.
Journal: Nature communications
In common: pandas, rat, methods / tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.