Example #1
0
def updateInt():
    if not test_environment:
        emit('randint', [adc.read(0), adc.read(1), adc.read(2)])
    else:
        emit('randint', [max(random.randint(latest_sensor_readings[0][-1] - 5, latest_sensor_readings[0][-1] + 5), 0),
                         max(random.randint(latest_sensor_readings[1][-1] - 5, latest_sensor_readings[1][-1] + 5), 0),
                         max(random.randint(latest_sensor_readings[2][-1] - 5, latest_sensor_readings[2][-1] + 5), 0)])
Example #2
0
 def update_recent_readings_adc():
     for x in range(0, 3):
         if len(latest_sensor_readings[x]) < 200:
             latest_sensor_readings[x] += [adc.read(x)]
         else:
             latest_sensor_readings[x].pop(0)
             latest_sensor_readings[x] += [adc.read(x)]
     with open(csv_filename, 'a') as writeFile:
         writer = csv.writer(writeFile)
         writer.writerow([adc.read(1), adc.read(2), adc.read(3), time.strftime("%H:%M:%S", time.localtime())])
     if running_status:
         threading.Timer(.3, update_recent_readings).start()
     else:
         print("Closing files, exiting threads", flush=True)
         writeFile.close()
def read_analog_input(board):
    '''
    input parameters:
        - board: board address
    output parameters:
        - code:  maximum value of last 10 measures (in Volts, from MIN_SCALE to FULL_SCALE)
    ----------------------------
    description:
        this function reads an analog input (from -10V to 10V, but only used
        monopolar range, i.e., 0 to +10V, mapped in 0 to FULL_SCALE voltage).
    '''
    global lock
    with lock:
        selection.adc(board)
        code = adc.read()
    # remove the oldest measure of the array
    ADC_array.pop(0)
    # append new value to the array
    ADC_array.append(code)
    # complete array size to be 10 (in case of error)
    while (len(ADC_array) != 10):
        ADC_array.append(0)
    #print(ADC_array)
    #print(max(ADC_array))
    return max(ADC_array)
Example #4
0
def joystick():
    try:
        joystick_y = adc.read(1)
        joystick_x = adc.read(2)
    except:
        print("Fail PCF8591 adc module")

    if (joystick_x <= 120): pitch = (joystick_x - 120) / 120.0 * -6.5
    elif (joystick_x >= 140): pitch = (joystick_x - 140) / 115.0 * -6.5
    else: pitch = 0

    if (joystick_y <= 120): roll = (joystick_y - 120) / 120.0 * -6.5
    elif (joystick_y >= 140): roll = (joystick_y - 140) / 115.0 * -6.5
    else: roll = 0
    values = (pitch, roll)
    return values
Example #5
0
File: eq.py Project: chrisy/pfft
def read():
	# Send a reset signal
	gpio.set(24, 1)
	gpio.set(23, 1)
	gpio.set(23, 0)
	gpio.set(24, 0)

	l = []
	r = []

	for i in range(7):
		gpio.set(23, 1)
		gpio.set(23, 0)
		l.append(adc.read(2))
		r.append(adc.read(3))

	return [l, r]
Example #6
0
def sampling():
    global freq
    while True:
        value = adc.read(A1)
        freq[0] = value // 10
        freq[1] = freq[0] * 2
        freq[2] = freq[0] * 4
        sleep(50)
Example #7
0
def battery():
    try:
        value_adc = adc.read(3)
        sleep(0.01)
    except ValueError:
        print("Error adc module, voltage Battery")
    except:
        print("Error PCF8591 adc module")
    return value_adc
Example #8
0
def server_thread():
    global threadID
    threadID = threading.get_ident()
    try:
        server.listen(1)
        clientsocket, clientAddress = server.accept()
        global csocket
        global msg
        global command
        csocket = clientsocket
        print("Connection Established")
        print("Connection from : ", clientAddress)
        print(csocket.recv(1024))
        msg = "0"
        while True:
            signal.alarm(3)
            data = csocket.recv(1024)
            signal.alarm(0)
            data = data.decode()
            data,ignore1,ignore2 = data.partition("0")
            if data == 'a':
                os.kill(os.getpid(), signal.SIGUSR1)
            elif data == 'kill':
                os.kill(os.getpid(), signal.SIGINT)
                break
            elif data != "":
                print(data)
                command = data
                data = "0"
            if GPIO.input(CH1) == GPIO.HIGH:
                Burn = "0"
            else:
                Burn = "1"
            #Pre = str(round(12.12165135, 1))
            Pre = str(round(adc.read(), 1))
            data_out =""
            data_out = msg +";"+ Ign +";"+ Val +";"+ Burn +";"+ Pre +";" + ERROR + ";"
            #print(data_out)
            csocket.send(bytes(data_out,'utf-8'))
    except SocketError:
        print("EXCEPTION")
        os.kill(os.getpid(), signal.SIGINT)
    print("Connection Broken")
    threadID = 0
def read_analog_input_raw(board):
    '''
    input parameters:
        - board: board address
    output parameters:
        - code:  raw value of ADC measures (in Volts, from MIN_SCALE to FULL_SCALE)
    ----------------------------
    description:
        this function reads an analog input (from -10V to 10V, but only used
        monopolar range, i.e., 0 to +10V, mapped in 0 to FULL_SCALE voltage).
    '''
    global lock
    #global MIN_SCALE, MAX_SCALE, FULL_SCALE
    with lock:
        selection.adc(board)
        code = adc.read()
    #volts = adc.meanVolts(1000)
    #volts = adc.readVolts()
    #volts = (volts / 10) * (FULL_SCALE - MIN_SCALE)
    #return round(volts,6)
    return code
Example #10
0
 def _battery_level_calc(self, chg_state=False):
     chg = None
     if chg_state:
         chg = digitalRead(self.chg_pin)
         if chg == 0:
             chg = True
         else:
             chg = False
     val = adc.read(self.bat_sense)
     bat = val * (3.3 / 65535.0) * 1000
     if bat > 2670:
         bat_level = 100
     elif bat > 2500:
         bat_level = 50 * (bat - 2500) / 170.0
         bat_level += 50
     elif bat > 2430:
         bat_level = 20 * (bat - 2430) / 70.0
         bat_level += 30
     elif bat > 2370:
         bat_level = 20 * (bat - 2370) / 60.0
         bat_level += 10
     else:
         bat_level = 0
     return bat_level, chg
Example #11
0
        digitalWrite(LED0, HIGH)
        sleep(delay)
        digitalWrite(LED0, LOW)
        sleep(delay)


for retry in range(10):
    try:
        wifi.link(wifi_config.SSID, wifi.WIFI_WPA2, wifi_config.PASSWORD)
        break
    except Exception as e:
        on_error(100)

if not wifi.is_linked():
    on_error(200)
else:
    digitalWrite(LED0, HIGH)
    while True:
        try:
            values = []
            for i in range(200):
                values.append(clean_value(adc.read(A3)))
            requests.post(wifi_config.HOST,
                          json={
                              "min": min(values),
                              "max": max(values),
                              "avg": sum(values) / len(values)
                          })
        except Exception as e:
            print(e)
Example #12
0
################################################################################
# Toishield basic
#
# Created by VIPER Team 2015 CC
# Authors: L. Rizzello, G. Baldi,  D. Mazzei
###############################################################################

import streams
import adc
from toishield import toishield

streams.serial()

# toishield defines pin names in a board indipendent manner
# let's use them to read raw sensors values

while True:
    print(" Microphone:",adc.read(toishield.microphone_pin))
    print("      Light:",adc.read(toishield.light_pin))
    print("Temperature:",adc.read(toishield.temperature_pin))
    print("      Touch:",digitalRead(toishield.touch_pin))
    # aux pins are also accessible!
    print("       AUX1:",adc.read(toishield.aux1.ADC))
    print("-"*40)
    sleep(500)
    
# this scripts runs on every supported board, without a single change...cool isn't it? :)
Example #13
0
import adc  # 別のファイルadc.pyで宣言した関数を使えるようにする。
import RPi.GPIO as GPIO
from time import sleep

GPIO.setmode(GPIO.BCM)
adc.init()

try:
    while True:
        inputVal0 = adc.read(0)
        print(inputVal0)
        sleep(0.2)

except KeyboardInterrupt:
    pass

GPIO.cleanup()
Example #14
0
################################################################################
# Toishield basic
#
# Created by VIPER Team 2015 CC
# Authors: L. Rizzello, G. Baldi,  D. Mazzei
###############################################################################

import streams
import adc
from drivers.toishield import toishield

streams.serial()

# toishield defines pin names in a board indipendent manner
# let's use them to read raw sensors values

while True:
    print(" Microphone:",adc.read(toishield.microphone_pin))
    print("      Light:",adc.read(toishield.light_pin))
    print("Temperature:",adc.read(toishield.temperature_pin))
    print("      Touch:",digitalRead(toishield.touch_pin))
    # aux pins are also accessible!
    print("       AUX1:",adc.read(toishield.aux1.ADC))
    print("-"*40)
    sleep(500)
    
# this scripts runs on every supported board, without a single change...cool isn't it? :)
Example #15
0
streams.serial()

# save the template.html in the board flash with new_resource
new_resource("template.html")

# connect to a wifi network
try:
    cc3000.auto_init()

    print("Establishing Link...")
    wifi.link("Network-Name",wifi.WIFI_WPA2,"Wifi-Password")

    print("Ok!")
        
except Exception as e:
    print(e)


# Configure and run the ViperApp instance
vp = viperapp.ViperApp("Oscilloscope","Yeah, a javascript oscilloscope","resource://template.html")
vp.run()


while True:
    sleep(500)
    # read from adc
    x = adc.read(A4)
    # send the value to the mobile app via a notification event called "adc"
    # the notification is sent only after the mobile app to viper script link is established ;)
    vp.notify("adc",x)
Example #16
0
    # connect to the wifi network (Set your SSID and password below)
    wifi_driver.auto_init()
    for i in range(0,5):
        try:
            wifi.link("SSID",wifi.WIFI_WPA2,"PASSWORD")
            break
        except Exception as e:
            print("Can't link",e)
    else:
        print("Impossible to link!")
        while True:
            sleep(1000)

    # Start the Zerynth app instance!
    # Remember to create a template with the files under the "template" folder you just cloned
    # upload it to the ADM and associate it with the connected device
    zapp.run()
    
    # Read ADC and send values to the ADM
    while True:
        sleep(1000)
        x = (adc.read(A4)*100)//4096
        zapp.event({"data":x})
        if x>95:
            # send mobile notification
            # (there is a limit of one notification per minute per device on the ADM sandbox)
            zapp.notify("ALARM!","The value is greater than 95!")
        
except Exception as e:
    print(e)
Example #17
0
def get_y():
    y =  adc.read(thunbVry) # values from 0 to 4095
    print(y)
    return y
Example #18
0
            msg = "Opening the Valve"
            print("Opening the Valve")
            GPIO.output(CH4, GPIO.HIGH)
=======
            GPIO.output(CH2, GPIO.HIGH)
            Ign = "0"
            msg = "Opening the Valve"
            print("Opening the Valve")
            GPIO.output(CH4, GPIO.LOW)
>>>>>>> e171732815b4e2932e13c3b76866fa8df5909a59
            Val = "1"

            msg = "Waiting for pressure build"
            print("Waiting for pressure build")
            adc.set_ref_time()
            while adc.read() < 100:
                pass
            msg = "Waiting for pressure drop"
            print("Waiting for pressure drop")
            temp = adc.read()
            while temp > 70 and temp < 900:
                temp = adc.read()
                pass
            msg = "Closing the Valve"
            print("Closing the Valve")
<<<<<<< HEAD
            GPIO.output(CH4, GPIO.LOW)
=======
            GPIO.output(CH4, GPIO.HIGH)
>>>>>>> e171732815b4e2932e13c3b76866fa8df5909a59
            Val = "0"
Example #19
0
def repetibility_error(board):
    # run calibration function and get the step that should be used
    #step = calibration(2)
    # turns on DAC and ADC circuit
    dac.on(board)
    adc.on(board)
    # select DAC of the board requested
    selection.dac(board)
    dac.config()

    print "  ======================================================\n"
    from time import gmtime, strftime

    timestr = strftime("%Y-%m-%d_%H-%M-%S", gmtime())
    filename = "repetibility/" + timestr + "_error_log_file.csv"
    log = open(filename, "a+")
    # set tabs of .csv file
    log.write('Iteracao')
    log.write(';Status')
    log.write(';Horario')
    log.write(';Valor setado [LSB]')
    log.write(';Valor lido [LSB]')
    log.write(';Valor lido [V]')
    log.write(';Diferenca [LSB]')
    log.write('\n')
    # Update the file
    log.close()

    # save time when test started
    startTime = time.time()
    ############################################################
    print "  ============================================================================"
    print "  |                             REPETIBILIDADE                               |"
    print "  ============================================================================"
    print "  | DAC\t\tMULT.\t\tMULT.(LSB)\tADC\tADC(V)\t\tTEMP.|"
    print "  |--------------------------------------------------------------------------|"
    iteration = 0
    error = 0
    while (1):
        # read current time
        startTime = time.time()
        #while ((time.time() - startTime) < 1*60*60):
        points = 1024
        while ((time.time() - startTime) < 1*60*60):
            for i in range(points):
                base = int((math.sin(i*1.0/points*2*math.pi) + 1)*131071.5)
                # select DAC and write correspondent value
                selection.dac(board)
                dac.write(base)
                #time.sleep(0.01)
                selection.adc(board)
                adc_value = adc.read()
                adc_volt = float(adc_value) / 262143 * 20 - 10
                adc_volt_str = '{:.8f}'.format(adc_volt)
                # check if an error occurred
                if (abs(adc_value - base) > 100):
                    error += 1
                    print error
                    # write in log file
                    log = open(filename, "a+")
                    timestr = strftime("%Y/%m/%d_%H:%M:%S", gmtime())
                    log.write(str(iteration) + ";erro;" + timestr + ';' + str(base) + ';' + str(adc_value) + ';' + str(adc_volt) + ';' + str((adc_value - base)) + "\n")
                    # Update the file
                    log.close()
                # print data on terminal
                sys.stdout.write("  | " + str(base) + "\t" + "-----   " + "\t" + "  -----   " + "\t")
                # ---------------------------------------------------------
                sys.stdout.write(str(adc_value) + "\t")
                # ---------------------------------------------------------
                if (adc_volt < 0):
                    sys.stdout.write(str(adc_volt_str) + "\t")
                else:
                    sys.stdout.write("+" + str(adc_volt_str) + "\t")
                # ---------------------------------------------------------
                # sys.stdout.write(temp_str + "|" + "\n")
                sys.stdout.write('---\t' + "|" + "\n")
            print "  |--------------------------------------------------------------------------|"
        print "ERROR = " + str(error)
        # write in log file
        log = open(filename, "a+")
        timestr = strftime("%Y/%m/%d_%H:%M:%S", gmtime())
        log.write(str(iteration) + ";fim de ciclo;" + timestr + "\n")
        # Update the file
        log.close()
        iteration += 1
    print "ERRO = " + str(error)
        #----------Set angles servos----------#
        end_servo = bf.set_servo_values(servos_value, min_signal_degree,
                                        max_signal_degree, min_servo_signal,
                                        max_servo_signal, "online", servos)

    except ValueError:
        print(
            "\n\x1b[1;31m" +
            "Error: It isn't posible set the current position (MathDomain Error)\n"
        )
        print("\x1b[0;37m", end="")


set_plataform([0, 0, 0], [0, 0, 110])
t.sleep(1)
set_plataform([0, 0, 0], [0, 0, 114])

while True:
    joystick_y = adc.read(1)
    joystick_x = adc.read(2)

    if (joystick_x <= 120): pitch = (joystick_x - 120) / 120.0 * -6.5
    if (joystick_x >= 140): pitch = (joystick_x - 140) / 115.0 * -6.5
    if (joystick_x > 120 and joystick_x < 140): pitch = 0
    if (joystick_y <= 120): roll = (joystick_y - 120) / 120.0 * -6.5
    if (joystick_y >= 140): roll = (joystick_y - 140) / 115.0 * -6.5
    if (joystick_y > 120 and joystick_y < 140): roll = 0

    set_plataform([0, pitch, roll], [0, 0, 117])
Example #21
0
def repetibility(board):
    # select DAC of the board requested
    selection.dac(board)
    dac.config()

    print "  ======================================================\n"
    from time import gmtime, strftime

    timestr = strftime("%Y-%m-%d_%H-%M-%S", gmtime())
    filename = "repetibility/" + timestr + "_"

    tensoes = [-9, -5, 0, 5, 9]
    # total time of the test (in seconds)
    # total_time = 12*60*60
    total_time = 0.07 * 60 * 60
    # save time when test started
    startTime = time.time()
    ############################################################
    for x in tensoes:
        if (x > 0):
            log = open(filename + "+" + str(x) + "V.csv", "a+")
        else:
            log = open(filename + str(x) + "V.csv", "a+")
        # set tabs of .csv file
        log.write(';Valor lido no multimetro (V)')
        log.write(';Valor lido no multimetro (LSB)')
        log.write(';ADC - Leitura do valor integrado (V)')
        log.write(';ADC - Leitura do valor integrado (LSB)')
        log.write(';MBTemp1:Channel5 (graus C)')
        log.write('\n')
        # Update the file
        log.close()
    print "  ============================================================================"
    print "  |                             REPETIBILIDADE                               |"
    print "  ============================================================================"
    print "  | DAC\t\tMULT.\t\tMULT.(LSB)\tADC\tADC(V)\t\tTEMP.|"
    print "  |--------------------------------------------------------------------------|"
    while ((time.time() - startTime) < total_time):
        for x in tensoes:
            base = int(((x + 10) / (20 / float(262144))))
            # select DAC and write correspondent value
            selection.dac(board)
            dac.write(base)
            time.sleep(0.01)
            # ---------------------------------------------------
            if (x > 0):
                log = open(filename + "+" + str(x) + "V.csv", "a+")
            else:
                log = open(filename + str(x) + "V.csv", "a+")
            # ---------------------------------------------------
            selection.adc(board)
            adc_value = adc.read()
            '''
            measure = []
            for j in range(100):
                measure.append(adc.read())
            #	#print numpy.mean(measure)
            adc_value = sum(measure) / len(measure)
            '''
            if (abs(adc_value - base) > 1000):
                error += 1
                print error

            # adc = "{:1}".format(adc)
            # adc = numpy.mean(measure)
            adc_volt = float(adc_value) / 262143 * 20 - 10
            adc_volt_str = '{:.8f}'.format(adc_volt)
            #adc_volt_str = str(adc_volt)
            #adc_volt_str = adc_volt_str[0:adc_volt_str.find(".") + 8]
            # ---------------------------------------------------
            log.write(str(base) + ';' + ';' + str(adc_value) + ';' + str(adc_volt) + ';;')
            '''
            for j in range(100):
                log.write(str(measure[j]) + ';')
            log.write('\n')
            '''
            # Update the file
            log.close()
            # print data on terminal
            sys.stdout.write("  | " + str(base) + "\t" + "-----   " + "\t" + "  -----   " + "\t")
            # ---------------------------------------------------------
            sys.stdout.write(str(adc_value) + "\t")
            # ---------------------------------------------------------
            if (adc_volt < 0):
                sys.stdout.write(str(adc_volt_str) + "\t")
            else:
                sys.stdout.write("+" + str(adc_volt_str) + "\t")
            # ---------------------------------------------------------
            # sys.stdout.write(temp_str + "|" + "\n")
            sys.stdout.write('---\t' + "|" + "\n")
        print "  |--------------------------------------------------------------------------|"
    print "ERROR = " + str(error)
Example #22
0
# Analog Read
# 
# Created by Zerynth Team 2015 CC
# Authors: G. Baldi, D. Mazzei
################################################################################

import streams  # import the streams module
import adc      # import the adc driver 

# create a stream linked to the default serial port
streams.serial() 

while True:
    
# Basic usage of ADC for acquiring the analog signal from a pin   
    value = adc.read(A0)
    print("One sample:",value)

# The complete definition of adc.read() is adc.read(pin, samples=1) 
# For an advanced usage of adc.read refer to the official Zerynth documentation

#acquire 10 samples with default sampling period    
    value2 = adc.read(A0,10)
    print("10 samples:\n",value2)
    
#acquire 3 samples from the first 4 analog pins of the board with default sampling period    
    value3= adc.read([A0,A1,A2,A3],3)
    print("3 samples from A0, A1, A2 and A3:\n",value3)

    print()
    sleep(300)
Example #23
0
#!/usr/bin/python
from Adafruit_BBIO.SPI import SPI
import Adafruit_BBIO.GPIO as GPIO
import dac
import adc
import sys
import math
import time

#=======================================================
#	stability test
#=======================================================

dac.config()
adc.read()

from time import gmtime, strftime
timestr = strftime("%Y-%m-%d_%H-%M-%S", gmtime())
filename = "ADC stability/" + timestr + "_"

#from epics import caput
#from epics import caget
#import Agilent34420A

#voltage = [-9, -5, 0, 5, 9]
voltage = [9]
#total time of the test (in seconds)
total_measures = 10000
# defining variables for MAX, MIN and MEAN (ADC measure)
min_adc = [0] * 5
max_adc = [0] * 5
Example #24
0
#!/usr/bin/env python

import sys, math, time
import adc, eq, gpio, led

while True:
	l = int(math.fabs(adc.read(0)-512)/13)
	r = int(math.fabs(adc.read(1)-512)/13)
	sys.stdout.write("\r")
	for i in range(l):
		sys.stdout.write('#')
	for i in range(39-l):
		sys.stdout.write(' ')
	for i in range(r):
		sys.stdout.write('#')
	for i in range(39-r):
		sys.stdout.write(' ')

	sys.stdout.write(repr(eq.read())+"    ")
	
	sys.stdout.flush()
Example #25
0
################################################################################
# Analog Read to Voltage
#
# Created by Zerynth Team 2015 CC
# Authors: G. Baldi, D. Mazzei
################################################################################

import streams
import adc      # import the adc module  

#create a serial port stream with default parameters
streams.serial()

while True:
       
    #read the input on analog pin 0
    sensor_value = adc.read(A0)
    
    #convert the analog reading (which goes from 0 - 4095.0) to a voltage (0 - 3.3V):
    voltage = sensor_value * (3.3 / 4095.0)
    
    #print out the raw and converted values:
    print("sensor raw value:", sensor_value,"Voltage:",voltage)
    
    sleep(300)


Example #26
0
 def curvalue( self ):
   adc.read(self._adc, lightsensor._MUX)
Example #27
0
from libs.apps import viperapp

streams.serial()

# save the template.html in the board flash with new_resource
new_resource("template.html")

# connect to a wifi network
try:
    cc3000.auto_init()

    print("Establishing Link...")
    wifi.link("Network-Name", wifi.WIFI_WPA2, "Wifi-Password")

    print("Ok!")

except Exception as e:
    print(e)

# Configure and run the ViperApp instance
vp = viperapp.ViperApp("Oscilloscope", "Yeah, a javascript oscilloscope",
                       "resource://template.html")
vp.run()

while True:
    sleep(500)
    # read from adc
    x = adc.read(A4)
    # send the value to the mobile app via a notification event called "adc"
    # the notification is sent only after the mobile app to viper script link is established ;)
    vp.notify("adc", x)
Example #28
0
def get_x():
    x = adc.read(thunbVrx) 
    print(x)
    return x
Example #29
0
def sampling():
    global input_val
    while True:
        input_val['pot_val'] = helpers.map_range(adc.read(pot_pin),0,4000,1,1000)      
        input_val['prox_val'] = helpers.map_range(adc.read(prox_pin),300,3800,1,1000)
        sleep(50)
Example #30
0
def sampling():
    global input_val
    while True:
        input_val['pot_val'] = helpers.map_range(adc.read(pot_pin),0,4000,1,1000)      
        input_val['prox_val'] = helpers.map_range(adc.read(prox_pin),300,3800,1,1000)
        sleep(50)
Example #31
0
 def readSound(self):
     sound = adc.read(self.sndSnsr)
     multiplier = adc.read(
         self.potentiometer
     ) / 1500.0  # Al posto di 4095.0 per usare il potenziometro in posizione centrale
     return sound * multiplier
Example #32
0
###############################################################################
# Zerynth oscilloscope
#
# Created by Zerynth Team 2015 CC
# Authors: G. Baldi, D. Mazzei
###############################################################################

import streams
import adc

streams.serial()

while True:
    value = adc.read(A4)
    conv = value * 80 // 4095
    print("|", "#" * conv, " " * (80 - conv), "|")
    sleep(200)
Example #33
0
#!/usr/bin/env python

import sys, math, time
import adc, eq, gpio, led

while True:
	raw_l = adc.read(0)
	raw_r = adc.read(1)
	raw_eq = eq.read()

	l1 = 255-int(math.fabs(raw_l-512)/2)
	r1 = 255-int(math.fabs(raw_r-512)/2)

	l1 = 255
	l2 = 255

	led.led_send([l1, r1, l1])

	# l2 = (128-l1 / 2) + 128
	# r2 = (127-r1 / 2) + 128

	r = (raw_eq[0][0] + raw_eq[0][1] + raw_eq[1][0] + raw_eq[1][1]) / 4
	g = (raw_eq[0][2] + raw_eq[0][3] + raw_eq[1][2] + raw_eq[1][3]) / 4
	b = (raw_eq[0][5] + raw_eq[0][6] + raw_eq[1][5] + raw_eq[1][6]) / 4

	r = int(r/10)+128
	g = int(g/10)+128
	b = int(b/10)+128

	p = []
	for count in range(led.rgb_count):
Example #34
0
def child(Command = 0):
    while True:
        if Command == "1":
            if GPIO.input(Burn_Wire) == GPIO.HIGH:
                print("ERROR: Burn wire cut")
                os._exit(1)

            #Ignition countdown
            print("Three")
            time.sleep(1)
            print("Two")
            time.sleep(1)
            print("One")
            time.sleep(1)
            
            start_time = time.perf_counter()
            Deluge_timer = time.perf_counter()
            Deluge_on = False
            print("Start Ignition")
            while GPIO.input(Burn_Wire) == GPIO.LOW: 
                if time.perf_counter() - start_time < 10:
                    GPIO.output(Igniter, GPIO.HIGH)
                    if time.perf_counter() - Deluge_timer > 1 and Deluge_on == False:
                        print("Starting Deluge")
                        Deluge_on = True
                        GPIO.output(Deluge, GPIO.HIGH)
                else:
                    print("ERROR: Ignition timeout")
                    reset(0)
                    os._exit(1)

            print("Stopping Igniter")
            GPIO.output(Igniter, GPIO.LOW)
            print("Starting Deluge")
            GPIO.output(Deluge, GPIO.HIGH)
            #print("Time to Ignite: " + str(time.perf_counter() - start_time))
            print("Opening the Valve")
            GPIO.output(Valve, GPIO.HIGH)
            
            print("Waiting for pressure build")
            start_time = time.perf_counter()
            adc.set_ref_time()
            psi = adc.read()

            while psi < 220:
                if time.perf_counter() - start_time < 3:
                    psi = adc.read()
                else:
                    reset(0)
                    print("Pressure Build Timeout")
                    os._exit(1)
                    break

            #Reset timer
            start_time = time.perf_counter()
            print("Waiting for pressure drop")

            while psi > 200:
                if time.perf_counter() - start_time < 6 and psi < 1000:
                    psi = adc.read()
                else:
                    reset(0)
                    if psi >= 900:
                        print("Over Pressure Failure")
                    else:
                        print("Pressure Drop Timeout")
                    os._exit(1)

            print("Sequence Success: Closing the Valve")
            GPIO.output(Valve, GPIO.LOW)
            print("Command (input h for help): ")
            break

        elif Command == "2":
            print("Ignition ON")
            GPIO.output(Igniter, GPIO.HIGH)
            break

        elif Command == "3":
            print("Ignition OFF")
            GPIO.output(Igniter, GPIO.LOW)
            break

        elif Command == "4":
            print("Valve OPEN")
            GPIO.output(Valve, GPIO.HIGH)
            break

        elif Command == "5":
            print("Valve CLOSE")
            GPIO.output(Valve, GPIO.LOW)
            break

        elif Command == "6":
            print("Deluge ON")
            GPIO.output(Deluge, GPIO.HIGH)
            break

        elif Command == "7":
            print("Deluge OFF")
            GPIO.output(Deluge, GPIO.LOW)
            break
        
        elif Command == "8":
            print("Propane ON")
            GPIO.output(Propane, GPIO.HIGH)
            break

        elif Command == "9":
            print("Propane OFF")
            GPIO.output(Propane, GPIO.LOW)
            break

        elif Command == "h":
            print("1: Ignition Sequence")
            print("2: Ignition ON")
            print("3: Ignition OFF")
            print("4: Valve OPEN")
            print("5: Valve CLOSE")
            print("6: Deluge ON")
            print("7: Deluge OFF")
            print("8: Propane ON")
            print("9: Propane OFF")
            print("a: abort process")
            print("exit: exit program")
            break

        else:
            print("ERROR: invalid input")
            break
    os._exit(0)
Example #35
0
def stability(board):
    # turns on DAC and ADC circuit
    dac.on(board)
    adc.on(board)
    # set up DAC
    selection.dac(board)
    dac.config(board)

    from time import gmtime, strftime
    timestr = strftime("%Y-%m-%d_%H-%M-%S", gmtime())
    filename = "stability/" + timestr + "_"

    #from epics import caput
    #from epics import caget
    #import Agilent34420A

    voltage = [-9, -5, 0, 5, 9]
    #voltage = [9]
    #total time of the test (in seconds)
    total_measures = 10000
    # defining variables for MAX, MIN and MEAN (ADC measure)
    min_adc = [0] * 5
    max_adc = [0] * 5
    mean_adc = [0] * 5
    std_var = [0] * 5
    i = 0
    j = 0
    ############################################################
    for x in voltage:
        measure = []
        if (x > 0):
            log = open(filename + "+" + str(x) + "V.csv", "a+")
        else:
            log = open(filename + str(x) + "V.csv", "a+")
        #set tabs of .csv file
        log.write('Indice')
        log.write(';Valor lido no multimetro (V)')
        log.write(';Valor lido no multimetro (LSB)')
        log.write(';ADC - Leitura do valor integrado (V)')
        log.write(';ADC - Leitura do valor integrado (LSB)')
        log.write(';MBTemp1:Channel5 (graus C)')
        log.write('\n')
        #Update the file
        log.close()
        print "  ============================================================================"
    #    sys.stdout.write("  |                         ESTABILIDADE: ")
        sys.stdout.write("  |                           STABILITY: ")
        if(x < 0):
            sys.stdout.write(str(x) + "V" + "                                 |\n")
        elif(x > 0):
            sys.stdout.write("+" + str(x) + "V" + "                                 |\n")
        else:
            sys.stdout.write(str(x) + "V" + "                                  |\n")
        print "  ============================================================================"
        print "  | INDEX\tMULT.\t\tMULT.[LSB]\tADC\tADC(V)\t\tTEMP.|"
        print "  |--------------------------------------------------------------------------|"

        # select DAC and write correspondent value
        base = int(((x+10)/(20/float(262144))))
        selection.dac(board)
        dac.write(base)
        time.sleep(30)

        measure = []
        for i in range (total_measures):
            if (x > 0):
                log = open(filename + "+" + str(x) + "V.csv", "a+")
            else:
                log = open(filename + str(x) + "V.csv", "a+")
            #---------------------------------------------------

            selection.adc(board)
            mean_measure = []
            for k in range(3):
                mean_measure.append(adc.read())
            #    #print numpy.mean(measure)
            adc_value = sum(mean_measure) / len(mean_measure)

#            adc_value = adc.read()
            measure.append(adc_value)
            # check if it is the first measure
            if(i == 0):
                min_adc[j] = measure[0]
                max_adc[j] = measure[0]
                mean_adc[j] = measure[0]*1.0
            # if not, calculate max, min and mean
            else:
                if(measure[i] < min_adc[j]):
                    min_adc[j] = measure[i]
                if(measure[i] > max_adc[j]):
                    max_adc[j] = measure[i]
                mean_adc[j] = (mean_adc[j]*i + measure[i])/(i + 1)
            i += 1
            #adc = "{:1}".format(adc)
            #adc = numpy.mean(measure)
            adc_volt = float(adc_value)/262143*20-10
            adc_volt_str = str(adc_volt)
            adc_volt_str = adc_volt_str[0:adc_volt_str.find(".")+8]
            #---------------------------------------------------
            #Get temperature
            #temp = caget("MBTemp_RAFAEL_1:Channel5")
            #temp_str = ("%.2f" %temp)
            #temp_str = str(temp_str)
            #temp_str = temp_str[0:temp_str.find(".")+3]
            #---------------------------------------------------
            #Write all data
            #log.write(str(base+i)+ ';' + multimeter_int_str + ';' + str(multimeter_lsb) + ';' + str(adc) + ';' + str(adc_volt) + ';' + str(temp) + '\n')
            #log.write(str(base+i)+ ';' + multimeter_int_str + ';' + str(multimeter_lsb) + ';' + str(adc) + ';' + str(adc_volt) + ';' + '\n')
            #log.write(str(base+i)+ ';' + multimeter_int_str + ';' + str(multimeter_lsb) + ';' + str(adc) + ';' + str(adc_volt) + ';;')
            log.write(str(base+i)+ ';;;' + str(adc_value) + ';' + str(adc_volt) + ';;')

    #        for k in range(100):
    #            log.write(str(measure[k]) + ';')
            log.write('\n')

            #Update the file
            log.close()
            #print data on terminal
            sys.stdout.write("  | " + str(base) + "\t" + "------" + "\t\t" + "------\t" + "\t")
            #---------------------------------------------------------
            sys.stdout.write(str(adc_value) + "\t")
            #---------------------------------------------------------
            if(adc_volt < 0):
                sys.stdout.write(str(adc_volt_str) + "\t")
            else:
                sys.stdout.write("+" + str(adc_volt_str) + "\t")
            #---------------------------------------------------------
            #sys.stdout.write(temp_str + "|" + "\n")
            sys.stdout.write('---\t' + "|" + "\n")
        print "  |                                                                          |"

    #    #calculate standard deviation
    #    part_sum = 0
    #    for i in range(len(measure)):
    #        part_sum = part_sum + (measure[i] - mean_adc[j])**2
    #    std_var[j] = part_sum/(len(measure)*1.0)
    #    std_var[j] = math.sqrt(std_var[j])
    #    std_var[j] = "{0:.4f}".format(std_var[j])
    #    mean_adc[j] = "{0:.2f}".format(mean_adc[j])
        #---------------------------------------------------
        # plot and save Histogram
        std_var[j] = plot_hist(board, x, measure, mean_adc[j])
        mean_adc[j] = "{0:.2f}".format(mean_adc[j])
        print "  ============================================================================"
        #---------------------------------------------------
        # print standard variation
        sys.stdout.write("  |    std_dev  = %s" %str(std_var[j]))
        for i in range (0, (6 - len(str(std_var[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('      |\n')
        #-------------------------------------------------------
        # print minimum value acquired
        sys.stdout.write("  |    ADC_min  = %s" %min_adc[j])
        for i in range (0, (6 - len(str(min_adc[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('      |\n')
        #---------------------------------------------------
        # print maximum value acquired
        sys.stdout.write("  |    ADC_max  = %s" %max_adc[j])
        for i in range (0, (6 - len(str(max_adc[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('      |\n')
        #---------------------------------------------------
        # print mean
        sys.stdout.write("  |    ADC_mean = %s" %mean_adc[j])
        for i in range (0, (6 - len(str(mean_adc[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('   |\n')
        #---------------------------------------------------
        # print difference between max and min (histogram thickness)
        sys.stdout.write("  |        diff = %s" %(max_adc[j] - min_adc[j]))
        for i in range (0, (6 - len(str(max_adc[j] - min_adc[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('      |\n')
        #---------------------------------------------------
        print "  ============================="
        j += 1

    # Print it all again after all the data were acquired
    j = 0
    for x in voltage:
        sys.stdout.write("  |       STABILITY: ")
        if(x > 0):
            sys.stdout.write("+")
        if(x == 0):
            sys.stdout.write(" ")
        sys.stdout.write(str(x) + "V      |\n")
        print "  ============================="
        #---------------------------------------------------
        # print standard variation
        sys.stdout.write("  |    std_dev  = %s" %str(std_var[j]))
        for i in range (0, (6 - len(str(std_var[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('      |\n')
        #-------------------------------------------------------
        # print minimum value acquired
        sys.stdout.write("  |    ADC_min  = %s" %min_adc[j])
        for i in range (0, (6 - len(str(min_adc[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('      |\n')
        #---------------------------------------------------
        # print maximum value acquired
        sys.stdout.write("  |    ADC_max  = %s" %max_adc[j])
        for i in range (0, (6 - len(str(max_adc[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('      |\n')
        #---------------------------------------------------
        # print mean
        sys.stdout.write("  |    ADC_mean = %s" %mean_adc[j])
        for i in range (0, (6 - len(str(mean_adc[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('   |\n')
        #---------------------------------------------------
        # print difference between max and min (histogram thickness)
        sys.stdout.write("  |        diff = %s" %(max_adc[j] - min_adc[j]))
        for i in range (0, (6 - len(str(max_adc[j] - min_adc[j])))):
            sys.stdout.write(' ')
        sys.stdout.write('      |\n')
        #---------------------------------------------------
        print "  ============================="
        j += 1
Example #36
0
# PotLED
# Created at 2018-06-27 06:32:46.299130



import streams  # import the streams module
import adc
streams.serial() 
led_1 = D11
pinMode(led_1, OUTPUT)
while True:
    a = adc.read(A2)
    print(a)
    if a<512 :
        print("ON")
        digitalWrite(led_1,HIGH)   # turn the LED ON by making the voltage HIGH
        sleep(1000)            # wait for timeON
    else:
        print("OFF")
        digitalWrite(led_1,LOW)    # turn the LED OFF by making the voltage LOW
        sleep(1000)           # wait for timeOFF
    
    print("One sample:",a)
    print()
    sleep(300)
Example #37
0
            print("connecting...")
    print("connected.")

    #aqui o ESP8266 assina os tópicos abaixo
    client.subscribe([["desktop/samples", 1]])
    client.subscribe([["desktop/others", 2]])

    #habilita a publicação de dados
    client.on(mqtt.PUBLISH, print_sample, is_sample)

    client.loop(print_other)

    #dentro desse loop medimos a tensão que o sensor fornece para entrada analógica do ESP8266 e convertemos num valor de temperatura.
    while True:
        sleep(3000)
        value = adc.read(A0)
        print(value)
        Vout = (value * VCC) / adcRes
        Rth = (VCC * R2 / Vout) - R2
        temperature = (1 / (A + (B * math.log(Rth)) + (C * math.pow(
            (math.log(Rth)), 3))))
        temperature = temperature - 292.15
        temperature = -1 * (temperature)

        #printamos o valor pela serial e logo em seguida enviamos o valor calculado para o Broker MQTT Mosquitto
        print(temperature)
        send_sample(temperature)
        if temperature % 10 == 0:
            publish_to_self(
            )  #caso ocorra alguma exceção ou erro, a temperatura publicada é um valor aleatório de 0 a 10
except Exception as e: