def PullData():
print("pull data")
spi = SPI(1, 0)
spi.msh = 100000
spi.bpw = 8
spi.writebytes([0x30])
sleep(0.1)
moistureVals = spi.readbytes(3)
moisture = str(moistureVals[0]) + str(moistureVals[1]) + str(moistureVals[2])
spi.writebytes([0x31])
sleep(0.1)
moistureVals1 = spi.readbytes(3)
moisture1 = str(moistureVals1[0]) + str(moistureVals1[1]) + str(moistureVals1[2])
spi.writebytes([0x35])
sleep(0.1)
lightVals = spi.readbytes(3)
light = str(lightVals[0]) + str(lightVals[1]) + str(lightVals[2])
Data = []
Data.append(moisture)
Data.append(moisture1)
Data.append(light)
spi.close()
return Data
def run(self):
#Only need to execute one of the following lines:
#spi = SPI(bus, device) #/dev/spidev<bus>.<device>
spi = SPI(0, 0) #/dev/spidev1.0
spi.msh = 2000000 # SPI clock set to 2000 kHz
spi.bpw = 8 # bits/word
spi.threewire = False
spi.lsbfirst = False
spi.mode = 1
spi.cshigh = False # chip select (active low)
spi.open(0, 0)
print("spi... msh=" + str(spi.msh))
gchannel = 0
buf0 = (7 << 3) | ((gchannel & 0x0f) >> 1) #(7<<3) for auto-2 mode
buf1 = (gchannel & 0x01) << 7
buf1 = buf1 | 0x40 #select 5v i/p range
while (self.running):
ret = spi.xfer2([buf0, buf1])
print("0x%x 0x%x" % (ret[0], ret[1]))
chanl = (ret[0] & 0xf0) >> 4
adcval = ((ret[0] & 0x0f) << 4) + ((ret[1] & 0xf0) >> 4)
print(" -> chanl=%d adcval=0x%x" % (chanl, adcval))
time.sleep(1)
def __init__(self, bus): # Use Adafruit_BBIO.SPI to initialize the cap # and the spi bus configuration s = SPI(bus, self.__DEVICE) s.msh = self.__SPEED s.mode = self.__MODE s.close() # Use normal file for writing bytes dev = '/dev/spidev%s.%s' % (bus + 1, self.__DEVICE) self.spi = open(dev, 'wb') print 'Opened %s, Freq: %sHz' % (dev, self.__SPEED)
def __init__(self, bus):
# Use Adafruit_BBIO.SPI to initialize the cap
# and the spi bus configuration
s = SPI(bus, self.__DEVICE)
s.msh = self.__SPEED
s.mode = self.__MODE
s.close()
# Use normal file for writing bytes
dev = '/dev/spidev%s.%s' % (bus + 1, self.__DEVICE)
self.spi = open(dev, 'wb')
print 'Opened %s, Freq: %sHz' % (dev, self.__SPEED)
def __init__(self, unix_socket_path, *args, **kwargs):
self.unix_socket_path = unix_socket_path
self.connection = None
self.welcome_socket = None
spi = SPI(0, 0)
spi.msh = 2000000
spi.mode = 1
self.chs = [0, 1, 2, 3]
self.ADC0 = ADC("P9_24", spi)
self.ADC1 = ADC("P9_26", spi)
self.ADC2 = ADC("P9_28", spi)
self.ADC3 = ADC("P9_30", spi)
def getLight():
#print("Reading Light Data")
spi = SPI(1, 0)
spi.msh = 100000
spi.bpw = 8
spi.writebytes([0x35])
sleep(0.01)
lightVals = spi.readbytes(3)
light = str(lightVals[0]) + str(lightVals[1]) + str(lightVals[2])
spi.close()
return light
def getMoist_ch1():
#print("Reading Moisture CH 1")
spi = SPI(1, 0)
spi.msh = 100000
spi.bpw = 8
spi.writebytes([0x31])
sleep(0.01)
moistureVals = spi.readbytes(3)
moisture = str(moistureVals[0]) + str(moistureVals[1]) + str(moistureVals[2])
spi.close()
return moisture
def Watering():
print("watering")
spi = SPI(1, 0)
spi.msh = 100000
spi.bpw = 8
list = []
i=0
while i<50:
spi.writebytes([0x31])
sleep(0.1)
list.append(spi.readbytes(3))
print(list.pop())
++i
sleep(0.5)
spi.close()
def stopWatering():
print("Stopping watering")
session['watering_command_status'] = "OFF"
# send the signal to arduino to stop watering
spi = SPI(1, 0)
spi.msh = 100000
spi.bpw = 8
# send the appropriate signal
spi.writebytes([0x37]) # '7'
print(spi.readbytes(1))
spi.close()
return flask.redirect("/")
def startWatering():
print("Started watering...")
session['watering_command_status'] = "ON"
# send the signal to arduino to start watering
spi = SPI(1, 0)
spi.msh = 100000
spi.bpw = 8
# send the appropriate signal
spi.writebytes([0x36]) # '6'
print(spi.readbytes(1))
spi.close()
return flask.redirect("/")
def ini_levels():
check_ok = 0
update_data = 0x39
# spi.set_clock_hz(1000000)
# spi.set_mode(0)
# spi.set_bit_order(SPI.MSBFIRST)
SPI_PORT = 0
SPI_DEVICE = 0
# SPI setup
spi = SPI(0, 0) #/dev/spidev1.0
spi.msh = 100000 # SPI clock set to 100 kHz
spi.bpw = 8 # bits/word
spi.threewire = False
spi.lsbfirst = False
spi.mode = 0
spi.cshigh = False # ADS1248 chip select (active low)
# spi.open(0,0)
spi.open(SPI_PORT, SPI_DEVICE)
print "SPI port ", SPI_PORT, " ", SPI_DEVICE, " open"
def spi_config():
global RFM_SPI
RFM_SPI = SPI(0, 0)
RFM_SPI.msh = 5000000
import sys
from Adafruit_BBIO.SPI import SPI
command = sys.argv[1]
WALK = 1
WALK_BACK = 31
STOP = 15
TURNL = 3
TURNR = 7
spi = SPI(0,0)
spi.msh = 57600
spi.bpw = 8
#for debugging with keyboard input
#command = raw_input();
spi.xfer2([getCommandCode(command)])
spi.close()
def getCommandCode(command):
if command == 'walk':
print("Walk!")
return WALK
elif command == 'back':
print('Reverse')
return WALK_BACK
elif command == 'stop':
print('Stop!')
return STOP
elif command == 'left':
print('Turn Left')
from Adafruit_BBIO.SPI import SPI
import zlsGpio
# alt use spidev
import time
#https://github.com/adafruit/adafruit-beaglebone-io-python
# Constants
VREF = 4.096
z = time.time()
spi = SPI(1, 0) # 1, 0 is what used to be 0,0
#spi.fd = -1;
spi.mode = 3
spi.bpw = 8
#Bits per word
spi.msh = 1000000
y = time.time()
print y - z
def ReadADC_average(chan, averages, delay, vref):
""" Returns average of averages measurments.
rate is mS
loopMax is number of measurements
"""
data_summ = 0.0
data_val = 0.0
for x in range(averages):
data_summ += self.ReadADC(chan)
time.sleep(delay)
from Adafruit_BBIO.SPI import SPI
import time
pause = 0.1
chipSelect = "P9_12"
GPIO.setup(chipSelect, GPIO.OUT)
GPIO.output(chipSelect, GPIO.HIGH)
sclk = "P9_11"
GPIO.setup(sclk, GPIO.IN)
spi = SPI(0, 0)
spi.mode = 0
spi.msh = 500000
spi.open(0, 0)
# global count
# count = 0;
#
# def callback_function_print(input_pin):
# count = count + 1
# print "Input on pin", input_pin
#
# GPIO.add_event_detect(sclk, GPIO.BOTH, callback=callback_function_print)
def spi_write(num):
print "Writing " + num + "..."
GPIO.output(chipSelect, GPIO.LOW)
#SPIO_SCLK P9.22 => SCK blue
#DGND gnd gray
#3V3 orange
#OM SPI TE ENABLEN
#config-pin P9.20 spi
#en da me alle pins
from Adafruit_BBIO.SPI import SPI
import Adafruit_BBIO.GPIO as GPIO
import time
spi = SPI(0, 0) #4 busses, this is bus 0
spi.msh = 10000 #Frequency
spi.bpw = 8 #bits per word
spi.cshigh = False #true means you select the chip, depends on the chip, here low means active, normally Low for IMU
spi.threewire = False #if it is true, you just read, otherwise you also send commands
spi.lsbfirst = False #Least significant bit first (left)
spi.open(0, 0) #open
#GPIO.setup("P8_11",GPIO.OUT)
#GPIO.output("P8_11",GPIO.HIGH)
try:
while True:
res = spi.xfer2([0xFFFF, 0xFFFF]) #deliver two bytes
res1 = spi.readbytes(2) #Read 2 bytes
angle = (res1[0] << 8) | res1[1] #merge leftbyte and rightbyte
from Adafruit_BBIO.SPI import SPI
import time
#https://github.com/adafruit/adafruit-beaglebone-io-python
spi = SPI(1, 0)
#spi.fd = -1;
spi.mode = 3
#spi.bpw = 8;#Bits per word
spi.msh = 1250000
time.sleep(.300)
#spi.lsbfirst = True
time.sleep(.300)
def readLong():
x = 0
time.sleep(.001)
spi.writebytes([0x33])
time.sleep(.001)
x_high_data = spi.readbytes(1)
time.sleep(.001)
x = x_high_data[0] << 8
spi.writebytes([0x34])
time.sleep(.001)
x_low_data = spi.readbytes(1)
x += x_low_data[0]
longAdc = 0.0
longAdc += x - 32768
#y -= 32768
from Adafruit_BBIO.SPI import SPI
import struct
import time
spi = SPI(0,0)
spi.mode = 1
spi.msh = 300000
spi.xfer([0b00011000, 0x02])
def decode_sent_command(ser_cmd):
cmd_bits = (ser_cmd & (((1<<6) - 1)<<10))>>10
data_bits = ser_cmd & ((1<<10)-1)
return bin(cmd_bits)[2:], data_bits
def send_cmd(cmd,data):
ser_cmd = (cmd << 10) | (data & ((1<<10)-1))
w0 = ser_cmd >> 8
w1 = ser_cmd & ((1<<8)-1)
return [w0, w1]
# write to RDAC
spi.xfer(list(struct.unpack('BB', struct.pack('>H', 1 << 10 | 0))))
# read RDAC
spi.xfer(list(struct.unpack('BB', struct.pack('>H', 0b10 << 10 | 0))))
# read Control register
spi.xfer(list(struct.unpack('BB', struct.pack('>H', 0b111 << 10 | 0))))
spi.readbytes(2)
#!/usr/bin/python from Adafruit_BBIO.SPI import SPI import Adafruit_BBIO.GPIO as GPIO import time #------------------------------------------------------- # initialize the bus and device /dev/spidev1.0 spi0 = SPI(0, 0) #ADC # initialize the bus and device /dev/spidev2.0 spi1 = SPI(1, 0) #DAC #------------------------------------------------------- #Set the maximum clock frequency spi0.msh = 100000 spi1.msh = 100000 #------------------------------------------------------- # mnemonics for GPIO RST = "P9_26" CLR = "P9_25" LDAC = "P9_24" BUSY = "P9_20" CNV = "P9_23" PWR_SYS = "P9_16" #PWR_SYS = "P9_15" #------------------------------------------------------- # defining outputs GPIO.setup(RST, GPIO.OUT) GPIO.setup(CLR, GPIO.OUT) GPIO.setup(LDAC, GPIO.OUT) GPIO.setup(CNV, GPIO.OUT) GPIO.setup(PWR_SYS, GPIO.OUT) #------------------------------------------------------- # defining inputs
### New Python Template File
### H27 Mar 16
import os, sys
import time
import Adafruit_BBIO.GPIO as GPIO
from Adafruit_BBIO.SPI import SPI
GPIO.setup("P9_12",GPIO.OUT)
GPIO.output("P9_12",GPIO.HIGH)
print("GPIO >> HIGH")
spi_in = SPI(0, 0)
spi_out = SPI(0, 1)
spi_out.msh = 500000
while True:
GPIO.output("P9_12",GPIO.LOW)
print("GPIO >> LOW")
spi_out.writebytes([0b00001111])
print("write >> num")
print spi_in.readbytes(1)
GPIO.output("P9_12",GPIO.HIGH)
print("GPIO >> HIGH")
time.sleep(1)
GPIO.cleanup()
def ADCinit():
RegWrite(ADS1248.MUX0, 0b00000001); # MUX0: Pos. input: AIN0, Neg. input: AIN1 (Burnout current source off)
RegWrite(ADS1248.MUX1, 0b00100000); # MUX1: REF0, normal operation
RegWrite(ADS1248.SYS0, 0b00000000); # SYS0: PGA Gain = 1, 5 SPS
RegWrite(ADS1248.IDAC0,0b00000000); # IDAC0: off
RegWrite(ADS1248.IDAC1,0b11001100); # IDAC1: n.c.
RegWrite(ADS1248.VBIAS,0b00000000); # VBIAS: BIAS voltage disabled
RegWrite(ADS1248.OFC0, 0b00000000); # OFC0: 0 => reset offset calibration
RegWrite(ADS1248.OFC1, 0b00000000); # OFC1: 0 => reset offset calibration
RegWrite(ADS1248.OFC2, 0b00000000); # OFC2: 0 => reset offset calibration
RegWrite(ADS1248.GPIOCFG, 0b00000000); # GPIOCFG: all used as analog inputs
RegWrite(ADS1248.GPIODIR, 0b00000000); # GPIODIR: -
RegWrite(ADS1248.GPIODAT, 0b00000000); # GPIODAT: -
spi = SPI(0,0) #/dev/spidev1.0
spi.msh=10000 # SPI clock set to 100 kHz
spi.bpw = 8 # bits/word
spi.threewire = False
spi.lsbfirst = False
spi.mode = 1
spi.cshigh = False # ADS1248 chip select (active low)
spi.open(0,0)
GPIO.setup("P9_14", GPIO.OUT)
# drive START high to start conversion
GPIO.setup(ADS1248.STARTPIN, GPIO.OUT)
GPIO.output(ADS1248.STARTPIN,GPIO.HIGH)
from Adafruit_BBIO.SPI import SPI
import time
pause = 0.1
chipSelect = "P9_12"
GPIO.setup(chipSelect, GPIO.OUT)
GPIO.output(chipSelect, GPIO.HIGH)
sclk = "P9_11"
GPIO.setup(sclk, GPIO.IN)
spi = SPI(0,0)
spi.mode = 0
spi.msh = 500000
spi.open(0,0)
# global count
# count = 0;
#
# def callback_function_print(input_pin):
# count = count + 1
# print "Input on pin", input_pin
#
# GPIO.add_event_detect(sclk, GPIO.BOTH, callback=callback_function_print)
def spi_write(num):
print "Writing " + num + "..."
GPIO.output(chipSelect, GPIO.LOW)
print str(spi.xfer2([int(num)]))
from Adafruit_BBIO.SPI import SPI spi = SPI(1,0) spi.mode=2 spi.msh=200000 spi.open(1,0) print spi.readbytes(4) #print spi.xfer2([32, 11, 110, 22, 220]) spi.close()
#!/usr/bin/python from Adafruit_BBIO.SPI import SPI import Adafruit_BBIO.GPIO as GPIO import time #------------------------------------------------------- # DAC # initialize the bus and device /dev/spidev2.0 spi1 = SPI(1, 0) #defining mode (CPOL = 0; CPHA = 1) spi1.mode = 1 #defining speed (in bps) spi1.msh = 10000000 #------------------------------------------------------- # mnemonics for GPIO RST = "P9_26" CLR = "P9_25" LDAC = "P9_24" #------------------------------------------------------- # defining outputs GPIO.setup(RST, GPIO.OUT) GPIO.setup(CLR, GPIO.OUT) GPIO.setup(LDAC, GPIO.OUT) #------------------------------------------------------- # initialization of outputs GPIO.output(RST, GPIO.HIGH) GPIO.output(CLR, GPIO.HIGH) GPIO.output(LDAC, GPIO.LOW) #======================================================= # DAC calibration parameters #======================================================= # global variables
#TODO: port this to other stepper actions
#spio_csx = "P9_17"
spio_csy = "P9_11"
spio_csz = "P8_14"
spi = SPI(1, 0)
#spi.no_cs = True
spi.cshigh = True
spio_selects = [spio_csy, spio_csz]
for select in spio_selects:
GPIO.setup(select, GPIO.OUT)
GPIO.output(select, GPIO.HIGH)
GPIO.output(spio_csz, GPIO.LOW)
spi.mode = 3
spi.msh = int(16000000 / 8)
#spi.msh = 1000
def controlledwrite(lst, chipselect):
spi.writebytes(lst)
GPIO.output(chipselect, GPIO.HIGH)
sleep(1)
GPIO.output(chipselect, GPIO.LOW)
spi.readbytes(len(lst))
GPIO.output(chipselect, GPIO.HIGH)
sleep(1)
GPIO.output(chipselect, GPIO.LOW)
spi.writebytes(lst)
GPIO.output(chipselect, GPIO.HIGH)
sleep(1)
#!/usr/bin/python from Adafruit_BBIO.SPI import SPI from time import sleep spi = SPI(0,0) spi.bpw = 12 spi.msh = 100000 spi.lsbfirst = False spi.mode = 0 spi.open tlc5947_count = 2 tlc5947_channels = 24 # buffer = [0x000] * 48 buffer = [0x000] * (tlc5947_count * tlc5947_channels) #spi.writebytes(buffer) #print buffer spi.writebytes(buffer) #sleep(1) spi.close # CS_0 P9_17 lat # DO P9_21 din # DI P9_18 n/c
rssi = value[17] - 256
#print(rssi)
if rssi > -70:
if value[28] == 128:
print("%s, 1, %d") % (address, rssi)
if value[28] == 129:
print("%s, 2, %d") % (address, rssi)
if value[28] == 130:
print("%s, 3, %d") % (address, rssi)
if value[28] == 131:
print("%s, 4, %d") % (address, rssi)
bt = SPI(0, 0)
bt.mode = 1
bt.msh = 1000000
#reset the module
GPIO.output("P9_12", GPIO.LOW)
time.sleep(0.1)
GPIO.output("P9_12", GPIO.HIGH)
# initialize bt module
k = 0
while k < 100:
#print("Sending init message")
bt.xfer2([
0x00, 0xFE, 0x2A, 0x01, 0x00, 0xFE, 0x26, 0x02, 0x0A, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
#!/usr/bin/python
from Adafruit_BBIO.SPI import SPI
import Adafruit_BBIO.GPIO as GPIO
import time
spi = SPI(1, 1) #4 busses, this is bus 0
spi.msh = 500000 #Frequency
spi.bpw = 8 #bits per word
spi.cshigh = True #true means you select the chip, depends on the chip, here low means active, normally Low for IMU
spi.threewire = False #if it is true, you just read, otherwise you also send commands
spi.lsbfirst = False #Least significant bit first (left)
#spi.mode=3
spi.open(0, 0) #open
#GPIO.setup("P8_11",GPIO.OUT)
#GPIO.output("P8_11",GPIO.HIGH)
try:
while True:
res = spi.xfer2([0xFFFF, 0xFFFF]) #deliver two bytes
#spi.cshigh=False
res1 = spi.readbytes(10)
angle = (res1[0] << 8) | res1[1] #merge leftbyte and rightbyte
angle1 = angle & 0x3FFF #move the first two bits
angle2 = float(angle1) / 16363 * 360
#print("res is", str(res))
print("res1 is", str(res1))
print("angle is", str(angle))
from Adafruit_BBIO.SPI import SPI
import time
import numpy as np
import scipy as sp
import peakutils
spi = SPI(0, 0)
spi.mode = 1
spi.bpw = 8
spi.msh = 8000000
def put_in_reset():
print "\nput in reset"
print spi.xfer2([int("16", 16), int("2F", 16), int("01", 16)])
def read_this_fifo(this, that):
#print "\nread this fifo"
#print "sent: 08", this, that, " 00. Got:"
resp = spi.xfer2(
[int("08", 16),
int(str(this), 16),
int(str(that), 16),
int("00", 16)])
print resp
return resp
def put_out_reset():
print "\nput out reset"
#!/usr/bin/python from Adafruit_BBIO.SPI import SPI import Adafruit_BBIO.GPIO as GPIO import math import time import dac #------------------------------------------------------- # initialize the bus and device /dev/spidev1.0 spi0 = SPI(0, 0) #defining mode (CPOL = 0; CPHA = 1) spi0.mode = 1 #defining speed (in bps) spi0.msh = 10000000 #------------------------------------------------------- # mnemonics for GPIO BUSY = "P9_20" CNV = "P9_23" #------------------------------------------------------- # defining outputs GPIO.setup(CNV, GPIO.OUT) #------------------------------------------------------- # defining inputs GPIO.setup(BUSY, GPIO.IN) #------------------------------------------------------- # initialization of outputs GPIO.output(CNV, GPIO.LOW) #======================================================= # ADC calibration parameters #======================================================= # global variables global GAIN
