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
