def __init__(self, **kwargs): """Initialize Valve. If there is an error connecting to the external DAC, And if user agrees, sets self.dac to use SimDac class. Otherwise raises Exception. Sets all initial volts values to calibrated off of 45. Requires no external arguments. Contains **kwargs to pass kywd=arg pairs down MRO chain. """ super().__init__(**kwargs) if BOARD: self.__i2c = busio.I2C(board.SCL, board.SDA) self.dac = adafruit_mcp4725.MCP4725(self.__i2c) elif input('Use simulated DAC?\n(Y/N) = ').upper() == 'Y': print() self.dac = SimDac() else: raise Exception("No DAC or unsupported DAC connected.") self.volts = self.clog_volts = self.__optimal_volts = 45 self.__latency = time.time() self.__time_open = 0 self.clogged = False print(":: VALVE INITIALIZED ::\n")
def setup_output(self): import adafruit_mcp4725 from adafruit_extended_bus import ExtendedI2C self.setup_output_variables(OUTPUT_INFORMATION) try: self.dac = adafruit_mcp4725.MCP4725( ExtendedI2C(self.output.i2c_bus), address=int(str(self.output.i2c_location), 16)) self.channel = {0: self.dac.channel_a} # Channel A if self.options_channels['vref'][0] == "internal": self.channel[0].vref = adafruit_mcp4728.Vref.INTERNAL else: self.channel[0].vref = adafruit_mcp4728.Vref.VDD self.channel[0].gain = self.options_channels['gain'][0] if (self.options_channels['state_start'][0] == "value" and self.options_channels['state_start_value'][0]): self.channel[0].value = int( 65535 * (self.options_channels['state_start_value'][0] / self.vref)) self.dac.save_settings() self.output_setup = True except: self.output_setup = False
def __init__(self): self.IMU_ADDRESS = 0x29 self.DRV_ADDRESS = 0x5A self.METER_ADDRESS = '0x40' self.DACL_ADDRESS = 0x62 self.DACR_ADDRESS = 0x63 self.i2c = busio.I2C(board.SCL, board.SDA) devices = self.scan_bus() print(devices) if len(devices) == 0: print('* No I/O device found') if str(self.IMU_ADDRESS) in devices: print('* Motion sensor detected') self.motion = adafruit_bno055.BNO055_I2C(self.i2c, self.IMU_ADDRESS) else: self.motion = None if str(self.DRV_ADDRESS) in devices: haptic = adafruit_drv2605.DRV2605(self.i2c, self.DRV_ADDRESS) haptic.mode(0x03) # Analog/PWM Mode haptic.use_LRM() print('* Haptic driver detected (and set to analog mode)') else: self.haptic = None if str(self.METER_ADDRESS) in devices: self.meter = INA219(0.1, 3) self.meter.configure(self.meter.RANGE_16V) print('* Current sensor detected') else: self.meter = None if str(self.DACL_ADDRESS) in devices: self.leftDAC = adafruit_mcp4725.MCP4725(self.i2c, self.DACL_ADDRESS) print('* Left DAC detected') else: self.leftDAC = None if str(self.DACL_ADDRESS) in devices: self.rightDAC = adafruit_mcp4725.MCP4725(self.i2c, self.DACR_ADDRESS) print('* Left DAC detected') else: self.rightDAC = None
def __init__(self): """Sonicator init.""" self.i2c = busio.I2C(board.SCL, board.SDA) self.dac = adafruit_mcp4725.MCP4725(self.i2c, address=0x60) self.sonicator_enable = digitalio.DigitalInOut(board.D4) self.sonicator_enable.direction = digitalio.Direction.OUTPUT self.sonicator_enable.value = False self.dac.normalized_value = 0.0
def init_mcp4725(): global i2c, dac import board import busio import adafruit_mcp4725 i2c = busio.I2C(board.SCL, board.SDA) dac = adafruit_mcp4725.MCP4725(i2c) set_voltage(0)
def setup_rpi(registry): from controller.device import SwimPumpDevice, TempSensorDevice, TankSensorDevice from controller.device import ArduinoDevice, EZOSensorDevice, LcdDevice # Relay import RPi.GPIO as GPIO setup_gpio(registry, GPIO) # Initialize I2C bus. import board import busio i2c = busio.I2C(board.SCL, board.SDA) # ADC import adafruit_ads1x15.ads1015 as ADS # Create the ADC object using the I2C bus adc = ADS.ADS1015(i2c) # With a gain of 2/3 and a sensor output of 0.25V-5V, the values should be around 83 and 1665 params = ((int, "channel"), (float, "gain"), (int, "low"), (int, "high")) registry.add_sensor( TankSensorDevice("tank", adc, *[t(config["adc", n]) for t, n in params])) # DAC import adafruit_mcp4725 dac = adafruit_mcp4725.MCP4725(i2c) registry.add_pump( SwimPumpDevice("swim", GPIO, int(config["pins", "swim"]), dac)) # pH, ORP registry.add_sensor(EZOSensorDevice("ph", config["serial", "ph"])) registry.add_sensor(EZOSensorDevice("orp", config["serial", "orp"])) # Arduino (cover, water) registry.add_device(ArduinoDevice("arduino", config["serial", "arduino"])) # LCD registry.add_device(LcdDevice("lcd", config["serial", "lcd"])) # 1-wire # 28-031634d04aff # 28-0416350909ff # 28-031634d54bff # 28-041635088bff registry.add_sensor( TempSensorDevice("temperature_pool", config["1-wire", "pool"])) registry.add_sensor( TempSensorDevice("temperature_air", config["1-wire", "air"])) registry.add_sensor( TempSensorDevice("temperature_local", config["1-wire", "local"])) registry.add_sensor( TempSensorDevice("temperature_ncc", config["1-wire", "ncc"]))
def __init__(self,GUI_hvac_Ref): #init de sensores y dac self.GUI_hvac_Ref = GUI_hvac_Ref self.TaskControlTemp = threading.Thread(target = self.ControlTemp_Routine) self.spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) self.cs = digitalio.DigitalInOut(board.D10) self.max31855 = adafruit_max31855.MAX31855(self.spi, self.cs) self.Relay = digitalio.DigitalInOut(board.D13) self.Relay.direction = digitalio.Direction.OUTPUT self.i2c = busio.I2C(board.SCL, board.SDA) self.dac = adafruit_mcp4725.MCP4725(self.i2c, address = 0x60) self.TaskControlTemp.start() pass
def __init__(self, i2c, gps: UBX): # Drive Controller (Millipak) Digital Pins self.forward = DIO.DigitalInOut(board.D16) # D3 self.reverse = DIO.DigitalInOut(board.D26) # D4 self.fs1 = DIO.DigitalInOut(board.D19) # D5 self.seat = DIO.DigitalInOut(board.D13) # D6 self.power = DIO.DigitalInOut(board.D6) # D7 # Set as outputs self.forward.direction = DIO.Direction.OUTPUT self.reverse.direction = DIO.Direction.OUTPUT self.fs1.direction = DIO.Direction.OUTPUT self.seat.direction = DIO.Direction.OUTPUT self.power.direction = DIO.Direction.OUTPUT # I2C and ADC Setup self._i2c_interface = i2c # Setup Drive Speed DAC self.dac_output = DAC.MCP4725(self._i2c_interface, address=96) # Speed self._measured_speed = 0. self._speed_set_point = 0. # Speed PID Controller self._prev_error = 0. self.p_gain = 0.5 self.d_gain = 1 self._output_voltage = 0. self._max_output_voltage = 1. # GPS self._gps = gps # Threading self._speed_thread = None self._stop_threads = False # Set DAC Output to 0V self.dac_output.value = 0
import mido import adafruit_mcp4725 import board import busio i2c_1 = busio.I2C(board.SCL, board.SDA) #i2c_2 = busio.I2C(24, 23) dac_PITCH = adafruit_mcp4725.MCP4725(i2c_1, address=0x60) dac_HOLD = adafruit_mcp4725.MCP4725(i2c_1, address=0x61) #dac_MOD = adafruit_mcp4725.MCP4725(i2c_2, address= 0x60) #dac_TRIG = adafruit_mcp4725.MCP4725(i2c_2, address= 0x61) from midi_handler import * from port_manager import * p = PortManager() m = MidiHandler() try: while True: if not p.is_scanning: with mido.open_input(p.input_name) as port: while not port.closed: for msg in port.iter_pending(): m.input_signal(msg) if p.is_scanning: port.close() dac_PITCH.normalized_value = m.PITCH_V except KeyboardInterrupt: GPIO.cleanup()
def __init__(self, gps: UBX): # self.steer = SteeringController(i2c=i2c) # self.speed = SpeedController(i2c=i2c, gps=gps) self.sampling_time = 0.001 self.time_stamp = 0. # Steering Digital Pins self.left_pin = DIO.DigitalInOut(board.D21) # D1 self.right_pin = DIO.DigitalInOut(board.D20) # D2 # Set as outputs self.left_pin.direction = DIO.Direction.OUTPUT self.right_pin.direction = DIO.Direction.OUTPUT # Drive Controller (Millipak) Digital Pins self.forward = DIO.DigitalInOut(board.D16) # D3 self.reverse = DIO.DigitalInOut(board.D26) # D4 self.fs1 = DIO.DigitalInOut(board.D19) # D5 self.seat = DIO.DigitalInOut(board.D13) # D6 self.power = DIO.DigitalInOut(board.D6) # D7 # Set as outputs self.forward.direction = DIO.Direction.OUTPUT self.reverse.direction = DIO.Direction.OUTPUT self.fs1.direction = DIO.Direction.OUTPUT self.seat.direction = DIO.Direction.OUTPUT self.power.direction = DIO.Direction.OUTPUT # GPS self._gps = gps # self._gps.start_reading() # I2C and ADC Setup self._i2c_interface = busio.I2C(board.SCL, board.SDA) # Setup Steering Angle ADC adc = ADC.ADS1115(self._i2c_interface, address=72) self.steer_adc = AnalogIn(adc, ADC.P0) # Setup Steering Angle DAC self.steer_dac = DAC.MCP4725(self._i2c_interface, address=97) # Setup Drive Speed DAC self.speed_dac = DAC.MCP4725(self._i2c_interface, address=96) # Speed self._measured_speed = 0. self._speed_set_point = 0. self._stop = False # Speed PID Controller self._prev_error_speed = 0. self._cumulative_error_speed = 0. # Original non-time related # self.p_gain_speed = 0.01 # self.d_gain_speed = 1. # self.i_gain_speed = 0. # Sample time related self.p_gain_speed = 0.01 self.d_gain_speed = 1. / 1000 self.i_gain_speed = 0. * 1000 self._speed_output_voltage = 0 self._max_speed_voltage = 1.6 self.driving_forward = True # Steering # 0 Degree Steer = 2.582V self._steer_output_voltage = 0. self._max_steer_voltage = 4.5 self._min_steer_voltage = 0.05 self._steering_angle_set_point = 0. self._current_steering_angle = 0. self._steer_adc_measurements = deque(maxlen=1) self._steering_changed = False self._steer_adc_average = 0. self._steer_adc_set_point = 0. self.left_max = 20 self.right_max = -20 # Steering PID Controller # Original non-time related # self.p_gain_steer = 15. # self.d_gain_steer = 0. # self.i_gain_steer = .2 # Sampling time related self.p_gain_steer = 15. self.d_gain_steer = 0. / 1000 self.i_gain_steer = .2 * 1000 self._prev_error_steer = 0. self._cumulative_error_steer = 0. # Set DAC Output self.steer_dac.value = 0 self.speed_dac.value = 0 # Threading self._stop_threads = False self._control_thread = None
import busio import time from simpleio import map_range import adafruit_trellism4 import adafruit_adxl34x # accelerometer import adafruit_mcp4725 # external DACs trellis = adafruit_trellism4.TrellisM4Express() acc_i2c = busio.I2C(board.ACCELEROMETER_SCL, board.ACCELEROMETER_SDA) # for accelerometer dac_i2c = busio.I2C(board.SCL, board.SDA) # for DACs # Initialize accelerometer and DACs accelerometer = adafruit_adxl34x.ADXL345(acc_i2c) pitch_dac = adafruit_mcp4725.MCP4725(dac_i2c, address=0x62) gate_dac = adafruit_mcp4725.MCP4725(dac_i2c, address=0x63) # There are a three ways to set the DAC output, you can use any of these: # dac2.value = 65535 # dac2.raw_value = 4095 # dac2.normalized_value = 1.0 step_delay = 0.0 print("2018-12-18 dual DAC CV test v02.py") while True: x, y, z = accelerometer.acceleration # print((x,y,z))
'AutoStart': 4, 'ErrorFlag': 5, 'Bottle': 6, 'DataMemory': 7, 'CalMemory': 8 } # MFC i2c = busio.I2C(board.SCL, board.SDA) ads = ADS.ADS1015(i2c) # MFC_1 sample flow MFC_SAMPLE = { 'NAME': 'sample', 'DAC': adafruit_mcp4725.MCP4725(i2c), 'ADC': AnalogIn(ads, ADS.P1), 'RANGE': 3.0, 'FLOW': 1.0, 'LOWER_LIMIT': 0.75, 'UPPER_LIMIT': 1.25, } # MFC_2 zero air flow MFC_CAL = { 'NAME': 'cal', 'DAC': adafruit_mcp4725.MCP4725(i2c, address=0x63), 'ADC': AnalogIn(ads, ADS.P2), 'RANGE': 5.0, 'FLOW': 2.0, 'LOWER_LIMIT': 1.5,
class Heater: desired_temp = None # Fully populated once constructed current_step = 0 # Track which iteration we are on temperature_readings = [0] # Add to list as we step errors = [0] # Add to this as we step current_temperature = 0 # Updated in step() if on_pi_hardware: # Raspberry Pi software SPI configuration. (For thermocouple) CLK = 25 CS = 24 DO = 18 sensor = MAX31855.MAX31855(CLK, CS, DO) # Raspberry Pi hardware SPI configuration. (For thermocouple) # SPI_PORT = 0 # SPI_DEVICE = 0 # sensor = MAX31855.MAX31855(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=5000000)) i2c = busio.I2C(board.SCL, board.SDA) dac = adafruit_mcp4725.MCP4725(i2c) # Calculates the temperature based on dni_arr and secs_per_cycle def __init__(self, dni_arr, secs_per_cycle): self.mutex = Lock() # sample every secs_per_cycle since this probably won't run every second desired_temp = dni_arr[::secs_per_cycle] # multiply by 2 for some reason desired_temp = np.multiply(desired_temp, 2) # v = (5 / 208) * (DNI) / sqrt(DNI / R)(on each element in the list) R = 15 voltage_ratio = 5 / 208 # The ratio of the analog control voltage to max voltage into the heater for i in range(0, len(desired_temp)): desired_temp[i] = voltage_ratio * desired_temp[i] / math.sqrt( desired_temp[i] / R) # desired_temp = 8.6*v^2 + 115v (on each element in the list) # Estimated calibration equation, analog voltage to Celsius for i in range(0, len(desired_temp)): desired_temp[i] = 8.6 * math.pow(desired_temp[i], 2) + 115 * desired_temp[i] self.desired_temp = desired_temp print("DEBUG: [Heater] Constructed") # public facing step method # spawns a thread and calls the synchronous step_sync helper method def step(self): print("DEBUG: [Heater] Stepping") t1 = Thread(target=self.__step_sync) t1.start() # private synchronous helper method that runs each time we need to check heater temp def __step_sync(self): # Stop stepping once we have reached the end of the desired_temp array # (for the case where the desired_temp arr is not evenly divisible by secs_per_cycle if self.current_step >= len(self.desired_temp) - 1: return else: self.current_step += 1 if not on_pi_hardware: return self.mutex.acquire() print("DEBUG: [Heater] Stepping for", self.current_step) # Read the current temperature current_temp = self.sensor.readTempC() self.current_temperature = current_temp # Calculate the control temperature kP = 1000 ki = 10 kd = 25 # control_temperature = desired_temp_c[currentsecond] + kP * error[current reading and current desired # temperature] + ki * [sum of all errors] + kd * (this error - previous error) ref_temp = self.desired_temp[self.current_step] error = ref_temp - current_temp control_temperature = ref_temp + kP * error + ki * np.sum( self.errors) + kd * self.errors[len(self.errors) - 1] self.errors.append(error) # convert control temperature to voltage control_voltage = 500 * control_temperature # actual dac output (0-4096) actual_dac_output = control_voltage / 5 * 4096 if actual_dac_output > 4096: actual_dac_output = 4096 elif actual_dac_output < 0: actual_dac_output = 0 self.dac.set_voltage(actual_dac_output) print("DEBUG: [Heater] Done stepping for", self.current_step) self.mutex.release() # returns the state of this stepper motor def get_state(self): return { "current_temperature": str(self.current_temperature), "reference_temperature": str(self.desired_temp[self.current_step]) } def get_desired_temp_arr(self): return self.desired_temp.tolist()
I2C1_SDA_PIN = 2 I2C1_SCL_PIN = 3 # For Channel 0 # GPIO 0, Board Pin Numbers 27 # GPIO 1, Board Pin Numbers 28 # Initialize I2C bus. i2c = busio.I2C(I2C1_SCL_PIN, I2C1_SDA_PIN) # default TCA address=0x70 tca = adafruit_tca9548a.TCA9548A(i2c) print("attempting to connect to DAC") # Initialize all 5 MCP4725 at default address=0x60 time.sleep(1) dac1 = adafruit_mcp4725.MCP4725(tca[0], address=0x60) print("connected to MCP on tca[0]") input("Press enter...") time.sleep(1) dac2 = adafruit_mcp4725.MCP4725(tca[1], address=0x60) print("connected to MCP on tca[1]") input("Press enter...") dac3 = adafruit_mcp4725.MCP4725(tca[2], address=0x60) print("connected to MCP on tca[2]") input("Press enter...") dac4 = adafruit_mcp4725.MCP4725(tca[3], address=0x60) print("connected to MCP on tca[3]") input("Press enter...") dac5 = adafruit_mcp4725.MCP4725(tca[4], address=0x60) print("connected to MCP on tca[4]") # Optionally you can specify a different addres if you override the A0 pin.
def controller_thread(): global state global dac_value global on_button_pressed global off_button_pressed global shutoff_timer_start # Open the DAC device. i2c = busio.I2C(board.SCL, board.SDA) dac = adafruit_mcp4725.MCP4725(i2c) # Get the current value of the DAC. We read the value 10 times from I2C to avoid reading an erroneously high value that would cause the RAMP_DOWN state to write that erroneously high value back to the DAC and break the crystal. dac_readings = [] print("Starting controller...", end='', flush=True) for _ in range(10): dac_readings.append(dac.raw_value) print('.', end='', flush=True) time.sleep(0.05) print("\nController started.") dac_value = int(sum(dac_readings) / float(len(dac_readings))) # If the DAC isn't off right now, ramp down. if dac_value > 0: log_action("AUTO", "FILAMENT_OFF", "") state = RAMP_DOWN if computer_control: status_led_flash_red() else: state = OFF if computer_control: status_led_solid_red() # Main state machine loop. while True: if state == OFF: if on_button_pressed: shutoff_timer_start = time.time() status_led_flash_green() state = RAMP_UP off_button_pressed = False on_button_pressed = False time.sleep(0.1) elif state == RAMP_UP: off_button_pressed = False on_button_pressed = False time.sleep(float(RAMP_TIME_SECONDS) / (max_dac_value + 1)) dac_value += 1 dac.raw_value = dac_value if dac_value >= max_dac_value: state = ON status_led_solid_green() elif state == ON: if off_button_pressed: state = RAMP_DOWN status_led_flash_red() if time.time( ) - shutoff_timer_start >= SHUTOFF_TIMER_DURATION_SECONDS: state = RAMP_DOWN status_led_flash_red() log_action("SHUTOFF", "FILAMENT_OFF", "") off_button_pressed = False on_button_pressed = False time.sleep(0.1) elif state == RAMP_DOWN: off_button_pressed = False on_button_pressed = False time.sleep(float(RAMP_TIME_SECONDS) / (max_dac_value + 1)) dac_value -= 1 dac.raw_value = dac_value if dac_value <= 0: state = OFF status_led_solid_red()
def main(self, config, log, local): from inputs import get_gamepad, UnpluggedError, devices from time import sleep import adafruit_mcp4725 i2c = busio.I2C(board.SCL, board.SDA) motor = adafruit_mcp4725.MCP4725(i2c) # PulseIO is not yet supported on Raspberry Pi # (f11384e0 is the last commit with Adafruit Servo code # should Pi's be supported in the future.) import pigpio steering = pigpio.pi() reverse = digitalio.DigitalInOut(board.D24) reverse.direction = digitalio.Direction.OUTPUT reverse.value = True boost = False currentSteeringSensetivity = 0 log["driveUnit.reverse"] = False while True: try: leftStickCenter = None leftStickPosition = None while leftStickCenter == None: events = get_gamepad() for event in events: if event.code == "ABS_X": leftStickPosition = event.state if event.code == "BTN_SELECT": if leftStickPosition != None: leftStickCenter = leftStickPosition gamepad = devices.gamepads[0] while True: events = get_gamepad() log['driveUnit.controllerConnected'] = True for event in events: if event.code == "BTN_SELECT": leftStickCenter = leftStickPosition if event.code == "BTN_WEST": reverse.value = not event.state log["driveUnit.reverse"] = not reverse.value # The reverse pin/transistor is pulled the wrong way, so this double invert is needed. if event.code == "BTN_EAST": boost = event.state log["driveUnit.boost"] = boost if event.code == "ABS_X": leftStickPosition = event.state steeringInput = event.state - leftStickCenter log["driveUnit.steeringInput"] = steeringInput steeringNormalized = steeringInput / 16384 speed = speedUnit.getSpeed(config, speedUnitLocal) if speed > 10 and config[ 'speedSteeringSensitivity']: # Ajust steering sensetivity/range based on speed. if speed < currentSteeringSensetivity: if -config[ 'steeringDeadzone'] < steeringNormalized < config[ 'steeringDeadzone']: steeringNormalized = steeringNormalized / ( speed / 10 ) # Adjust steering sensitivity based on speed. currentSteeringSensetivity = speed else: steeringNormalized = steeringNormalized / ( speed / 10 ) # Adjust steering sensitivity based on speed. currentSteeringSensetivity = speed steeringNormalized = steeringNormalized * config[ 'steeringSensitivity'] if -config[ 'steeringDeadzone'] < steeringNormalized < config[ 'steeringDeadzone']: steeringNormalized = 0 elif steeringNormalized < 0: steeringNormalized += config[ 'steeringDeadzone'] elif steeringNormalized > 0: steeringNormalized -= config[ 'steeringDeadzone'] self.setSteering(log, steering, steeringNormalized) elif event.code == "ABS_RZ": throttleInput = event.state log["driveUnit.throttleInput"] = throttleInput throttleNormalized = ( (throttleInput * (0.76 - 0.18)) / 1024) + 0.18 # Motor activates at ~0.24 if throttleNormalized > 0.2 and boost: throttleNormalized = 1 self.setMotor(config, log, motor, throttleNormalized) except Exception as exception: log["exceptions"].append(str(exception)) if type(exception) == UnpluggedError: log['driveUnit.controllerConnected'] = False motor.normalized_value = 0 reverse.value = 0
# from Cedar Grove's CircuitPython StringCar Racer project # adapted for John Park's workshop 3/29/2018 pan/tilt project # modified for dual DAC output to drive oscilloscope # ### Setup ### import board import time import neopixel as neo from analogio import AnalogIn, AnalogOut import busio import adafruit_mcp4725 ext_i2c = busio.I2C(board.SCL, board.SDA) # for DACs x_out = adafruit_mcp4725.MCP4725(ext_i2c, address=0x62) y_out = adafruit_mcp4725.MCP4725(ext_i2c, address=0x63) # set up x-y scope output pins # x_out = AnalogOut(board.A0) # y_out = AnalogOut(board.A1) # dim the on-board neopixel and show yellow start-up indicator pixel = neo.NeoPixel(board.NEOPIXEL,1, brightness=0.01, auto_write=False) pixel[0] = (128, 128, 0) pixel.write() trellis_outline = [ # raw, absolute 12-bit data points (0, 0), (0, 41520), (21760, 41520),
Created on Fri Apr 30 02:05:15 2021 @author: Nat """ #python can be used to control a microcontoller's ouput voltage to a component using DAC. #This code is for an Arduino or Raspberry Pi microcontroller using CircuitPython and # the MCP4725 component, which has the circuit python library bundle for the MCP4725 import board import busio import adafruit_mcp4725 i2c = busio.I2C(board.SCL, board.SDA) # Initialize I2C bus. dac = adafruit_mcp4725.MCP4725(i2c) # Initialize MCP4725. # Create a DAC instance. #Using i2c #set the DAC output using: dac.raw_value = 4095 # The raw_value property to directly reads and writes # to the 12-bit DAC value. #takes an incoming peltier temperature value and converts it to the 12 bit DAC #value between # 0 (minimum/ground) to 4095 (maximum/Vout), which #corresponds to a Vout pin voltage between 0-3.3V. A heating range of 35 deg #is used here https://www.cuidevices.com/product/resource/cp18-m.pdf class microcontroller(): def __init__ (self): EffectorBase.__init__(self, "microcontroller") self.temp = 0 self.maxtemp = 35
import board import busio import adafruit_mcp4725 from time import sleep # Initialize I2C bus. i2c = busio.I2C(board.SCL, board.SDA) # Initialize MCP4725. dac = adafruit_mcp4725.MCP4725(i2c, address=0x60) # There are a three ways to set the DAC output, you can use any of these: dac.value = 65535 # Use the value property with a 16-bit number just like # the AnalogOut class. Note the MCP4725 is only a 12-bit # DAC so quantization errors will occur. The range of # values is 0 (minimum/ground) to 65535 (maximum/Vout). dac.raw_value = 4095 # Use the raw_value property to directly read and write # the 12-bit DAC value. The range of values is # 0 (minimum/ground) to 4095 (maximum/Vout). dac.normalized_value = 1.0 # Use the normalized_value property to set the # output with a floating point value in the range # 0 to 1.0 where 0 is minimum/ground and 1.0 is # maximum/Vout. # Main loop will go up and down through the range of DAC values forever. while True: dac.raw_value = 0
# Alternatively, there is a quick start command by using "~/gitFolder/startUpScript.sh" # Written by Valentine Lin and Eric Trollsaas, 2020 # Contact: [email protected], [email protected] import rospy from std_msgs.msg import String from sensor_msgs.msg import LaserScan import time import adafruit_mcp4725 import math import board import busio i2c = busio.I2C(board.SCL, board.SDA) dac1 = adafruit_mcp4725.MCP4725(i2c, address=0x60) dac2 = adafruit_mcp4725.MCP4725(i2c, address=0x61) brakeDistance = 0.5 stairDistance = 10 #Currently effectively unused, but may be useful for stair avoidance breakVoltage = 0.4 #This can be given as any value between 0 and 1, where 1 is full braking power and 0 is no power. def turn(direction): print("Turning " + direction) if direction == "left": dac1.normalized_value = breakVoltage dac2.normalized_value = 0 elif direction == "right": dac1.normalized_value = 0 dac2.normalized_value = breakVoltage
centerY = 2.3458 # #EXPANDED #centerY = 2.956; #centerX = 2.53; voltageToPositionX = 4.12 # mm/V voltageToPositionY = 3.52 # mm/V laserSpotRadius = 0.949 #mm unexpanded i2c = busio.I2C(board.SCL, board.SDA) dac = adafruit_mcp4725.MCP4725(i2c, address=0x62) dacY = adafruit_mcp4725.MCP4725(i2c, address=0x63) x = 0 try: if mode == 1: # Goes from 0,0 to a point (x,y) in one move, then waits, then moves back #1) generate list of points (this will change depending on what we want to do) #xlist #xlist=[lev(centerX-0.50),lev(centerX-0.25),lev(centerX),lev(centerX+0.25),lev(centerX+0.50)] xlist = [] for b in range(-4, 5): xlist.append(lev(centerX + b / 2.0)) print((centerX + b / 2.0)) #ylist
if __name__ == "__main__": # I2C and ADC Setup i2c_interface = busio.I2C(board.SCL, board.SDA) # First I2C bus is normal RasPi I2C pins # i2c_adc = busio.I2C(board.SCL, board.SDA) # Second I2C bus is set to: SCL GPIO17, SDA GPIO27 # i2c_dac_steering = busio.I2C(board.D17, board.D27) # Setup Steering Angle ADC # adc = ADC.ADS1115(i2c_interface, address=72) # adc_input = AnalogIn(adc, ADC.P0) # Setup Steering Angle DAC dac_output = DAC.MCP4725(i2c_interface, address=97) output_voltage = 0. direction = True add = 0.1 try: while True: dac_output.raw_value = round(output_voltage / 5 * 4095) if output_voltage >= 4.9 and direction: direction = not direction print(f"Voltage going down") add *= -1 if output_voltage <= 0.1 and not direction: direction = not direction print(f"Voltage going up") add *= -1 output_voltage += add
return np.minimum(10,(v1*10/3.3)) , np.minimum(10,(v2*10/3.3)) def dac_converter(u): #Definimos que 0 a 25 sera 0 a 1 #Pero la salida es de 0-3.3 es 0-4095 u_scalebin = np.divide((u*4095),(25*3.3)) u_scalevolt = np.divide(u,25) u_bin = np.int(np.maximum(0,np.minimum(4095,u_scalebin))) u_volt = np.maximum(0,np.minimum(1,u_scalevolt)) return u_volt, u_bin if __name__=="__main__": i2c = busio.I2C(board.SCL, board.SDA) ads = ADS.ADS1115(i2c, address = 0x48) dac = adafruit_mcp4725.MCP4725(i2c) #Create single-ended input on channel 0 chan1 = AnalogIn(ads, ADS.P0) chan2 = AnalogIn(ads, ADS.P1) chan3 = AnalogIn(ads, ADS.P2) dac.raw_value = 0 print('Inicializando, wait 10 seconds') time.sleep(10) start = time.time() while True: u = (chan1.voltage/3.3) u_volt, u_bin = dac_converter(25*u) dac.raw_value = u_bin
def __init__(self): self.i2c = busio.I2C(board.SCL, board.SDA) self.dac = adafruit_mcp4725.MCP4725(self.i2c) self.dac.value = 0