#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
#  MA 02110-1301, USA.
#
#  Written by BitHead (Britany Head)
# Step 1) Enable I2C in Raspi-Config (Interfacing Options)
# Step 2) sudo apt-get install i2c-tools python3-smbus
# Step 3) plug it in (don't forget your pull-up resistors) and run this program

import smbus
import time
import threading

bus = smbus.SMBus(1)  # /dev/i2c-1, in my case


class VEML6040(object):
    def __init__(self, i2c_driver=None, bus=None, resetPin=None):
        """
                This method initializes the class object. If no 'address' or
                'i2c_driver' are inputed or 'None' is specified, the method will
                use the defaults.
                :param address: 	The I2C address to use for the device.
                                    If not provided, the method will default to
                                    the 0x10
                :param i2c_driver:	An existing SMBus driver object.If not parsed, it is created
                :param bus:         bus number of i2c bus on rpi. Defaults to 1 is nothing passed
                """
        self.VEML6040_ADDR = 0x10  #default i2c address of
Exemple #2
0
 def __init__(self):
     signal.signal(signal.SIGINT, self.exit_gracefully)
     signal.signal(signal.SIGTERM, self.exit_gracefully)
     self.i2c_bus = smbus.SMBus(self.i2c_bus)
 def __init__(self, name, address, bus_nr, address_sensor):
     self.name = name
     self.address = address
     self.bus_nr = bus_nr
     self.bus = smbus.SMBus(bus_nr)
     self.address_sensor = address_sensor
import smbus
bus = smbus.SMBus(1)    # 0 = /dev/i2c-0 (port I2C0), 1 = /dev/i2c-1 (port I2C1)

fichero = open('/usr/lib/python2.7/dist-packages/RPi/volumen.txt')
if fichero.read() == '0':
	print('no se puede mas')
else:
	fichero.seek(0)
	numero = fichero.read()
	fichero.close()
	numero = int(numero) + 2
	bus.write_byte_data(0x44, 0x02, numero)
	numero = str(numero)
	fichero = open('/usr/lib/python2.7/dist-packages/RPi/volumen.txt','w')
	fichero.seek(0)
	fichero.write(numero)
	fichero.close()
	fichero = open('/usr/lib/python2.7/dist-packages/RPi/volumen.txt')
	numero = fichero.read()
	print(numero)
	fichero.close()
Exemple #5
0
def dist(a, b):
    return math.sqrt((a * a) + (b * b))


def get_y_rotation(x, y, z):
    radians = math.atan2(x, dist(y, z))
    return -math.degrees(radians)


def get_x_rotation(x, y, z):
    radians = math.atan2(y, dist(x, z))
    return math.degrees(radians)


bus = smbus.SMBus(1)  # or bus = smbus.SMBus(1) for Revision 2 boards
address = 0x68  # This is the address value read via the i2cdetect command

# Now wake the 6050 up as it starts in sleep mode
bus.write_byte_data(address, power_mgmt_1, 0)

#---------------------------------- main -------------------------------------------
learning_rate = 0.1
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
W1 = tf.Variable(tf.random_normal([6, 4]), name='weight1')
b1 = tf.Variable(tf.random_normal([4]), name='bias1')
layer1 = tf.nn.relu(tf.matmul(X, W1) + b1)

W2 = tf.Variable(tf.random_normal([4, 2]), name='weight2')
b2 = tf.Variable(tf.random_normal([2]), name='bias2')
Exemple #6
0
from lcddriver import lcd
from time import time
from time import sleep
from datetime import datetime
import smbus

i2c = smbus.SMBus(0)
address = 0x5c

lcd = lcd()

lcd.display_string("LCD", 1)
lcd.display_string("Hello World", 2)
sleep(5)
lcd.clear()


def read():
    hum = 0.0
    tmp = 0.0
    try:
        sleep(0.003)
        i2c.write_i2c_block_data(address, 0x03, [0x00, 0x04])
        sleep(0.015)
        block = i2c.read_i2c_block_data(address, 0, 6)
        hum = float(block[2] << 8 | block[3]) / 10
        tmp = float(block[4] << 8 | block[5]) / 10
    except:
        pass
    return (tmp, hum)
 def __init__(self):
     self.address = 0x18  #address of the I2C device
     self.bus = smbus.SMBus(1)  #initialize bus
import time
import smbus
import logx
import logging
BUS = smbus.SMBus(1)
LCD_ADDR = 0x27
BLEN = 1 #turn on/off background light

def turn_light(key):
    global BLEN
    BLEN = key
    if key ==1 :
        BUS.write_byte(LCD_ADDR ,0x08)
        logging.info('LCD executed turn on BLight')
    else:
        BUS.write_byte(LCD_ADDR ,0x00)
        logging.info('LCD executed turn off BLight')

def write_word(addr, data):
    global BLEN
    temp = data
    if BLEN == 1:
        temp |= 0x08
    else:
        temp &= 0xF7
    BUS.write_byte(addr ,temp)

def send_command(comm):
    # Send bit7-4 firstly
    buf = comm & 0xF0
    buf |= 0x04               # RS = 0, RW = 0, EN = 1
Exemple #9
0
class _Basic_class(object):
    _class_name = '_Basic_class'
    _DEBUG = 0
    DEBUG_LEVELS = {
        'debug': logging.DEBUG,
        'info': logging.INFO,
        'warning': logging.WARNING,
        'error': logging.ERROR,
        'critical': logging.CRITICAL,
    }
    DEBUG_NAMES = ['critical', 'error', 'warning', 'info', 'debug']

    bus = smbus.SMBus(1)
    SYS_ADDRESS = 0x10

    def __init__(self):
        self.logger_setup()

    def logger_setup(self):
        self.logger = logging.getLogger(self._class_name)
        self.ch = logging.StreamHandler()
        form = "%(asctime)s	[%(levelname)s]	%(message)s"
        self.formatter = logging.Formatter(form)
        self.ch.setFormatter(self.formatter)
        self.logger.addHandler(self.ch)
        self._debug = self.logger.debug
        self._info = self.logger.info
        self._warning = self.logger.warning
        self._error = self.logger.error
        self._critical = self.logger.critical

    @property
    def DEBUG(self):
        return self._DEBUG

    @DEBUG.setter
    def DEBUG(self, debug):
        if debug in range(5):
            self._DEBUG = self.DEBUG_NAMES[debug]
        elif debug in self.DEBUG_NAMES:
            self._DEBUG = debug
        else:
            raise ValueError(
                'Debug value must be 0(critical), 1(error), 2(warning), 3(info) or 4(debug), not \"{0}\".'
                .format(debug))
        self.logger.setLevel(self.DEBUG_LEVELS[self._DEBUG])
        self.ch.setLevel(self.DEBUG_LEVELS[self._DEBUG])
        self._debug('Set logging level to [%s]' % self._DEBUG)

    def run_command(self, cmd):
        self._debug('Run command: "%s"' % cmd)
        with tempfile.TemporaryFile() as f:
            subprocess.call(cmd, shell=True, stdout=f, stderr=f)
            f.seek(0)
            output = f.read()
            return output

    def _map(self, x, in_min, in_max, out_min, out_max):
        return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min

    def _write_sys_byte(self, value):
        self._info('Write "0x%02X" to I2C_dev(0x%02X)' %
                   (value, self.SYS_ADDRESS))
        self._debug('└─Write "0x%02X" to I2C_dev(0x%02X) start' %
                    (value, self.SYS_ADDRESS))
        self.bus.write_byte(self.SYS_ADDRESS, value)
        self._debug("└─Done")

    def _read_sys_byte(self, reg, delay=0):
        self._info('Read from I2C_dev(0x%02X) at "0x%02X"' %
                   (self.SYS_ADDRESS, reg))
        self._debug('└─Write "0x%02X" to I2C_dev(0x%02X)' %
                    (reg, self.SYS_ADDRESS))
        self.bus.write_byte(self.SYS_ADDRESS, reg)
        self._debug("└─Done")
        if delay != 0:
            time.sleep(delay)

        self._debug('└─Read from I2C_dev(0x%02X)' % (self.SYS_ADDRESS))
        number = self.bus.read_byte(self.SYS_ADDRESS)
        self._debug('└─Done, read value: "0x%02X"' % number)
        if delay != 0:
            time.sleep(delay)
        return number

    def end(self):
        pass
Exemple #10
0
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 17 18:50:15 2021

@author: Administrator
"""
import smbus

device = smbus.SMBus(1)
dev_addr = 0x30
identi_addr = 0x39

inter_control = 0x1b
X_H_add = 0x00
X_L_add = 0x01
Y_H_add = 0x02
Y_L_add = 0x03
Z_H_add = 0x04
Z_L_add = 0x05

class Mag:
    def __init__(self):
        self.device = device
        
    def all_data(self):
        self.device.write_byte_data(dev_addr,inter_control,0b00100001)
        self.X_L = self.device.read_byte_data(dev_addr,X_L_add)
        self.X_H = self.device.read_byte_data(dev_addr,X_H_add)
        self.Y_L = self.device.read_byte_data(dev_addr,Y_L_add)
        self.Y_H = self.device.read_byte_data(dev_addr,Y_H_add)
        self.Z_L = self.device.read_byte_data(dev_addr,Z_L_add)
Exemple #11
0
#!/usr/bin/env python3
# Reads a TMP101 sensor and posts its temp on ThinkSpeak
# https://thingspeak.com/channels/538706
# source setup.sh to set THING_KEY

# Edited by James Werne, 11/4/2020
# Reads values of TMP101 sensors, then prints them to a Thingspeak channel:
# https://thingspeak.com/channels/1220211/private_show

import requests
import os, sys
import time
import smbus
import time

bus = smbus.SMBus(2)
TMPleft = 0x48
TMPright = 0x4a

#TMP101a='/sys/class/i2c-adapter/i2c-2/2-0048/hwmon/hwmon0/'
#TMP101b='/sys/class/i2c-adapter/i2c-2/2-0049/hwmon/hwmon1/'

# Get the key (See setup.sh)
key = os.getenv('THING_KEY', default="")
if (key == ""):
    print("THING_KEY is not set")
    sys.exit()

url = 'https://api.thingspeak.com/update'
print(url)
 def __init__(self):
     # Initialize connection to peripheral
     self.bus = smbus.SMBus(1)
Exemple #13
0
#!/usr/bin/env python
import smbus
import sys

I2C_BUS = 1

install_mode = False

if len(sys.argv) > 1:
    if "--install" in sys.argv:
        install_mode = True

try:
    bus = smbus.SMBus(I2C_BUS)
except IOError:
    print("Unable to access /dev/i2c-{}, please ensure i2c is enabled!".format(I2C_BUS))
    sys.exit()

def get_device(line):
    parts=[x.strip() for x in line.split(":")]
    return int(parts[0], 16), parts[1], parts[2], parts[3]

devices = [get_device(line) for line in open("breakouts.config").read().strip().split("\n")]

addresses = [device[0] for device in devices]

def identify(find_i2c_addr):
    for i2c_addr, library, module, name in devices:
        if i2c_addr == find_i2c_addr:
            installed = True
            try:
Exemple #14
0
 def __init__(self, bus, addr=ADDR):
     self.addr = addr
     self.bus = smbus.SMBus(bus)
     self.banks = [GPIOA, GPIOB]
 def __init__(self, addr, port=I2CBUS):
    self.addr = addr
    self.bus = smbus.SMBus(port)
Exemple #16
0
#!/usr/bin/env python3

import smbus  # install python3-smbus with apt
import time

i2c = smbus.SMBus(1)
addr = 0x28


def read(reg):
    v = i2c.read_byte_data(addr, reg)
    return v


def readw(reg):
    v = i2c.read_word_data(addr, reg)
    return v & 0x00ff, (v & 0xff00) >> 8


def write(reg, v):
    i2c.write_byte_data(addr, reg, v)


def setup():
    read(0x00)
    read(0x0a)
    read(0x01)

    read(0x40)
    read(0x41)
    read(0x48)
Exemple #17
0
 def __init__(self):
     self.bus = smbus.SMBus(1)
     self.device_address = 0x6c
     self.full_range = 1000.0
     self.init_device()
Exemple #18
0
import smbus
import sys
import getopt
import time

bus = smbus.SMBus(0)

address = 0x20  # I2C address of MCP23017
bus.write_byte_data(0x20, 0x00, 0x00)  # Set all of bank A to outputs
bus.write_byte_data(0x20, 0x01, 0x00)  # Set all of bank B to outputs


def set_led(data, bank):
    if bank == 1:
        bus.write_byte_data(address, 0x12, data)
    else:
        bus.write_byte_data(address, 0x13, data)
    return


# Handle the command line arguments
def main():
    a = 0


delay = 0.05
while True:

    # Move led left
    for x in range(0, 8):
        a = 1 << x
Exemple #19
0
    log_directory = parameters["log_directory"]

    if not os.path.isdir(log_directory):
        os.makedirs(log_directory)

    logging.basicConfig(
        level=log_level,
        format='%(asctime)s %(name)-20s %(levelname)-8s %(message)s',
        datefmt="%d-%m-%Y %H:%M:%S",
        filename=log_directory + "/dump_spectra_" +
        datetime.datetime.now().strftime("%d%m%Y_%H%M%S") + ".log",
        filemode='w')

    logger = logging.getLogger("dump_spectra")

    i2c_bus = smbus.SMBus(1)
    rtc = ds3231.DS3231(i2c_bus, 0x68)

    snap_board = parameters["snap-board"]
    firmware = parameters["firmware"]
    synthesizer = parameters["synthesizer"]
    adcs = parameters["adcs"]
    pfb = parameters["pfb"]
    test_vector_generator = parameters["test-vector-generator"]
    xcorr = parameters["xcorr"]
    output_control = parameters["output-control"]
    packetiser = parameters["packetiser"]
    baseband = parameters["baseband"]
    mount_directory = parameters["mount_directory"]
    harddrives = parameters["hard-drives"]
    spectra = parameters["spectra"]
Exemple #20
0
LCD_LINE_1 = 0x80  # LCD RAM address for the 1st line
LCD_LINE_2 = 0xC0  # LCD RAM address for the 2nd line
LCD_LINE_3 = 0x94  # LCD RAM address for the 3rd line
LCD_LINE_4 = 0xD4  # LCD RAM address for the 4th line

LCD_BACKLIGHT = 0x08  # On
#LCD_BACKLIGHT = 0x00  # Off

ENABLE = 0b00000100  # Enable bit

# Timing constants
E_PULSE = 0.0005
E_DELAY = 0.0005

#Open I2C interface
bus = smbus.SMBus(2)  # Rev C Beaglebone Black uses 2


def lcd_init():
    # Initialise display
    lcd_byte(0x33, LCD_CMD)  # 110011 Initialise
    lcd_byte(0x32, LCD_CMD)  # 110010 Initialise
    lcd_byte(0x06, LCD_CMD)  # 000110 Cursor move direction
    lcd_byte(0x0C, LCD_CMD)  # 001100 Display On,Cursor Off, Blink Off
    lcd_byte(0x28, LCD_CMD)  # 101000 Data length, number of lines, font size
    lcd_byte(0x01, LCD_CMD)  # 000001 Clear display
    time.sleep(E_DELAY)


def lcd_byte(bits, mode):
    # Send byte to data pins
Exemple #21
0
# ----------------------------------------------------------
# i2c bus interface
# DS1621 register addresses
stopConv = 0x22
accessTH = 0xa1
accessTL = 0xa2
readCount = 0xa8
readSlope = 0xa9
readTemp = 0xaa
accessCfg = 0xac
startConv = 0xee

# enable interface in one-shot mode
try:
    import smbus
    i2cBus = smbus.SMBus(bus=1)
    cfg = i2cBus.read_byte_data(ds1621Addr, accessCfg)
    if 0 == (cfg & 0x01):
        cfg |= 0x01  # set one-shot bit
        print('Writing config register: {0}'.format(hex(cfg)))
        i2cBus.write_byte_data(ds1621Addr, accessCfg, cfg)
        time.sleep(0.01)
    print('DS1621 intialized at addr: {0}'.format(hex(ds1621Addr)))

except (IOError, OSError, ImportError) as e:
    i2cBus = None
    print('Failed to initialize hardware: {0}'.format(e))
    print('   Running in simulation mode.')


# function to read and report temperature
Exemple #22
0
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

import time
from ctypes import *
import smbus

VL53L0X_GOOD_ACCURACY_MODE = 0  # Good Accuracy mode
VL53L0X_BETTER_ACCURACY_MODE = 1  # Better Accuracy mode
VL53L0X_BEST_ACCURACY_MODE = 2  # Best Accuracy mode
VL53L0X_LONG_RANGE_MODE = 3  # Longe Range mode
VL53L0X_HIGH_SPEED_MODE = 4  # High Speed mode

i2cbus_zero = smbus.SMBus(0)
i2cbus_one = smbus.SMBus(1)


# i2c bus read callback
def i2c_read(address, reg, data_p, length, bus_number):
    ret_val = 0
    result = []

    # print("Python i2c_read to bus ", bus_number)
    try:
        if (bus_number == 0):
            result = i2cbus_zero.read_i2c_block_data(address, reg, length)
        if (bus_number == 1):
            result = i2cbus_one.read_i2c_block_data(address, reg, length)
    except IOError:
Exemple #23
0
LCD_LINE_1 = 0x80  # LCD RAM address for the 1st line
LCD_LINE_2 = 0xC0  # LCD RAM address for the 2nd line
LCD_LINE_3 = 0x94  # LCD RAM address for the 3rd line
LCD_LINE_4 = 0xD4  # LCD RAM address for the 4th line

LCD_BACKLIGHT = 0x08  # On
#LCD_BACKLIGHT = 0x00  # Off

ENABLE = 0b00000100  # Enable bit

# Timing constants
E_PULSE = 0.0005
E_DELAY = 0.0005

#Open I2C interface
bus = smbus.SMBus(0)  # Rev 1 Pi uses 0
#bus = smbus.SMBus(1) # Rev 2 Pi uses 1


def get_ip_address():
    ip_address = ''
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.connect(("8.8.8.8", 80))
    ip_address = s.getsockname()[0]
    s.close()
    return ip_address


def lcd_init():
    # Initialise display
    lcd_byte(0x33, LCD_CMD)  # 110011 Initialise
Exemple #24
0
# the integer division and input()
# mind your parentheses!

import smbus
import time
import math
import RPi.GPIO as GPIO
import struct
import operator
import pickle

debug = 0

rev = GPIO.RPI_REVISION
if rev == 2 or rev == 3:
    bus = smbus.SMBus(1)
else:
    bus = smbus.SMBus(0)

# I2C Address of Arduino
address = 0x06

# Command Format
# analogRead() command format header
aRead_cmd = [3]

# This allows us to be more specific about which commands contain unused bytes
unused = 0

#Add a multipler to each sensor
multp = [-10, -5, 0, 5, 10]
Exemple #25
0
 def __init__(self, address, bus=1):
     self.address = address
     self.bus = smbus.SMBus(bus)
     # Wake up the MPU-6050 since it starts in sleep mode
     self.bus.write_byte_data(self.address, self.PWR_MGMT_1, 0x00)
Exemple #26
0
 def __init__(self, address, bus=1):
     self.address = address
     self.bus = smbus.SMBus(bus)
def read_raw_data(addr):
    #Accelero and Gyro value are 16-bit
        high = bus.read_byte_data(DeviceAddress, addr)
        low = bus.read_byte_data(DeviceAddress, addr+1)

        #concatenate higher and lower value
        value = ((high << 8) | low)

        #to get signed value from mpu6050
        if(value > 32768):
                value = value - 65536
        return value


bus = smbus.SMBus(1) 	# or bus = smbus.SMBus(0) for older version boards
DeviceAddress = 0x68   # MPU6050 device address

MPU_Init()

time.sleep(1)
#Read Accelerometer raw value
accX = read_raw_data(ACCEL_XOUT_H)
accY = read_raw_data(ACCEL_YOUT_H)
accZ = read_raw_data(ACCEL_ZOUT_H)

#print(accX,accY,accZ)
#print(math.sqrt((accY**2)+(accZ**2)))
def init():
    if (RestrictPitch):
        roll = math.atan2(accY,accZ) * radToDeg
LCD_CHR = 1  # sending data
LCD_CMD = 0  # sending command

LCD_LINE_1 = 0x80  # LCD RAM address for the 1st line
LCD_LINE_2 = 0xC0  # LCD RAM address for the 2nd line
LCD_LINE_3 = 0x94  # LCD RAM address for the 3rd line
LCD_LINE_4 = 0xD4  # LCD RAM address for the 4th line

LCD_BACKLIGHT = 0x08  # On

ENABLE = 0b00000100  # Enable bit

E_PULSE = 0.0005
E_DELAY = 0.0005

bus = smbus.SMBus(1)  # Rev 2 Pi uses 1


def lcd_init():
    # Initialise display
    lcd_byte(0x33, LCD_CMD)  # 110011 Initialise
    lcd_byte(0x32, LCD_CMD)  # 110010 Initialise
    lcd_byte(0x06, LCD_CMD)  # 000110 Cursor move direction
    lcd_byte(0x0C, LCD_CMD)  # 001100 Display On,Cursor Off, Blink Off
    lcd_byte(0x28, LCD_CMD)  # 101000 Data length, number of lines, font size
    lcd_byte(0x01, LCD_CMD)  # 000001 Clear display
    time.sleep(E_DELAY)


def lcd_byte(bits, mode):
    # Send byte to data pins
Exemple #29
0
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

import time
from ctypes import *
import smbus

VL53L0X_GOOD_ACCURACY_MODE = 0  # Good Accuracy mode
VL53L0X_BETTER_ACCURACY_MODE = 1  # Better Accuracy mode
VL53L0X_BEST_ACCURACY_MODE = 2  # Best Accuracy mode
VL53L0X_LONG_RANGE_MODE = 3  # Longe Range mode
VL53L0X_HIGH_SPEED_MODE = 4  # High Speed mode

i2cbus = smbus.SMBus(1)


# i2c bus read callback
def i2c_read(address, reg, data_p, length):
    ret_val = 0
    result = []

    try:
        result = i2cbus.read_i2c_block_data(address, reg, length)
    except IOError:
        ret_val = -1

    if (ret_val == 0):
        for index in range(length):
            data_p[index] = result[index]
Exemple #30
0
 def __init__(self):
     self.bus = smbus.SMBus(1)