def __init__(self, drive): """ Standard Constructor """ logging.info("Straight Line Speed constructor") # set up ADC self.i2c_helper = ABEHelpers() self.bus = self.i2c_helper.get_smbus() self.adc = ADCPi(self.bus, 0x6a, 0x6b, 12) # define fixed values self.stopped = 0 self.full_forward = 0.5 self.slow_forward = 0.1 self.full_reverse = -0.5 self.slow_reverse = -0.1 self.left_steering = -0.25 self.right_steering = 0.25 self.straight = 0 self.distance_sensor = 1 # Voltage value we are aiming for (2 was close, 0.5 was further away) self.nominal_voltage = 0.5 self.min_dist_voltage = 2.0 self.max_dist_voltage = 0.4 # Drivetrain is passed in self.drive = drive self.killed = False
def __init__(self, drive): """ Standard Constructor """ logging.info("Three Point Turn constructor") # set up ADC self.i2c_helper = ABEHelpers() self.bus = self.i2c_helper.get_smbus() self.adc = ADCPi(self.bus, 0x6a, 0x6b, 12) # define fixed values # red is typically 3.5V self.red_min = 3 self.red = 3.5 self.stopped = 0 self.full_forward = 0.5 self.half_forward = 0.25 self.slow_forward = 0.1 self.full_reverse = -0.5 self.half_reverse = -0.25 self.slow_reverse = -0.1 self.straight = 0 self.full_left = -1 self.slow_left = -0.5 self.rear_line_sensor = 2 # same sensor for now self.front_line_sensor = 2 self.max_rate = 2 # Drivetrain is passed in self.drive = drive self.killed = False
def __init__(self): """ Standard Constructor """ logging.info("Three Point Turn constructor") # set up ADC self.i2c_helper = ABEHelpers() self.bus = self.i2c_helper.get_smbus() self.adc = ADCPi(self.bus, 0x6a, 0x6b, 12) self.killed = False
def __init__(self): #Get the ADC fired up. i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() self.adc = ADCPi(bus, 0x68, 0x69, 12) #Open the serial port for use. roboclaw.Open("/dev/ttyAMA0", 38400) print("Serial port open!") self.address = 0x80 #Networking vars. Currently set to Christian's IP and Laptop client_IP = "10.42.0.87" port = 6969 self.server_address = (client_IP, port) #Set the max speed of the motors. Max/min is +32767/-32767 self.max_speed = 20000 self.min_speed = -20000 #Scaling params. Experimentally obtained. self.adc_min = 0.600453 self.adc_max = 4.6000 self.mapped_max = 0 #Yes, max is zero and min is 100. self.mapped_min = 100 #This is due to backward wiring in TVCBey and on my part. #Vars needed for mapping method. self.adc_span = self.adc_max - self.adc_min self.mapped_span = self.mapped_max - self.mapped_min #Initializing feedbacks self.x_feedback = 0 self.y_feedback = 0 #PID Params. They're currently same for x and y kp = 2500 ki = 50 kd = 0 sample_time = 0.001 #Objects from the PID.py import. See documentation there. self.x_PID = PID.PID(kp, ki, kd) self.y_PID = PID.PID(kp, ki, kd) self.x_PID.setSampleTime(sample_time) self.y_PID.setSampleTime(sample_time) #Zero point for actuators to balance motor self.x_zero = 54 #Experimentally defined self.y_zero = 51 self.x_output_error_range = 1500 self.y_output_error_range = 1000
def hallSen(): # GPIO Setup GPIO.setmode(GPIO.BOARD) GPIO.setup(7, GPIO.OUT) text_file = open("hallSensor_Data.txt", "w") initTime = time.time() t1 = 0 t2 = 0 flag = 0 diameter = 14 # need to find the actual diameter !!! i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc = ADCDifferentialPi(bus, i2cAddr1, i2cAddr2, bitRate) SevenSeg.initDisplay() while (True): voltage = adc.read_voltage( channel ) # voltage output from hall sensor (either a pos. or neg. value) curTime = time.time( ) - initTime # calculates the current time from time acc. minus time started with if voltage < 0.0 and flag == 0: # if voltage is neg. and we have not passed by the magnet yet flag = 1 t1 = t2 # stores the previous curent time from curTime t2 = curTime # stores the current time in curTime rps = 1 / (t2 - t1) # revolutions per second mph = rps * (math.pi) * diameter * ( 3600 / 63360) # conversion from rps to miles per second #mph = rps*60 #print( str(curTime) + "," + str(voltage) + "," + str(mph) ) #text_file.write( str(curTime) + "," + str(voltage) + "," + str(mph) + "\n" ) elif voltage < 0.0 and flag == 1: # else if voltage is neg. but we are currently still passing by the magnet #print( str(curTime) + "," + str(voltage) ) #text_file.write( str(curTime) + "," + str(voltage) + "\n" ) temp = 1 else: # else the voltage is positive (meaning the magnet is not next the the hall sensor) flag = 0 #print( str(curTime) + "," + str(voltage) ) #text_file.write( str(curTime) + "," + str(voltage) + "\n" ) SevenSeg.displayNum(int(mph)) #time.sleep( 0.0100 ) text_file.close()
def main(): """ Main function """ i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc_instance = ADCPi(bus, 0x68, 0x69, 18) windreader = WindReader(adc_instance) windreader.daemon = True windreader.start() loggers = {} for channel, codename in settings.channels.items(): loggers[codename + '_raw'] = ValueLogger(windreader, comp_val=1.05, channel=channel + '_raw', maximumtime=30) loggers[codename + '_raw'].start() loggers[codename] = ValueLogger(windreader, comp_val=1.005, channel=channel, maximumtime=30) loggers[codename].start() codenames = [] for name in settings.channels.values(): codenames.append(name) codenames.append(name + '_raw') socket = DateDataPullSocket('Fumehood Wind Speed', codenames, timeouts=2.0) socket.start() live_socket = LiveSocket('Fumehood Wind Speed', codenames) live_socket.start() db_logger = ContinuousDataSaver( continuous_data_table=settings.dateplot_table, username=credentials.user, password=credentials.passwd, measurement_codenames=codenames) db_logger.start() time.sleep(10) while windreader.is_alive(): time.sleep(0.25) for name in codenames: value = loggers[name].read_value() socket.set_point_now(name, value) live_socket.set_point_now(name, value) if loggers[name].read_trigged(): print(name + ': ' + str(value)) db_logger.save_point_now(name, value) loggers[name].clear_trigged()
def main(): """ Main function """ logging.basicConfig(filename="logger.txt", level=logging.ERROR) logging.basicConfig(level=logging.ERROR) i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc_instance = ADCPi(bus, 0x68, 0x69, 18) pressurereader = PressureReader(adc_instance) pressurereader.daemon = True pressurereader.start() codenames = ['chemlab312_sample_storage_pressure'] loggers = {} for i in range(0, 1): loggers[codenames[i]] = ValueLogger(pressurereader, comp_val=0.05, comp_type='log') loggers[codenames[i]].start() socket = DateDataPullSocket('chemlab312_sample_storage', codenames, timeouts=[2.0]) socket.start() live_socket = LiveSocket('chemlab312_sample_storage', codenames) live_socket.start() db_logger = ContinuousDataSaver( continuous_data_table='dateplots_chemlab312', username=credentials.user, password=credentials.passwd, measurement_codenames=codenames) db_logger.start() time.sleep(5) while True: time.sleep(0.5) for name in codenames: value = loggers[name].read_value() socket.set_point_now(name, value) live_socket.set_point_now(name, value) if loggers[name].read_trigged(): print(value) db_logger.save_point_now(name, value) loggers[name].clear_trigged()
def init_servos(address): i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() pwm = PWM(bus, address) pwm.set_pwm_freq(60) pwm.output_enable() # cycle the arms on channels 0, 2, 4 print('cycling through all valid positions') for x in (175, 300, 425, 550): pwm.set_pwm(0, 0, x) sleep(1) pwm.set_pwm(2, 0, x) sleep(1) pwm.set_pwm(4, 0, x) sleep(2) return pwm
def main(): """ Main function """ logging.basicConfig(filename="logger.txt", level=logging.ERROR) logging.basicConfig(level=logging.ERROR) i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc_instance = DeltaSigma(bus, 0x68, 0x69, 18) tempreader = TemperatureReader(adc_instance) tempreader.daemon = True tempreader.start() codenames = ['cooling_water_hot', 'cooling_water_cold'] loggers = {} for i in range(0, 2): loggers[codenames[i]] = ValueLogger(tempreader, comp_val=0.5, channel=i) loggers[codenames[i]].start() socket = DateDataPullSocket('hall_cooling_water_temp', codenames, timeouts=2.0) socket.start() live_socket = LiveSocket('hall_waterpressure', codenames) live_socket.start() db_logger = ContinuousDataSaver(continuous_data_table='dateplots_hall', username=credentials.user, password=credentials.passwd, measurement_codenames=codenames) db_logger.start() time.sleep(5) while tempreader.is_alive(): time.sleep(0.25) for name in codenames: value = loggers[name].read_value() socket.set_point_now(name, value) live_socket.set_point_now(name, value) if loggers[name].read_trigged(): print(value) db_logger.save_point_now(name, value) loggers[name].clear_trigged()
def run(self): global mph global flag t1 = 0 t2 = 0 flagMine = 0 diameter = 14 # need to find the actual diameter !!! i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc = ADCDifferentialPi(bus, i2cAddr1, i2cAddr2, bitRate) while True: c.acquire() if flag == 1: flag = 0 voltage = adc.read_voltage( channel ) # voltage output from hall sensor (either a pos. or neg. value) curTime = time.time() - initTime # calculates the current time from time acc. minus time started with if voltage < 0.0 and flagMine == 0: # if voltage is neg. and we have not passed by the magnet yet flagMine = 1 t1 = t2 # stores the previous curent time from curTime t2 = curTime # stores the current time in curTime rps = 1/(t2 - t1) # revolutions per second mph = rps * (math.pi) * diameter * (3600/63360) # conversion from rps to miles per second #mph = rps*60 #print( str(curTime) + "," + str(voltage) + "," + str(mph) ) #text_file.write( str(curTime) + "," + str(voltage) + "," + str(mph) + "\n" ) elif voltage < 0.0 and flagMine == 1: # else if voltage is neg. but we are currently still passing by the magnet #print( str(curTime) + "," + str(voltage) ) #text_file.write( str(curTime) + "," + str(voltage) + "\n" ) temp = 1 else: # else the voltage is positive (meaning the magnet is not next the the hall sensor) flagMine = 0 #print( str(curTime) + "," + str(voltage) ) #text_file.write( str(curTime) + "," + str(voltage) + "\n" ) #mph = mph + 1 c.notify_all() else: c.wait() c.release() text_file.close()
def main(): """ Main function """ logging.basicConfig(filename="logger.txt", level=logging.ERROR) logging.basicConfig(level=logging.ERROR) i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc_instance = ADCPi(bus, 0x68, 0x69, 18) pressurereader = PressureReader(adc_instance) pressurereader.daemon = True pressurereader.start() logger = ValueLogger(pressurereader, comp_val=0.5) logger.start() socket = DateDataPullSocket('hall_n5_argon_pressure', ['n5_argon_pressure'], timeouts=[1.0]) socket.start() live_socket = LiveSocket('hall_n5_argon_pressure', ['n5_argon_pressure'], 2) live_socket.start() db_logger = ContinuousDataSaver( continuous_data_table='dateplots_hall', username=credentials.user, password=credentials.passwd, measurement_codenames=['n5_argon_pressure']) db_logger.start() time.sleep(2) while True: time.sleep(0.25) value = logger.read_value() socket.set_point_now('n5_argon_pressure', value) live_socket.set_point_now('n5_argon_pressure', value) if logger.read_trigged(): print(value) db_logger.save_point_now('n5_argon_pressure', value) logger.clear_trigged()
def StrainGauge(): text_file = open("strainGuage_Data.txt", "w") i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc = ADCDifferentialPi(bus, i2cAddr1, i2cAddr2, bitRate) adc.set_pga( 1) # Set the gain of the PDA on the chip (Parameters: gain - 1,2,4,8) prev_voltage = 0 for i in range(10000): voltage = adc.read_voltage(channel) # voltage output from strain Gauge changeInVoltage = voltage - prev_voltage prev_voltage = voltage #print( str(changeInVoltage * 1000) ) text_file.write(str(voltage) + "\n")
def __init__(self, bus=None, address=None, address2=None, samplerate=None, gain=None): from ABE_helpers import ABEHelpers from ABE_ADCDifferentialPi import ADCDifferentialPi if bus is None: i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() # Initialize the ADC device using the default addresses and sample rate 18. # Sample rate can be 12, 14, 16 or 18. self.adc = ADCDifferentialPi(bus, address=address, address2=address2, rate=samplerate) # Set amplifier gain to 8. if gain is not None: self.adc.set_pga(gain)
This example shows how to use the interrupt methods on the IO Pi. The interrupts will be enabled and set so that a voltage applied to pins 1 and 16 will trigger INT A and B respectively. using the read_interrupt_capture or read_port methods will reset the interrupts Initialise the IOPi device using the default addresses and set the output of bank 1 on IC1 to the input of bank 1 on IC2 """ from ABE_helpers import ABEHelpers from ABE_IoPi import IoPi import time i2c_helper = ABEHelpers() newbus = i2c_helper.get_smbus() bus1 = IoPi(newbus, 0x20) bus2 = IoPi(newbus, 0x21) # Set all pins on bus 2 to be inputs with internal pull-ups disabled. bus2.set_port_pullups(0, 0x00) bus2.set_port_pullups(1, 0x00) bus2.set_port_direction(0, 0xFF) bus2.set_port_direction(1, 0xFF) # Set the interrupt polarity to be active high and mirroring disabled, so # pins 1 to 8 trigger INT A and pins 9 to 16 trigger INT B bus2.set_interrupt_polarity(1)
def hallSen(hallSensor_Num, adcChannel_Num, adcBitRate_Num, i2cAddr1_Num, i2cAddr2_Num, outputFile_Name, diameter_Num, hallSensorActive): # ADC Setup channel = 1 # analog channel number (1-8 inclusive) bitRate = 12 # programmable data rate # 18 (3.75 SPS) less per sec. but more # 16 ( 15 SPS) -- # 14 ( 60 SPS) -- # 12 ( 240 SPS) more per sec. but less accurate i2cAddr1 = 0x68 # these address are associated with the Address Config. 1 i2cAddr2 = 0x69 text_file = open("hallSensor_Data1.txt", "w") initTime = time.time() t1 = 0 t2 = 0 flag = 0 diameter = 14 # need to find the actual diameter !!! i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc = ADCDifferentialPi(bus, i2cAddr1, i2cAddr2, bitRate) global activeMphValues global flagThread global activeHallSensors activeHallSensors.append(hallSensorActive) mph = 0 activeMphValues.append(mph) #activeMphValues[hallSensor_Num-1] = mph while activeHallSensors[hallSensor_Num - 1]: voltage = adc.read_voltage( channel ) # voltage output from hall sensor (either a pos. or neg. value) curTime = time.time( ) - initTime # calculates the current time from time acc. minus time started with if voltage < 0.0 and flag == 0: # if voltage is neg. and we have not passed by the magnet yet flag = 1 t1 = t2 # stores the previous current time from curTime t2 = curTime # stores the current time in curTime rps = 1 / (t2 - t1) # revolutions per second activeMphValues[ hallSensor_Num - 1] = (rps * (math.pi) * diameter * (3600 / 63360) ) / 11.5 # conversion from rps to miles per second #temp = rps * (math.pi) * diameter * (3600/63360) rpm = rps * 60 #activeMphValues[hallsensor_Num-1] = rpm #mph = rps*60 #print( str(curTime + "," + str(voltage) + "," + str(mph) ) text_file.write(str(curTime) + "," + str(rpm) + "\n") text_file.flush() elif voltage < 0.0 and flag == 1: # else if voltage is neg. but we are currently still passing by the magnet #print( str(curTime) + "," + str(voltage) ) #text_file.write( str(curTime) + "," str(voltage) + "\n" ) filler = 0 else: # else the voltage is positive (meaning the magnet is not next to the hall sensor) flag = 0 #print( str(curTime) + "," + str(voltage) ) #text_file.write( str(curTime) + "," + str(voltage) + "\n" ) flag = 0 # added hopefully no problems, if problems comment this out #time.sleep( 0.0100 ) text_file.close()
def hallSen(): # ADC Setup channel = 1 # analog channel number (1-8 inclusive) bitRate = 12 # programmable data rate # 18 (3.75 SPS) less per sec. but more accurate # 16 ( 15 SPS) -- # 14 ( 60 SPS) -- # 12 ( 240 SPS) more per sec. but less accurate i2cAddr1 = 0x68 # these addresses are associated with the Address Config. 1 i2cAddr2 = 0x69 text_file = open("hallSensor_Data_1.txt", "w") initTime = time.time() text_file.write(str(globalValue)) text_file.flush() global t1 global t2 flag = 0 diameter = 14 # need to find the actual diameter !!! i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc = ADCDifferentialPi(bus, i2cAddr1, i2cAddr2, bitRate) global mph global flagThread global killH while True: if killH == True: text_file.close() time.sleep(10) else: voltage = adc.read_voltage( channel ) # voltage output from hall sensor (either a pos. or neg. value) curTime = time.time( ) - initTime # calculates the current time from time acc. minus time started with if voltage < 0.0 and flag == 0: # if voltage is neg. and we have not passed by the magnet yet flag = 1 t1 = t2 # stores the previous curent time from curTime t2 = curTime # stores the current time in curTime rps = 1 / (t2 - t1) # revolutions per second flagThread = 1 mph = rps * (math.pi) * diameter * ( 3600 / 63360) # conversion from rps to miles per second rpm = rps * 60 flagThread = 0 #mph = rps*60 #print( str(curTime) + "," + str(voltage) + "," + str(mph) ) text_file.write(str(curTime) + "," + str(rpm) + "\n") text_file.flush() elif voltage < 0.0 and flag == 1: # else if voltage is neg. but we are currently still passing by the magnet #print( str(curTime) + "," + str(voltage) ) #text_file.write( str(curTime) + "," + str(voltage) + "\n" ) filler = 0 else: # else the voltage is positive (meaning the magnet is not next the the hall sensor) flag = 0 #print( str(curTime) + "," + str(voltage) ) #text_file.write( str(curTime) + "," + str(voltage) + "\n" ) #time.sleep( 0.0100 ) text_file.close()
def init_nox(): """ init the sensor reader """ i2c_helper = ABEHelpers() bus = i2c_helper.get_smbus() adc = ADCPi(bus, 0x6A, 0x6B, 12) return adc
def __init__(self, master): self.i2c_helper = ABEHelpers() self.newbus = self.i2c_helper.get_smbus() self.bus2 = IoPi( self.newbus, 0x21 ) # create an instance of Bus 2 which is on I2C address 0x21 by default self.bus2.set_port_direction( 0, 0x00) # set pins 1 to 8 to be outputs and turn them off self.bus2.write_port(0, 0x00) self.bus2.set_port_direction( 1, 0x00) # set pins 9 to 16 to be outputs and turn them off self.bus2.write_port(1, 0x00) frame = Frame(master) # create a frame for the GUI frame.pack() # create 16 buttons which run the togglepin function when pressed self.button = Button(frame, text="Pin 1", command=lambda: self.togglepin(1)) self.button.pack(side=LEFT) self.slogan = Button(frame, text="Pin 2", command=lambda: self.togglepin(2)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 3", command=lambda: self.togglepin(3)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 4", command=lambda: self.togglepin(4)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 5", command=lambda: self.togglepin(5)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 6", command=lambda: self.togglepin(6)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 7", command=lambda: self.togglepin(7)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 8", command=lambda: self.togglepin(8)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 9", command=lambda: self.togglepin(9)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 10", command=lambda: self.togglepin(10)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 11", command=lambda: self.togglepin(11)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 12", command=lambda: self.togglepin(12)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 13", command=lambda: self.togglepin(13)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 14", command=lambda: self.togglepin(14)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 15", command=lambda: self.togglepin(15)) self.slogan.pack(side=LEFT) self.slogan = Button(frame, text="Pin 16", command=lambda: self.togglepin(16)) self.slogan.pack(side=LEFT)
import RPi.GPIO as GPIO import LCD1602 from ABE_ADCPi import ADCPi #import the ADCPi library from ABE_helpers import ABEHelpers #import ABEHelpers for smbus import time #import time module for delay import smbus #import smbus for i2c LCD1602.init(0x27, 1) #Assign LCD i2c address GPIO.setwarnings(False) #remove uncecessary warnings GPIO.setmode(GPIO.BCM) #setting pin mode to BCM i2c_helper=ABEHelpers() #Creating instance of ABEHelpers() for i2c_bus object bus=i2c_helper.get_smbus() #Creating instance of i2c_bus ADC=ADCPi(bus, 0X69, 0X6f, 18) #Set the i2c configuration address and bit rate time.sleep(0.2) ######### #Keypad input/output pins GPIO.setup(19, GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.setup(20, GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.setup(21, GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.setup(22, GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.setup(23, GPIO.OUT) GPIO.setup(24, GPIO.OUT) GPIO.setup(25, GPIO.OUT) GPIO.setup(26, GPIO.OUT) #Initializing the GPIO pins for Ultrasound, Buzzer, motion sensor, and LED GPIO.setmode(GPIO.BCM) TRIG=13 #ultrasonic