def setup(): global chan_temp global chan_LDR # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object mcp = MCP.MCP3008(spi, cs) # Create an analog input channel on pin 0 and 1 chan_temp = AnalogIn(mcp, MCP.P1) chan_LDR = AnalogIn(mcp, MCP.P0) # Setup buttons for interupt and input GPIO.setup(btn_delay, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(btn_delay, GPIO.FALLING, callback=btn_delay_callback, bouncetime=250) GPIO.setup(btn_measure, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(btn_measure, GPIO.FALLING, callback=btn_measure_callback, bouncetime=250)
def __init__(self, CLOCK=board.SCK, MISO=board.MISO, MOSI=board.MOSI, DATA=board.D5): self.available_channels = list(range(0, 8)) self.allocated_channels = [] if type(CLOCK) is str: CLOCK = resolve_pin(CLOCK) if type(MISO) is str: MISO = resolve_pin(MISO) if type(MOSI) is str: MOSI = resolve_pin(MOSI) if type(DATA) is str: DATA = resolve_pin(DATA) # create the spi bus self.spi = busio.SPI(clock=CLOCK, MISO=MISO, MOSI=MOSI) # create the cs (chip select) self.cs = digitalio.DigitalInOut(DATA) # create the mcp object self.mcp = MCP.MCP3008(self.spi, self.cs)
def __init__(self, numOfChannels, vref, noiseThreshold=350, maxInterval=1, cs=8): ''' Create spi connection and initialize lists ''' self.vref = vref logging.info("MCP3008 using SPI SCLK:GPIO{0} MISO:GPIO{1} MOSI:GPIO{2} CS:GPIO{3}".format(board.SCK, board.MISO, board.MOSI, cs)) spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the spi bus if cs == 8: cs = digitalio.DigitalInOut(board.D8) # create the cs (chip select). Use GPIO8 (CE0) or GPIO7 (CE1) elif cs == 7: cs = digitalio.DigitalInOut(board.D7) # create the cs (chip select). Use GPIO8 (CE0) or GPIO7 (CE1) else: logging.info("Chip Select pin must be 7 or 8") exit() mcp = MCP.MCP3008(spi, cs) # create the mcp object. Can pass Vref as last argument self.numOfChannels = numOfChannels self.chan = [AnalogIn(mcp, MCP.P0), # create analog input channel on pins AnalogIn(mcp, MCP.P1), AnalogIn(mcp, MCP.P2), AnalogIn(mcp, MCP.P3), AnalogIn(mcp, MCP.P4), AnalogIn(mcp, MCP.P5), AnalogIn(mcp, MCP.P6), AnalogIn(mcp, MCP.P7)] self.noiseThreshold = noiseThreshold self.numOfSamples = 10 # Number of samples to average self.maxInterval = maxInterval # interval in seconds to check for update self.time0 = time() # time 0 # Initialize lists self.sensorAve = [x for x in range(self.numOfChannels)] self.sensorLastRead = [x for x in range(self.numOfChannels)] self.adcValue = [x for x in range(self.numOfChannels)] self.sensor = [[x for x in range(0, self.numOfSamples)] for x in range(0, self.numOfChannels)] for x in range(self.numOfChannels): # initialize the first read for comparison later self.sensorLastRead[x] = self.chan[x].value
def getTemps(): # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.CE0) # create the mcp object mcp = MCP.MCP3008(spi, cs) channels = [MCP.P0, MCP.P1, MCP.P2] temps = [] for channel in channels: # create an analog input channel on pin 0 chan = AnalogIn(mcp, channel) value = chan.value if DEBUG: print('Value: {0} Voltage: {1}'.format(value, chan.voltage)) if value != 0: temp = temp_calc(chan.voltage) temps.append(float(temp)) if DEBUG: print("value: {0} {1} {2}".format(value, temp, channel)) #log temperature of 0 if sensor is not connected if value == 0: temps.append(float(value)) if DEBUG: print("value: {0} {1}".format(value, channel)) return temps
def main(): """ Print the water level and temperature every second :return: """ # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D22) # create the mcp object mcp = MCP.MCP3008(spi, cs) # create an analog input channel on pin 0 water_level_sensor = AnalogIn(mcp, MCP.P0) # create temperature sensor temp_sensor = W1ThermSensor() while True: temperature = temp_sensor.get_temperature() print(f"The temperature is {temperature} C, {celsius_to_fahrenheit(temperature)} F") print(f"ADC Voltage: {round(water_level_sensor.voltage, 2)}V") print(f"Water Level: {get_water_level_inches(water_level_sensor.voltage)} inches") print("\n") time.sleep(1)
def animate (i,xs,ys): import busio import digitalio import board import adafruit_mcp3xxx.mcp3008 as MCP from adafruit_mcp3xxx.analog_in import AnalogIn import time while True: spi = busio.SPI(clock=board.SCK_1, MISO=board.MISO_1, MOSI=board.MOSI_1) cs = digitalio.DigitalInOut(board.D5) mcp = MCP.MCP3008(spi, cs) chan = AnalogIn(mcp, MCP.P0) volt = print("Raw ADC Value: ", chan.value) xs.append(dt.datetime.now().strftime('%H:%M:%S')) ys.append(volt) ax.clear() ax.plot(xs,ys) plt.xticks(rotation=45, ha='right') plt.subplots_adjust(bottom=0.30) plt.title('BPM test') plt.ylabel('Voltage')
def __init__(self, n_channels=1, ref_voltage=3.3, threshold=.6, charger_off_callback=None, charger_on_callback=None): self.n_channels = n_channels self.ref_voltage = ref_voltage self.threshold = threshold self.charger_off_callback = charger_off_callback self.charger_on_callback = charger_on_callback # Init serial port self.spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # This pin doesn't seem to matter?!? self.cs = digitalio.DigitalInOut(board.D24) self.mcp = MCP.MCP3008(self.spi, self.cs, self.ref_voltage) self.channels = [ AnalogIn(self.mcp, getattr(MCP, 'P{}'.format(i))) for i in range(self.n_channels) ] # Init Thread self._read_thread = threading.Thread(target=self._read_charger_loop) self._read_thread_isalive = False self._charger_states = None
def main(argv): del argv # Setup up board spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) cs = digitalio.DigitalInOut(board.CE0) mcp = MCP.MCP3008(spi, cs) # Setup up metrics gauge = prom.Gauge("moisture_percent", "Moisture percentage", ["sensor_id"]) logging.info("Starting http server...") prom.start_http_server(8080) logging.info("Started http server on port 8080") meters = [] for pin, getter in id_getter.items(): id = getter() if id: logging.info("Measuring pin " + str(pin) + " with id " + id) meter = MoistureMeter(id, AnalogIn(mcp, pin), gauge) meters.append(meter) else: logging.info("Not measuring pin " + str(pin)) if not meters: logging.error("no pins are being measured") return while True: for m in meters: m.measure() logging.debug("Sleeping for " + str(FLAGS.poll_ms) + "ms") time.sleep(0.001 * FLAGS.poll_ms)
def voltage() -> float: """ Gets the analog voltage from pin 0 on the MCP3008 Arguments: None Returns: - The analog voltage """ try: # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object mcp = MCP.MCP3008(spi, cs) # create an analog input channel on pin 0 chan = AnalogIn(mcp, MCP.P0) return chan except: sys.exit(1)
def setup(): global chan_ldr global chan_temp # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object mcp = MCP.MCP3008(spi, cs) # create an analog input channel on pin 0 chan_ldr = AnalogIn(mcp, MCP.P0) chan_temp = AnalogIn(mcp, MCP.P1) # setup button GPIO.setup(btn, GPIO.IN) GPIO.setup(btn, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(btn, GPIO.FALLING, callback=btn_pressed, bouncetime=200)
def __init__(self, numOfChannels, vref, sampleInterval=1, noiseThreshold=350, numOfSamples=10): self.vref = vref spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the spi bus cs = digitalio.DigitalInOut(board.D22) # create the cs (chip select) mcp = MCP.MCP3008(spi, cs) # create the mcp object self.numOfChannels = numOfChannels self.chan = [ AnalogIn(mcp, MCP.P0), # create analog input channel on pins AnalogIn(mcp, MCP.P1), AnalogIn(mcp, MCP.P2), AnalogIn(mcp, MCP.P3), AnalogIn(mcp, MCP.P4), AnalogIn(mcp, MCP.P5), AnalogIn(mcp, MCP.P6), AnalogIn(mcp, MCP.P7) ] self.noiseThreshold = noiseThreshold self.sensorChanged = False self.numOfSamples = numOfSamples self.sensorAve = [x for x in range(self.numOfChannels)] self.sensorLastRead = [x for x in range(self.numOfChannels)] for x in range(self.numOfChannels ): # initialize the first read for comparison later self.sensorLastRead[x] = self.chan[x].value self.adcValue = [x for x in range(self.numOfChannels)] self.sensor = [[x for x in range(0, self.numOfSamples)] for x in range(0, self.numOfChannels)] self.sampleInterval = sampleInterval # interval in seconds to check for update self.time0 = time() # time 0
def __init__(self): Sensor.__init__(self) self.moisture_min = float(self.config["soil"]["min"]) self.moisture_max = float(self.config["soil"]["max"]) # create SPI bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D8) # create the mcp object mcp = MCP.MCP3008(spi, cs) # create an analog input channel self.pin = [] self.pin.append(AnalogIn(mcp, MCP.P0)) self.pin.append(AnalogIn(mcp, MCP.P1)) self.pin.append(AnalogIn(mcp, MCP.P2)) self.pin.append(AnalogIn(mcp, MCP.P3)) self.pin.append(AnalogIn(mcp, MCP.P4)) self.pin.append(AnalogIn(mcp, MCP.P5)) self.pin.append(AnalogIn(mcp, MCP.P6)) self.pin.append(AnalogIn(mcp, MCP.P7))
def __init__(self): spi = busio.SPI(clock=board.SCK_1, MISO=board.MISO_1, MOSI=board.MOSI_1) #ADCs use second SPI port of RPi cs = digitalio.DigitalInOut(board.D16) mcp = MCP.MCP3008(spi, cs) self.pi = pigpio.pi() self.NUM_NEOPIXELS = 118 self.pixels = neopixel.NeoPixel(board.D12, self.NUM_NEOPIXELS, auto_write=False) self.reservoir = Reservoir(self.pixels) self.windmills = Windmills(self.pi, mcp) self.solarPanels = SolarPanels(mcp) self.city = City(self.pixels) self.fuelCell = FuelCell(self.pixels, self.pi) self.distributionMiddle = DistributionLine(self.pixels, 101, 4) self.distributionRight = DistributionLine(self.pixels, 105, 5, True) self.transmissionLine = TransmissionLines(self.pixels) self.wattownSign = WattownSign(self.pixels) self.substation = Substation(self.pixels) self.stopEvent = threading.Event() self.stopEvent.clear() super().__init__()
def __init__(self): self.pinData = {} self.spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) self.cs = digitalio.DigitalInOut(board.D5) self.mcp = MCP.MCP3008(self.spi, self.cs) self.startDate = datetime.datetime(2020, 5, 14) self.mcpPins = { 'P0': MCP.P0, 'P1': MCP.P1, 'P2': MCP.P2, 'P3': MCP.P3, 'P4': MCP.P4, 'P5': MCP.P5, 'P6': MCP.P6, 'P7': MCP.P7, } self.boardPins = {'D18': board.D18} ########### ##Modules## ########### #W2LED self.pixels = None self.ledNum = None
def setup(): # the following variables must be global global spi, cs, mcp, chan # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object mcp = MCP.MCP3008(spi, cs) # create an analog input channel on pin 1 chan = AnalogIn(mcp, MCP.P1) # the button pin (in BCM mode) button_pin = 23 # setting GPIO 23 (BCM) as an input GPIO.setup(button_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) # adding a callback for when the button is clicked GPIO.add_event_detect(button_pin, GPIO.FALLING, callback=toggle_rate, bouncetime=300)
def setup(): global tof global tank_depth global minTemp global maxTemp # starting tof sensor in Long range which is up to 4m print("Sensors Used: ") tof.open() tof.start_ranging(3) # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object mcp = MCP.MCP3008(spi, cs) #bla bla # database setup create_connection() #insert_dummy_data() #config values, taken from a config file a_file = open("./Data/config.txt", "r") list_of_lines = a_file.readlines() list_of_lines = list_of_lines tank_depth = float(list_of_lines[0].rstrip()) minTemp = float(list_of_lines[1].rstrip()) maxTemp = float(list_of_lines[2]) a_file.close() pass
def setup(): # the following variables must be global global spi, cs, mcp, chan, buzzer #region Setup ADC # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object mcp = MCP.MCP3008(spi, cs) # create an analog input channel on pin 1 chan = AnalogIn(mcp, MCP.P1) #endregion Setup ADC # the pin to start/stop printing to the console start_stop_pin = 24 # this is pin 18 in BOARD MODE # setting GPIO 24 (BCM) as an input GPIO.setup(start_stop_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) #region Setup buzzer GPIO.setup(buzzer_pin, GPIO.OUT, initial=GPIO.LOW) # adding a callback for when the start/stop button is clicked GPIO.add_event_detect(start_stop_pin, GPIO.FALLING, callback=start_stop, bouncetime=300)
def Start(self, event): print("Starting sensor...") # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object mcp = MCP.MCP3008(spi, cs) # create an analog input channel on pin 0 channel = AnalogIn(mcp, MCP.P3) reading = Reading(value=channel.value, voltage=channel.voltage) self.new_reading_event.notify(reading.value, reading.voltage, reading.percentage) # SensorRepository.SaveReading(percentage=reading.percentage, value=reading.value, voltage=reading.voltage) while True: avg = [0] * 2 for x in range(50): avg[0] = avg[0] + channel.value avg[1] = avg[1] + channel.voltage time.sleep(0.5) # print('{} | {}'.format(x, str(channel.value))) avgValue = avg[0] / 50 avgVoltage = avg[1] / 50 reading = Reading(value=avgValue, voltage=avgVoltage) self.new_reading_event.notify(reading.value, reading.voltage, reading.percentage)
def query_hardware(): # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object mcp = MCP.MCP3008(spi, cs) # create analog channels for the LDR and potentiometer ldr = AnalogIn(mcp, MCP.P0) pot = AnalogIn(mcp, MCP.P1) last_ldr_val = 0.0 last_pot_val = 0.0 while True: # normalize cur_ldr_val = normalize_value(MIN_LDR_VAL, MAX_LDR_VAL, ldr.value) cur_pot_val = normalize_value(MIN_POT_VAL, MAX_POT_VAL, pot.value) # if either the LDR or potentiometer values are outside their thresholds if (beyond_threshold(last_ldr_val, cur_ldr_val, LDR_THRESHOLD) or beyond_threshold(last_pot_val, cur_pot_val, POT_THRESHOLD)): # publish current LDR and potentiometer values client.publish("lightSensor", payload=str(cur_ldr_val), qos=2, retain=True) client.publish("threshold", payload=str(cur_pot_val), qos=2, retain=True) # update values last_ldr_val = cur_ldr_val last_pot_val = cur_pot_val # wait 100 ms time.sleep(0.1)
def setup(): #ADC and Temp sensor setup global chan, start, start_stop, k GPIO.setmode(GPIO.BCM) # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object mcp = MCP.MCP3008(spi, cs); # create an analog input channel on pin 0 chan = AnalogIn(mcp, MCP.P0); # Setup Button GPIO.setup(button_stop_start,GPIO.IN,pull_up_down=GPIO.PUD_UP); # Setup debouncing and callbacks # GPIO.add_event_detect(button_stop_start,GPIO.FALLING,callback=btn_startstop,bouncetime=300); start=time.time(); start_stop=1; print("Time:\t\t\tRuntime\t\tTemperature:") #EEPROM setup # Setup PWM channels GPIO.setup(buzzer, GPIO.OUT) k=GPIO.PWM(buzzer,1000) k.start(0) # Setup debouncing and callbacks GPIO.add_event_detect(button_stop_start,GPIO.FALLING,callback=btn_startstop,bouncetime=300) return chan #object of analog input channel for ADC returned.
def setup(self, adc_channel, offset): super().setup(LogType.ARRAY) self.address = adc_channel self.offset = offset spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) mcp3008_a = mcp3008.MCP3008(spi, digitalio.DigitalInOut(board.D8)) self.bridge = AnalogIn(mcp3008_a, adc_channel)
def setup(self): """Sets up sensor configurations that should happen after loading from the database""" self.pin = board.D22 spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) cs = digitalio.DigitalInOut(self.pin) mcp = MCP.MCP3008(spi, cs) # create analog input channel on pin 0 self.channel = AnalogIn(mcp, MCP.P0)
def set_up_mcp_convertor(): """ Return an instance of the MCP analog-to-digital converter for reading the soil moisture probe """ spi_bus = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) chip_select = digitalio.DigitalInOut(board.D5) return MCP.MCP3008(spi_bus, chip_select)
def setupMcp(self): # create the spi bus spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) # create the cs (chip select) cs = digitalio.DigitalInOut(board.D5) # create the mcp object self.mcp = mcp3008.MCP3008(spi, cs)
def __init__(self, num_channels=3, sck=board.SCK, miso=board.MISO, mosi=board.MOSI, cs_pin=board.D5, serial_no=None, channels=None, *args, **kwargs): self.spi = busio.SPI(clock=sck, MISO=miso, MOSI=mosi) self.cs = digitalio.DigitalInOut(cs_pin) self.mcp = MCP.MCP3008(self.spi, self.cs) self.num_channels = num_channels self.type = __name__ super().__init__(serial_no, channels, *args, **kwargs)
def initialize_mcp(): global mcp_error try: spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) cs = digitalio.DigitalInOut(board.D5) return MCP.MCP3008(spi, cs) except Exception as error: print(error.args[0]) mcp_error = True
def _connect_to_hardware(self): import drivers.MCP3008.bbspi as bbspi import adafruit_mcp3xxx.mcp3008 as MCP self.MCP = MCP spi = bbspi.BBSpi( clock=self.clk, MISO=self.miso, MOSI=self.mosi, ) self.sensor = MCP.MCP3008(spi, self.cs)
def get_ocv_PV(self): spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) cs = digitalio.DigitalInOut(board.CE0) mcp = MCP.MCP3008(spi, cs) chan=AnalogIn(mcp, MCP.P0) time.sleep(1) raw = chan.voltage print('PV Raw volt read: ' + str(raw) + '[V]') # Since we divided voltage by 11, multiply by 11 to get actual Voc return raw * 11
def get_scc_PV(self): spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) cs = digitalio.DigitalInOut(board.CE0) mcp = MCP.MCP3008(spi, cs) chan=AnalogIn(mcp, MCP.P0) time.sleep(1) raw = chan.voltage print('PV Raw curr read: ' + str(raw) + '[A]') #SCC = Voc x 1 ohm return raw * 1
def listen(): spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) cs = digitalio.DigitalInOut(board.D6) mcp = MCP.MCP3008(spi, cs) chan = AnalogIn(mcp, MCP.P1) for _ in range(500): if (chan.voltage >= 1): return True return False