def init(self, args):
global disp, image, image_hor, image_ver, draw
driver = args['driver']
interface = args['interface']
self.mode = '1'
self.bits = 1
if interface == 'I2C':
if driver == 'SSD1306_128_64':
disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST, i2c_bus=args['i2c_bus'], i2c_address=args['i2c_address'])
elif driver == 'SSD1306_128_32':
disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, i2c_bus=args['i2c_bus'], i2c_address=args['i2c_address'])
elif driver == 'ssd1309_128_64':
self.backend = 'luma.oled'
disp = ssd1309(i2c(port=args['i2c_bus'], address=args['i2c_address']))
#elif driver == 'ssd1322_256_64':
# self.backend = 'luma.oled'
# disp = ssd1322(i2c(port=args['i2c_bus'], address=args['i2c_address']))
#elif driver == 'ssd1325_128_64':
# self.backend = 'luma.oled'
# disp = ssd1325(i2c(port=args['i2c_bus'], address=args['i2c_address']))
elif driver == 'SSD1327_128_128':
self.backend = 'luma.oled'
self.mode = 'RGB'
self.bits = 8
disp = ssd1327(i2c(port=args['i2c_bus'], address=args['i2c_address']))
#elif driver == 'SSD1331_96_64': #
# self.backend = 'luma.oled'
# self.bits = 16
# disp = ssd1331(i2c(port=args['i2c_bus'], address=args['i2c_address']))
#elif driver == 'SSD1351_128_96': #
# self.backend = 'luma.oled'
# self.bits = 16
# disp = ssd1351(i2c(port=args['i2c_bus'], address=args['i2c_address']))
elif driver == 'SSH1106_128_64':
self.backend = 'luma.oled'
disp = ssh1106(i2c(port=args['i2c_bus'], address=args['i2c_address']))
elif interface == 'SPI':
if driver == 'SSD1306_128_64':
disp = Adafruit_SSD1306.SSD1306_128_64(rst=args['spi_rst_pin'], dc=args['spi_dc_pin'], spi=SPI.SpiDev(args['spi_port'], args['spi_device']), max_speed_hz=args['spi_hz'])
elif driver == 'SSD1306_128_32':
disp = Adafruit_SSD1306.SSD1306_128_32(rst=args['spi_rst_pin'], dc=args['spi_dc_pin'], spi=SPI.SpiDev(args['spi_port'], args['spi_device']), max_speed_hz=args['spi_hz'])
elif driver == 'ssd1309_128_64':
self.backend = 'luma.oled'
disp = ssd1309(spi(device=args['spi_device'], port=args['spi_port']))
elif driver == 'ssd1322_256_64':
self.backend = 'luma.oled'
disp = ssd1322(spi(device=args['spi_device'], port=args['spi_port']))
elif driver == 'ssd1325_128_64':
self.backend = 'luma.oled'
disp = ssd1325(spi(device=args['spi_device'], port=args['spi_port']))
elif driver == 'SSD1327_128_128':
self.backend = 'luma.oled'
self.mode = 'RGB'
self.bits = 8
disp = ssd1327(spi(device=args['spi_device'], port=args['spi_port']))
elif driver == 'SSD1331_96_64': #
self.backend = 'luma.oled'
self.bits = 16
disp = ssd1331(spi(device=args['spi_device'], port=args['spi_port']))
elif driver == 'SSD1351_128_96': #
self.backend = 'luma.oled'
self.bits = 16
disp = ssd1351(spi(device=args['spi_device'], port=args['spi_port']))
elif driver == 'SSH1106_128_64':
self.backend = 'luma.oled'
disp = ssh1106(spi(device=args['spi_device'], port=args['spi_port']))
self.maxValue = 1
if 'RGB' == self.mode:
self.maxValue = 255
if 'adafruit' == self.backend:
disp.begin()
self.rotate({})
width = self.getOutputWidth()
height = self.getOutputHeight()
#image_hor = Image.new('1', (width, height))
#image_ver = Image.new('1', (width, width))
image = Image.new(self.mode, (width, width))
images['default'] = image;
# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
#start()
"""f = open("out.txt", "a")
async def socketHandler(websocket, path):
pixelCount = PIXEL_COUNT
try:
while True:
cmdLine = await websocket.recv()
cmdList = cmdLine.split(" ")
command = cmdList.pop(0)
if DEBUG:
print("> Received command:", cmdLine)
# Process the command
if command == "init":
# Initialize the led strip.
if DEBUG:
print(">> Initializing WS2801 strip...")
pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT,
spi=SPI.SpiDev(
SPI_PORT,
SPI_DEVICE),
gpio=GPIO)
# Clear all the pixels to turn them off.
if DEBUG:
print(">> Clearing all", PIXEL_COUNT, "pixels...")
pixels.clear()
pixels.show(
) # Make sure to call show() after changing any pixels!
# By default, we will automatically show what was sent. This can be overridden with the autoshow command.
autoShow = True
# The init command replies with the number of pixels on the strip.
await websocket.send(str(pixels.count()))
elif command == "clear":
if DEBUG:
print(">> Handling clear command")
pixels.clear()
if autoShow:
pixels.show()
elif command == "setpixel":
if DEBUG:
print(">> Handling setpixel command")
pix = int(cmdList.pop(0))
red = int(cmdList.pop(0))
green = int(cmdList.pop(0))
blue = int(cmdList.pop(0))
if pixelCount < PIXEL_COUNT:
# Handle virtual split into multiple strips
while pix < PIXEL_COUNT:
if COLOR_ORDER == "RGB":
pixels.set_pixel_rgb(pix, red, green, blue)
else:
pixels.set_pixel_rgb(pix, red, blue, green)
pix = pix + pixelCount
else:
if COLOR_ORDER == "RGB":
pixels.set_pixel_rgb(pix, red, green, blue)
else:
pixels.set_pixel_rgb(pix, red, blue, green)
if autoShow:
pixels.show()
elif command == "setpixels":
if DEBUG:
print(">> Handling setpixels command")
red = int(cmdList.pop(0))
green = int(cmdList.pop(0))
blue = int(cmdList.pop(0))
if COLOR_ORDER == "RGB":
color = Adafruit_WS2801.RGB_to_color(red, green, blue)
else:
color = Adafruit_WS2801.RGB_to_color(red, blue, green)
pixels.set_pixels(color)
if autoShow:
pixels.show()
elif command == "shift":
if DEBUG:
print(">> Handling shift command")
direction = cmdList.pop(0)
if direction == "left":
if DEBUG:
print(">> Shifting left...")
leftmostPixelColor = pixels.get_pixel(0)
if pixelCount < PIXEL_COUNT:
if DEBUG:
print(">>Handling virtual pixels for", pixelCount,
"virtual pixels over", PIXEL_COUNT,
"real pixels")
nrIterations = PIXEL_COUNT // pixelCount
for i in range(0, nrIterations):
for pix in range(1, pixelCount):
color = pixels.get_pixel(i * pixelCount + pix)
pixels.set_pixel(i * pixelCount + pix - 1,
color)
pixels.set_pixel((i + 1) * pixelCount - 1,
leftmostPixelColor)
if PIXEL_COUNT % pixelCount > 0:
i = 0
for pix in range(nrIterations * pixelCount,
PIXEL_COUNT):
color = pixels.get_pixel(i)
pixels.set_pixel(pix, color)
i = i + 1
else:
for pix in range(1, pixels.count()):
color = pixels.get_pixel(pix)
pixels.set_pixel(pix - 1, color)
pixels.set_pixel(pixels.count() - 1,
leftmostPixelColor)
if autoShow:
pixels.show()
elif direction == "right":
if DEBUG:
print(">> Shifting right...")
rightmostPixelColor = pixels.get_pixel(pixelCount - 1)
if pixelCount < PIXEL_COUNT:
if DEBUG:
print(">>Handling virtual pixels for", pixelCount,
"virtual pixels over", PIXEL_COUNT,
"real pixels")
nrIterations = PIXEL_COUNT // pixelCount
if PIXEL_COUNT % pixelCount > 0:
for pix in reversed(
range(nrIterations * pixelCount,
PIXEL_COUNT)):
color = pixels.get_pixel(pix - 1)
pixels.set_pixel(pix, color)
for i in range(0, nrIterations):
for pix in reversed(range(1, pixelCount)):
color = pixels.get_pixel(i * pixelCount + pix -
1)
pixels.set_pixel(i * pixelCount + pix, color)
pixels.set_pixel(i * pixelCount,
rightmostPixelColor)
else:
for pix in reversed(range(1, pixels.count())):
color = pixels.get_pixel(pix - 1)
pixels.set_pixel(pix, color)
pixels.set_pixel(0, rightmostPixelColor)
if autoShow:
pixels.show()
else:
print(">> Unknown shift direction:", direction)
elif command == "dim":
if DEBUG:
print(">> Handling dim command")
step = int(cmdList.pop(0))
for i in range(pixels.count()):
red, green, blue = pixels.get_pixel_rgb(i)
red = int(max(0, red - step))
green = int(max(0, green - step))
blue = int(max(0, blue - step))
pixels.set_pixel(
i, Adafruit_WS2801.RGB_to_color(red, green, blue))
if autoShow:
pixels.show()
elif command == "autoshow":
if DEBUG:
print(">> Handling autoshow command")
state = cmdList.pop(0)
if state == "on":
autoShow = True
elif state == "off":
autoShow = False
else:
print(">> Unknown state for autoshow:", state)
elif command == "show":
if DEBUG:
print(">> Handling show command")
pixels.show()
elif command == "getpixelcount":
if DEBUG:
print(">> Handling getpixelcount command")
print(">> Returning pixel count", pixels.count())
await websocket.send(str(pixels.count()))
elif command == "setVirtualPixels":
if DEBUG:
print(">> Handling setVirtualPixels")
nrPixels = int(cmdList.pop(0))
pixelCount = nrPixels
else:
print(">> Unknown command:", command)
except websockets.exceptions.ConnectionClosed:
if DEBUG:
print("> Disconnected.")
except:
print("> Unknown exception encountered.")
raise
CURRENT_PITFT = PITFT_2_8 # Raspberry Pi configuration. DC = CURRENT_PITFT RST = 23 SPI_PORT = 0 SPI_DEVICE = 0 # BeagleBone Black configuration. # DC = 'P9_15' # RST = 'P9_12' # SPI_PORT = 1 # SPI_DEVICE = 0 # Create TFT LCD display class. disp = TFT.ILI9341(DC, rst=RST, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=64000000)) # Initialize display. disp.begin() # Clear the display to a red background. # Can pass any tuple of red, green, blue values (from 0 to 255 each). disp.clear((255, 0, 0)) # Alternatively can clear to a black screen by calling: # disp.clear() # Get a PIL Draw object to start drawing on the display buffer. draw = disp.draw() # Draw some shapes.
WIDTH = 128
HEIGHT = 128
SPEED_HZ = 8000000
# Raspberry Pi configuration.
DC = 24
RST = 25
SPI_PORT = 0
SPI_DEVICE = 0
# BeagleBone Black configuration.
#DC = 'P9_15'
#RST = 'P9_12'
#SPI_PORT = 1
#SPI_DEVICE = 0
# Create TFT LCD display class.
disp = TFT.ST7735(DC,
rst=RST,
spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=SPEED_HZ))
# Initialize display.
disp.begin()
# Load an image.
image = Image.open('test.png')
#display image
disp.display(image)
MQTT_SERVER = "192.168.43.130" #for Litty
#MQTT_SERVER = "192.168.0.135" #for Naruto
listen_path = "topic/serene"
send_path = "topic/init_loc"
MY_ID = ""
LAST_WILL = ""
INITIALIZED = False
MY_CURRENT_LIGHTING = ""
# Configure the count of pixels:
PIXEL_COUNT = 8
# Alternatively specify a hardware SPI connection on /dev/spidev0.0:
SPI_PORT = 0
SPI_DEVICE = 0
pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE), gpio=GPIO)
def on_connect(client, userdata, flags, rc):
print("Connected: result code " + str(rc))
client.subscribe(listen_path)
def on_message(client, userdata, msg):
statement = msg.payload
print("RPi received")
print(msg.topic + " " + str(statement))
# Get IMU reading
tiltHeading = Compass.readCompass(Compass.IMU)
tiltHeading = Compass.readCompass(Compass.IMU)
tiltHeading = Compass.readCompass(Compass.IMU)
tiltHeading = Compass.readCompass(Compass.IMU)
tiltHeading = Compass.readCompass(Compass.IMU)
def test_write_assert_deassert_ss_false(self):
gpio = MockGPIO()
device = SPI.BitBang(gpio, 1, 2, 3, 4)
device.write([0x1F], assert_ss=False, deassert_ss=False)
self.assertListEqual(gpio.pin_written[4], [1])
def test_invalid_bit_order_fails(self):
gpio = MockGPIO()
device = SPI.BitBang(gpio, 1, 2, 3, 4)
self.assertRaises(ValueError, device.set_bit_order, -1)
self.assertRaises(ValueError, device.set_bit_order, 2)
def read(MCP3008,pin_num):
values = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(0,0)).read_adc(pin_num)
return values
def setup():
global mcp
mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
def __init__(self):
# Initialisation de l'interface
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
SPI_PORT = 0
SPI_DEVICE = 0
self.mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
# Définition des paramètres
self.margin = None
# Création des dictionnaires des types et sous types de capteurs et actionneurs
self.sensorDict = {"Position": ["Sélection 1", "Sélection 2", "Engagement 1", "Engagement 2", "Embrayage 1", "Embrayage 2"],
"Pression": ["Robot"],
"Vitesse": ["Boîte de vitesses"]}
self.actuatorDict = {"Electrovanne": ["Sélection +", "Sélection -", "Engagement +", "Engagement -", "Embrayage +"],
"Moteur_électrique": ["Sélection +", "Sélection -", "Engagement +", "Engagement -", "Embrayage +"],
"Electro_pompe": ["Robot"]}
self.pinDict = {"Position Sélection 1": ('A', 0), "Position Sélection 2": ('A', 1),
"Position Engagement 1": ('A', 2), "Position Engagement 2": ('A', 3),
"Position Embrayage 1": ('A', 4), "Position Embrayage 2": ('A', 5),
"Pression Robot": ('A', 6),
"Vitesse Boîte de vitesses": ('A', 7),
"Electrovanne Sélection +": ('D', 17), "Electrovanne Sélection -": ('D', 4),
"Electrovanne Engagement +": ('D', 5), "Electrovanne Engagement -": ('D', 27),
"Electrovanne Embrayage +": ('D', 22),
"Moteur_électrique Sélection +": ('D', 17), "Moteur_électrique Sélection -": ('D', 4),
"Moteur_électrique Engagement +": ('D', 5), "Moteur_électrique Engagement -": ('D', 27),
"Moteur_électrique Embrayage +": ('D', 22),
"Electro_pompe Robot": ('D', 13)}
self.pinMotor = 26
# Création de la liste des types
self.sensorList = []
for key in self.sensorDict:
self.sensorList.append(key)
self.actuatorList = []
for key in self.actuatorDict:
self.actuatorList.append(key)
# Création du dictionnaire des classes de capteurs
self.sensorClass = {}
for category in self.sensorDict:
self.sensorClass[category] = {}
for subCategory in self.sensorDict[category]:
self.sensorClass[category][subCategory] = Sensor(category, subCategory, self.pinDict[category+" "+subCategory], self)
self.actuatorClass = {}
for category in self.actuatorDict:
self.actuatorClass[category] = {}
for subCategory in self.actuatorDict[category]:
self.actuatorClass[category][subCategory] = Actuator(category, subCategory, self.pinDict[category+" "+subCategory], self)
# Création du dictionnaire de valeurs capteur
self.sensorValue= {}
for category in self.sensorDict:
for subCategory in self.sensorDict[category]:
self.sensorValue[category + ' ' + subCategory] = 0
self.GPIOReset()
_thread.start_new_thread(self.SensorThread, ())
_thread.start_new_thread(self.SpeedSensorThread, ())
def __init__(self): #analog read is controlled by SPI hardware interface
self.SPI_PORT = 0
self.SPI_DEVICE = 0
self.meas = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(0, 0))
import Adafruit_GPIO.SPI as SPI
import Adafruit_SSD1306
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
# Pins for the HC-SR04 sensor
iTriggerPin = 21
iEchoPin = 20
# Pins 23 and 24 are connected to the OLED display
disp = Adafruit_SSD1306.SSD1306_128_64(rst=24,
dc=23,
spi=SPI.SpiDev(0,
0,
max_speed_hz=8000000))
GPIO.setup(iTriggerPin, GPIO.OUT)
GPIO.setup(iEchoPin, GPIO.IN)
GPIO.output(iTriggerPin, False)
time.sleep(0.5)
disp.begin()
font = ImageFont.truetype('NovaMono.ttf', 26)
while True:
GPIO.output(iTriggerPin, True)
time.sleep(0.0001)
GPIO.output(iTriggerPin, False)
import time, sys
import Image
import ImageDraw
import ImageFont
import Adafruit_ILI9341 as TFT
import Adafruit_GPIO.SPI as SPI
#
# provide quoted strings for title and message.
# limit title to: 20 chars
# limit message to 30 chars
TEXT_TITLE = str(sys.argv[1])
TEXT_MSG = str(sys.argv[2])
disp = TFT.ILI9341(24, rst=25, spi=SPI.SpiDev(0,0,max_speed_hz=64000000))
disp.begin()
disp.clear()
image = disp.buffer
fill = (255,255,255)
angle = 90
font = ImageFont.truetype("/usr/share/fonts/truetype/freefont/FreeSans.ttf", 30)
draw = ImageDraw.Draw(image)
t_width, t_height = draw.textsize(TEXT_TITLE, font=font)
textimage = Image.new('RGBA', (t_width, t_height), (0,0,0,0))
textdraw = ImageDraw.Draw(textimage)
textdraw.text((0,0), TEXT_TITLE, font=font, fill=fill)
rotated = textimage.rotate(angle, expand=1)
x_pos = 280
import Adafruit_GPIO.SPI as SPI
import Adafruit_MCP3008
# Software SPI configuration:
# CLK = 18
# MISO = 23
# MOSI = 24
# CS = 25
# mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)
# Hardware SPI configuration:
SPI_PORT = 0
SPI_DEVICE0 = 0 # 0
SPI_DEVICE1 = 1 # 0
mcp1 = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE0))
mcp2 = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE1))
print('Reading MCP3008 values, press Ctrl-C to quit...')
# Print nice channel column headers.
print(
'| {0:>4} | {1:>4} | {2:>4} | {3:>4} | {4:>4} | {5:>4} | {6:>4} | {7:>4} |'
.format(*range(8)))
print('-' * 57)
# Main program loop.
while True:
# Read all the ADC channel values in a list.
values = [0] * 16
for i in range(8):
# The read_adc function will get the value of the specified channel (0-7).
values[i] = mcp1.read_adc(i)
def test_read_assert_deassert_ss_false(self):
gpio = MockGPIO()
device = SPI.BitBang(gpio, 1, 2, 3, 4)
gpio.pin_read[3] = [0, 0, 0, 1, 1, 1, 1, 1]
result = device.read(1, assert_ss=False, deassert_ss=False)
self.assertListEqual(gpio.pin_written[4], [1])
import json
import logging
import time
import math
import RPi.GPIO as GPIO
import Adafruit_DHT
import Adafruit_GPIO.SPI as SPI
import Adafruit_MCP3008
from w1thermsensor import W1ThermSensor
from hx711 import HX711
logger = logging.getLogger("api_beez")
mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(0, 0))
class MyPi(object):
# 'magic method' propre à toutes les classes (ca commence et finit par '__').
# En l'occurence init prend des parametres et permet de les relier à l'instance via self
def __init__(self):
self.config = json.load(open("config_settings.json", "r"))
self.sensors = self.sensor_matches(self.config['raspberry']['sensors'])
# Décorateur qui permet de faire des méthodes classe et non d'instance
@classmethod
def sensor_matches(cls, sensor_config):
matches = {
"DS18B20": {
"mesure": "temperature",
"class": DS18B20Sensor
},
def test_ss_set_high_after_initialization(self):
gpio = MockGPIO()
device = SPI.BitBang(gpio, 1, 2, 3, 4)
self.assertListEqual(gpio.pin_written[4], [1])
class MQ():
CLK = 23
MISO = 21
MOSI = 19
CS = 24
mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)
SPI_PORT = 0
SPI_DEVICE = 0
mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
MQ_PIN = 0
RL_VALUE = 10
RO_CLEAN_AIR_FACTOR = float(4.4)
CALIBARAION_SAMPLE_TIMES = 50
CALIBRATION_SAMPLE_INTERVAL = 50
READ_SAMPLE_INTERVAL = 50
READ_SAMPLE_TIMES = 5
GAS_CH4 = 0
def _init_(self, Ro=10, analogPin=0):
self.Ro = Ro
self.MQ_PIN = analogPin
self.CH4Curve = [2.3, 0.26, -0.36]
print("Calibrating...")
self.Ro = self.MQCalibration(self.MQ_PIN)
print("Calibration is done...\n")
print("Ro=%f kohm" % self.Ro)
def MQPercentage(self):
val = {}
read = self.MQRead(self.MQ_PIN)
val["GAS_CH4"] = self.MQGetGasPercentage(read / self.Ro, self.GAS_CH4)
return val
def MQResistanceCalculation(self, raw_adc):
return float(self.RL_VALUE * (1023.0 - raw_adc) / float(raw_adc))
def MQCalibration(self, MQ_PIN):
val = 0.0
for i in range(self.CALIBARAION_SAMPLE_TIMES):
val += self.MQResistanceCalculation(self.mcp.read_adc(MQ_PIN))
time.sleep(self.CALIBRATION_SAMPLE_INTERVAL / 1000.0)
val = val / self.CALIBARAION_SAMPLE_TIMES
val = val / self.RO_CLEAN_AIR_FACTOR
return val
def MQRead(self, MQ_PIN):
rs = 0.0
for i in range(self.READ_SAMPLE_TIMES):
rs += self.MQResistanceCalculation(self.mcp.read_adc(MQ_PIN))
time.sleep(self.READ_SAMPLE_INTERVAL / 1000.0)
rs = rs / self.READ_SAMPLE_TIMES
return rs
def MQGetGasPercentage(self, rs_ro_ratio, gas_id):
if (gas_id == self.GAS_CH4):
return self.MQGetPercentage(rs_ro_ratio, self.CH4Curve)
def MQGetPercentage(self, rs_ro_ratio, pcurve):
return (math.pow(
10,
(((math.log10(rs_ro_ratio) - pcurve[1]) / pcurve[2]) + pcurve[0])))
def test_write_lsbfirst(self):
gpio = MockGPIO()
device = SPI.BitBang(gpio, 1, 2, 3, 4)
device.set_bit_order(SPI.LSBFIRST)
device.write([0x1F])
self.assertListEqual(gpio.pin_written[2], [1, 1, 1, 1, 1, 0, 0, 0])
def __init__(self):
self.mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(0, 0))
import Adafruit_GPIO.SPI as SPI
from AD56x8 import AD56x8
DAC_CH = [
'DAC_A', 'DAC_B', 'DAC_C', 'DAC_D', 'DAC_E', 'DAC_F', 'DAC_G', 'DAC_H'
]
# BeagleBone Black hardware SPI configuration.
SPI_PORT = 1
SPI_DEVICE = 0
dac = AD56x8.AD56x8('AD5628-1', spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
dac.reset()
dac.internal_ref_mode('ON')
# Configure all channels for SW LDAC
for ch in DAC_CH:
dac.LDAC_mode('SW', ch)
counter = 0
while True:
for ch in DAC_CH:
dac.write_to_Input_Reg(ch, counter)
dac.update_DAC_Reg(ch)
voltage = 2 * (dac.VREF) * (counter / (2**dac.DATA_WIDTH))
counter = (counter + 1) % ((2**dac.DATA_WIDTH) - 1)
print("DAC Voltage:", round(voltage, 3))
#Define a function to convert Celsius to Fahrenheit.
def c_to_f(c):
return c * 9.0 / 5.0 + 32.0
#Function for reading the thermocouple temperature
def readTemp():
temp = sensor.readTempC()
internal = sensor.readInternalC()
return temp
# Raspberry Pi hardware SPI configuration.
SPI_PORT = 0
SPI_DEVICE = 0
sensor = MAX31855.MAX31855(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
#Setting up GPIO pins
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
#pin for activating pump relay currently set to 17 but may need to be changed later
GPIO.setup(26, GPIO.OUT)
#pin for activating solenoid valve
GPIO.setup(12, GPIO.OUT)
#---------USER DEFINED VARIABLES FROM THE UI ARE DECLARED HERE----------------------------------------------
#after some searching, the way python reads variables from C# is with sys.argv[]
#in this program, I am assuming sys.argv[1] is the destination temperature and sys.argv[2] is a boolean for isF
#In the C# front end, make sure to order the argv[] variables in the same way when you call the function
#variable to keep track of whether the user entered in Fahrenheit
DC = 23
RST = 24
SPI_PORT = 0
SPI_DEVICE = 0
# Raspberry Pi software SPI config:
# SCLK = 4
# DIN = 17
# DC = 23
# RST = 24
# CS = 8
# Hardware SPI usage:
disp = LCD.PCD8544(DC,
RST,
spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=4000000))
# Software SPI usage (defaults to bit-bang SPI interface):
#disp = LCD.PCD8544(DC, RST, SCLK, DIN, CS)
# Initialize library.
disp.begin(contrast=60)
# Clear display.
disp.clear()
disp.display()
# Create blank image for drawing.
# Make sure to create image with mode '1' for 1-bit color.
image = Image.new('1', (LCD.LCDWIDTH, LCD.LCDHEIGHT))
import Adafruit_SSD1306
from PIL import Image, ImageFont, ImageDraw
import StringIO
import pygame
import zipfile
import os, sys
# Ports used for fthe Display. You may have to change them to yours
RST = 25
DC = 24
SPI_PORT = 0
SPI_DEVICE = 0
# 128x64 display with hardware SPI:
disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=16000000))
# Initialize library.
disp.begin()
# Clear display.
disp.clear()
disp.display()
# Get display width and height.
width = disp.width
height = disp.height
# Create image buffer.
# Make sure to create image with mode '1' for 1-bit color.
image = Image.new('1', (width, height))
#Jason Millette
#11/23/18
#uses information from the website to display
#then create an 128x128 image for display on an SPI device
import requests
import Image
import ImageDraw
import sys
import ST7735 as TFT
import Adafruit_GPIO.SPI as SPI
#Getting weather data
#Creating weather image for SPI display
image = Image.new('RGB', (128,128), (0, 0, 255)) #RGB, size, color
draw = ImageDraw.Draw(image) #creates image
draw.text((10,9), sys.argv[1], fill=(0, 0, 0))#(x,y), text, (R, G, B)
#draw.text((35, 18), 'sys.argv[2]', fill=(0, 0, 0))
#displaying images to spi devices
DC = 24
RST = 25
#Displaying website data
display2 = TFT.ST7735(DC, rst=RST, spi=SPI.SpiDev(0, 1, max_speed_hz=8000000)) # display initalized in initDisplay.py
display2.display(image) #displays image
from PIL import ImageDraw
from PIL import ImageFont
import json
import requests
import _thread
# -- Setup Pi GPIO Numbers --
GPIO.setmode(GPIO.BCM)
# -- Setup Nokia 5110 LCD SPI Config --
DC = 5 # data/control (GPIO5 pin29)
RST = 6 # reset (GPIO6 pin31)
SPI_PORT = 0 # SPI port 0
SPI_DEVICE = 1 # CS1 (GPIO7 pin26)
# Hardware SPI usage:
disp = LCD.PCD8544(DC, RST, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=4000000))
image = Image.new('1', (LCD.LCDWIDTH, LCD.LCDHEIGHT))
# -- Setup ADC SPI --
spi = spidev.SpiDev() # create spi object
spi.open(0, 0) # SPI port 0, device CS0 (GPIO8 pin24)
spi.max_speed_hz = (1000000)
# -- Setup Nokia 5110 LCD Settings --
# Initialize library
disp.begin(contrast=50)
# Clear display
disp.clear()
disp.display()
# Load default font
font = ImageFont.load_default()
import Adafruit_GPIO.SPI as SPI import Adafruit_MCP3008 import RPi.GPIO as GPIO import spidev # Software SPI configuration: #CLK = 18 #MISO = 23 #MOSI = 24 #CS = 25 #mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI) # Hardware SPI configuration: SPI_PORT = 0 SPI_DEVICE = 0 mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE)) # Choose channel an_chan = 1 # channel 8 (numbered 0-7) # choose GPIO pin ledPin = 18 GPIO.setmode(GPIO.BCM) GPIO.setup(ledPin, GPIO.OUT) samplingTime = 280.0 deltaTime = 40.0 sleepTime = 9680.0 # Main program loop.
def __init__(self):
"""
Initialize the MCP3008 hardware interface used by this class
"""
self.mcp = MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
# Simple demo of of the WS2801/SPI-like addressable RGB LED lights.
import time
import RPi.GPIO as GPIO
# Import the WS2801 module.
import Adafruit_WS2801
import Adafruit_GPIO.SPI as SPI
# Configure the count of pixels:
PIXEL_COUNT = 9
# Alternatively specify a hardware SPI connection on /dev/spidev0.0:
SPI_PORT = 0
SPI_DEVICE = 0
pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT,
spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE),
gpio=GPIO)
# Define the wheel function to interpolate between different hues.
def wheel(pos):
if pos < 85:
return Adafruit_WS2801.RGB_to_color(pos * 3, 255 - pos * 3, 0)
elif pos < 170:
pos -= 85
return Adafruit_WS2801.RGB_to_color(255 - pos * 3, 0, pos * 3)
else:
pos -= 170
return Adafruit_WS2801.RGB_to_color(0, pos * 3, 255 - pos * 3)
def collect_data(interval, runtime, pin_num, filename):
'''
params
interval in seconds can be an int or float
runtime how long you want to collect data (if runtime = -1 it will continue until you C-c out)
data will only be collected if interval < runtime, interval > 0, and runtime != -1
ret
data is interval at idx 0 then collected data is at data[1:]
if data is not collected retruns -1
'''
# We can either use Software SPI or Hardware SPI. For software SPI we will
# use regular GPIO pins. Hardware SPI uses the SPI pins on the Raspberry PI
# Set the following variable to either HW or SW for Hardware SPI and Software
# SPI respectivly.
# PIN IS 6 AS A PARAMETER
SPI_TYPE = 'HW'
# dly = .5 # Delay of 1000ms (1 second) original
dly = .5 * interval
# Software SPI Configuration
CLK = 18 # Set the Serial Clock pin
MISO = 23 # Set the Master Input/Slave Output pin
MOSI = 24 # Set the Master Output/Slave Input pin
CS = 25 # Set the Slave Select
# Hardware SPI Configuration
HW_SPI_PORT = 0 # Set the SPI Port. Raspi has two.
HW_SPI_DEV = 0 # Set the SPI Device
# Instantiate the mcp class from Adafruit_MCP3008 module and set it to 'mcp'.
if (SPI_TYPE == 'HW'):
# Use this for Hardware SPI
mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(HW_SPI_PORT, HW_SPI_DEV))
elif (SPI_TYPE == 'SW'):
# Use this for Software SPI
mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)
analogPort = pin_num
print('Reading MCP3008 values on pin: %d' % analogPort)
data = [interval]
try:
if runtime == -1:
while True:
# Read the value from the MCP3008 on the pin we specified in analogPort
val = mcp.read_adc(analogPort)
# print out the value
print(val)
# Sleep for dly
sleep(dly)
else:
t = 0
i = 0
while t < runtime:
# Read the value from the MCP3008 on the pin we specified in analogPort
val = mcp.read_adc(analogPort)
# print out the value
print(val)
data.append(val)
os.system("fswebcam " + filename + str(i) + ".jpg")
# Sleep for dly
sleep(dly)
t += interval
i += 1
except KeyboardInterrupt:
sys.exit()
return data
