alexey.zholtikov/upm
1
0
Fork 0
mirror of https://github.com/eclipse/upm.git synced 2025-03-24 17:30:01 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

python_examples: Reformatted, self-checking, executable

Browse Source 
* Moved body of each python example to main.  This allows for basic
      load module testing for CI
    * General cleanup of python modules (crlf/tabs/prints/etc)
    * Chmod'ed to 755 to allow running examples without specifying the
      python interpreter
    * Added ctest for loading python2/3 modules
    * Added jniclasscode pragma for java swig interface files.
    * Updated check_examplenames.py module to check all languages vs. a
      cxx example name
    * Added tests for checking python module and test loading
    * Added 'make test' to travis-ci run (run ctests)
    * Print a more meaningful message when not building cxx docs into
      python modules
    * Updated check_clean.py to only check java wrapper files
    * ENABLED ctests for UPM
    * Deleted using_carrays.py python example - this is covered by other
      examples

Signed-off-by: Noel Eck <noel.eck@intel.com>
This commit is contained in:
Noel Eck 2016-09-29 18:24:19 -07:00
parent 62718daf0b
commit 2f78d9f62b
203 changed files with 5890 additions and 5216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.travis.yml
View File

@ -33,8 +33,10 @@ before_script:
script: script:
- echo "CC=$CC BUILDJAVA=$BUILDJAVA NODE010=$NODE010 NODE012=$NODE012 NODE4=$NODE4 NODE5=$NODE5 NODE_ROOT_DIR=$NODE_ROOT_DIR" - echo "CC=$CC BUILDJAVA=$BUILDJAVA NODE010=$NODE010 NODE012=$NODE012 NODE4=$NODE4 NODE5=$NODE5 NODE_ROOT_DIR=$NODE_ROOT_DIR"
- git clone https://github.com/intel-iot-devkit/mraa.git $MRAA_ROOT - git clone https://github.com/intel-iot-devkit/mraa.git $MRAA_ROOT
- mkdir -p $MRAA_BUILD && cd $_ && cmake -DBUILDSWIGJAVA=$BUILDJAVA -DBUILDSWIGNODE=OFF -DBUILDSWIGPYTHON=OFF -DFIRMATA=ON -DENABLEEXAMPLES=OFF -DCMAKE_INSTALL_PREFIX:PATH=$MRAA_INSTALL $MRAA_ROOT && make install - mkdir -p $MRAA_BUILD && cd $_ && cmake -DBUILDSWIGJAVA=$BUILDJAVA -DBUILDSWIGNODE=OFF -DBUILDSWIGPYTHON=ON -DFIRMATA=ON -DENABLEEXAMPLES=OFF -DCMAKE_INSTALL_PREFIX:PATH=$MRAA_INSTALL $MRAA_ROOT && make install
- cd $UPM_ROOT && mkdir $UPM_BUILD && cd $_ && PKG_CONFIG_PATH=$MRAA_INSTALL/lib/pkgconfig cmake -DNODE_ROOT_DIR:PATH="${NODE_ROOT_DIR}" -DBUILDSWIGJAVA=$BUILDJAVA -DBUILDEXAMPLES=ON -DBUILDJAVAEXAMPLES=$BUILDJAVA -DCMAKE_INSTALL_PREFIX:PATH=$UPM_INSTALL .. && make install - cd $UPM_ROOT && mkdir $UPM_BUILD && cd $_ && PKG_CONFIG_PATH=$MRAA_INSTALL/lib/pkgconfig cmake -DNODE_ROOT_DIR:PATH="${NODE_ROOT_DIR}" -DBUILDSWIGJAVA=$BUILDJAVA -DBUILDEXAMPLES=ON -DBUILDJAVAEXAMPLES=$BUILDJAVA -DBUILDTESTS=ON -DCMAKE_INSTALL_PREFIX:PATH=$UPM_INSTALL ..
- make install
- LD_LIBRARY_PATH=$MRAA_INSTALL/lib:$UPM_INSTALL/lib:$LD_LIBRARY_PATH PYTHONPATH=$UPM_INSTALL/lib/python2.7/site-packages/:$MRAA_INSTALL/lib/python2.7/dist-packages/ ctest --output-on-failure -E examplenames_js
addons: addons:
apt: apt:
sources: sources:

145
doxy/samples.mapping.txt
View File

@ -1,73 +1,72 @@
# Mapping C++ sample files to Java sample files # Mapping examples across provided languages
a110x-intr.cxx A110X_intrSample.java a110x.cxx A110XSample.java a110x.js a110x.py
a110x.cxx A110XSample.java a110x-intr.cxx A110X_intrSample.java a110x-intr.js a110x-intr.py
adc121c021.cxx ADC121C021Sample.java adc121c021.cxx ADC121C021Sample.java adc121c021.js adc121c021.py
adxl345.cxx Adxl345Sample.java adxl345.cxx Adxl345Sample.java adxl345.js adxl345.py
biss0001.cxx BISS0001Sample.java biss0001.cxx BISS0001Sample.java biss0001.js biss0001.py
bmpx8x.cxx BMPX8XSample.java bmpx8x.cxx BMPX8XSample.java bmpx8x.js bmpx8x.py
buzzer-sound.cxx Buzzer_soundSample.java button.cxx ButtonSample.java button.js button.py
cjq4435.cxx CJQ4435Sample.java buzzer-sound.cxx Buzzer_soundSample.java buzzer-sound.js buzzer-sound.py
ds1307.cxx DS1307Sample.java cjq4435.cxx CJQ4435Sample.java cjq4435.js cjq4435.py
enc03r.cxx ENC03RSample.java ds1307.cxx DS1307Sample.java ds1307.js ds1307.py
es08a.cxx ES08ASample.java enc03r.cxx ENC03RSample.java enc03r.js enc03r.py
button.cxx ButtonSample.java es08a.cxx ES08ASample.java es08a.js es08a.py
groveehr.cxx GroveEHRSample.java groveehr.cxx GroveEHRSample.java groveehr.js groveehr.py
groveled.cxx GroveLEDSample.java groveledbar.cxx GroveLEDBar.java groveledbar.js groveledbar.py
grovelinefinder.cxx GroveLineFinderSample.java groveled.cxx GroveLEDSample.java groveled.js groveled.py
light.cxx LightSample.java grovelinefinder.cxx GroveLineFinderSample.java grovelinefinder.js grovelinefinder.py
grovemoisture.cxx GroveMoistureSample.java grovemoisture.cxx GroveMoistureSample.java grovemoisture.js grovemoisture.py
relay.cxx RelaySample.java grovescam.cxx GROVESCAMSample.java grovescam.js grovescam.py
rotary.cxx RotarySample.java grovewfs.cxx GroveWFSSample.java grovewfs.js grovewfs.py
grovescam.cxx GROVESCAMSample.java guvas12d.cxx GUVAS12DSample.java guvas12d.js guvas12d.py
slide.cxx SlideSample.java h3lis331dl.cxx H3LIS331DLSample.java h3lis331dl.js h3lis331dl.py
speaker.cxx SpeakerSample.java hcsr04.cxx HCSR04Sample.java hcsr04.js hcsr04.py
vdiv.cxx VDivSample.java hm11.cxx HM11Sample.java hm11.js hm11.py
water.cxx WaterSample.java hmc5883l.cxx Hmc5883lSample.java hmc5883l.js hmc5883l.py
grovewfs.cxx GroveWFSSample.java htu21d.cxx HTU21DSample.java htu21d.js htu21d.py
guvas12d.cxx GUVAS12DSample.java itg3200.cxx Itg3200Sample.java itg3200.js itg3200.py
h3lis331dl.cxx H3LIS331DLSample.java jhd1313m1-lcd.cxx Jhd1313m1_lcdSample.java jhd1313m1-lcd.js jhd1313m1-lcd.py
hcsr04.cxx HCSR04Sample.java joystick12.cxx Joystick12Sample.java joystick12.js joystick12.py
hm11.cxx HM11Sample.java lcm1602-i2c.cxx Lcm1602_i2cSample.java lcm1602-i2c.js lcm1602-i2c.py
hmc5883l.cxx Hmc5883lSample.java ldt0028.cxx LDT0028Sample.java ldt0028.js ldt0028.py
htu21d.cxx HTU21DSample.java light.cxx LightSample.java light.js light.py
itg3200.cxx Itg3200Sample.java lol.cxx LoLSample.java lol.js lol.py
jhd1313m1-lcd.cxx Jhd1313m1_lcdSample.java lsm303.cxx LSM303Sample.java lsm303.js lsm303.py
joystick12.cxx Joystick12Sample.java m24lr64e.cxx M24LR64ESample.java m24lr64e.js m24lr64e.py
lcm1602-i2c.cxx Lcm1602_i2cSample.java max44000.cxx MAX44000Sample.java max44000.js max44000.py
ldt0028.cxx LDT0028Sample.java mic.cxx MicrophoneSample.java mic.js mic.py
lol.cxx LoLSample.java mma7455.cxx MMA7455Sample.java mma7455.js mma7455.py
lsm303.cxx LSM303Sample.java mma7660.cxx MMA7660Sample.java mma7660.js mma7660.py
m24lr64e.cxx M24LR64ESample.java mpl3115a2.cxx MPL3115A2Sample.java mpl3115a2.js mpl3115a2.py
max44000.cxx MAX44000Sample.java mpr121.cxx MPR121Sample.java mpr121.js mpr121.py
mic.cxx MicrophoneSample.java mpu9150.cxx MPU9150Sample.java mpu9150.js mpu9150.py
mma7455.cxx MMA7455Sample.java mq2.cxx MQ2Sample.java mq2.js mq2.py
mma7660.cxx MMA7660Sample.java mq303a.cxx MQ303ASample.java mq303a.js mq303a.py
mpl3115a2.cxx MPL3115A2Sample.java mq5.cxx MQ5Sample.java mq5.js mq5.py
mpr121.cxx MPR121Sample.java nrf24l01-receiver.cxx NRF24L01_receiverSample.java nrf24l01-receiver.js nrf24l01-receiver.py
mpu9150.cxx MPU9150Sample.java nrf24l01-transmitter.cxx NRF24L01_transmitterSample.java nrf24l01-transmitter.js nrf24l01-transmitter.py
mq2.cxx MQ2Sample.java nunchuck.cxx NUNCHUCKSample.java nunchuck.js nunchuck.py
mq303a.cxx MQ303ASample.java otp538u.cxx OTP538USample.java otp538u.js otp538u.py
mq5.cxx MQ5Sample.java ppd42ns.cxx PPD42NSSample.java ppd42ns.js ppd42ns.py
groveledbar GroveLEDBar pulsensor.cxx PulsensorSample.java pulsensor.js pulsensor.py
nrf24l01-receiver.cxx NRF24L01_receiverSample.java relay.cxx RelaySample.java relay.js relay.py
nrf24l01-transmitter.cxx NRF24L01_transmitterSample.java rfr359f.cxx RFR359FSample.java rfr359f.js rfr359f.py
nunchuck.cxx NUNCHUCKSample.java rotary.cxx RotarySample.java rotary.js rotary.py
otp538u.cxx OTP538USample.java rotaryencoder.cxx RotaryEncoderSample.java rotaryencoder.js rotaryencoder.py
ppd42ns.cxx PPD42NSSample.java rpr220.cxx RPR220Sample.java rpr220.js rpr220.py
pulsensor.cxx PulsensorSample.java rpr220-intr.cxx RPR220_intrSample.java rpr220-intr.js rpr220-intr.py
rfr359f.cxx RFR359FSample.java slide.cxx SlideSample.java slide.js slide.py
rotaryencoder.cxx RotaryEncoderSample.java speaker.cxx SpeakerSample.java speaker.js speaker.py
rpr220-intr.cxx RPR220_intrSample.java ssd1308-oled.cxx SSD1308_oledSample.java ssd1308-oled.js ssd1308-oled.py
rpr220.cxx RPR220Sample.java ssd1327-oled.cxx SSD1327_oledSample.java ssd1327-oled.js ssd1327-oled.py
ssd1308-oled.cxx SSD1308_oledSample.java st7735.cxx ST7735Sample.java st7735.js st7735.py
ssd1327-oled.cxx SSD1327_oledSample.java stepmotor.cxx StepMotorSample.java stepmotor.js stepmotor.py
st7735.cxx ST7735Sample.java tm1637.cxx TM1637Sample.java tm1637.js tm1637.py
stepmotor.cxx StepMotorSample.java tp401.cxx TP401Sample.java tp401.js tp401.py
tm1637.cxx TM1637Sample.java tsl2561.cxx TSL2561Sample.java tsl2561.js tsl2561.py
tp401.cxx TP401Sample.java ttp223.cxx TTP223Sample.java ttp223.js ttp223.py
tsl2561.cxx TSL2561Sample.java uln200xa.cxx ULN200XASample.java uln200xa.js uln200xa.py
ttp223.cxx TTP223Sample.java vdiv.cxx VDivSample.java vdiv.js vdiv.py
ublox6.cxx Ublox6Sample.java water.cxx WaterSample.java water.js water.py
uln200xa.cxx ULN200XASample.java wt5001.cxx WT5001Sample.java wt5001.js wt5001.py
wt5001.cxx WT5001Sample.java yg1006.cxx YG1006Sample.java yg1006.js yg1006.py
yg1006.cxx YG1006Sample.java

28
examples/python/a110x.py Normal file → Executable file
View File

@ -24,28 +24,30 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_a110x as upmA110x import pyupm_a110x as upmA110x
# Instantiate a Hall Effect magnet sensor on digital pin D2 def main():
myHallEffectSensor = upmA110x.A110X(2) # Instantiate a Hall Effect magnet sensor on digital pin D2
myHallEffectSensor = upmA110x.A110X(2)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myHallEffectSensor # This function lets you run code on exit, including functions from myHallEffectSensor
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while(1):
while(1):
if (myHallEffectSensor.magnetDetected()): if (myHallEffectSensor.magnetDetected()):
print "Magnet (south polarity) detected." print "Magnet (south polarity) detected."
else: else:
print "No magnet detected." print "No magnet detected."
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

40
examples/python/ad8232.py Normal file → Executable file
View File

@ -24,31 +24,33 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ad8232 as upmAD8232 import pyupm_ad8232 as upmAD8232
# Instantiate a AD8232 sensor on digital pins 10 (LO+), 11 (LO-) def main():
# and an analog pin, 0 (OUTPUT) # Instantiate a AD8232 sensor on digital pins 10 (LO+), 11 (LO-)
myAD8232 = upmAD8232.AD8232(10, 11, 0) # and an analog pin, 0 (OUTPUT)
myAD8232 = upmAD8232.AD8232(10, 11, 0)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myAD8232 # This function lets you run code on exit, including functions from myAD8232
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Output the raw numbers from the ADC, for plotting elsewhere.
# Output the raw numbers from the ADC, for plotting elsewhere. # A return of 0 indicates a Lead Off (LO) condition.
# A return of 0 indicates a Lead Off (LO) condition. # In theory, this data could be fed to software like Processing
# In theory, this data could be fed to software like Processing # (https://www.processing.org/) to plot the data just like an
# (https://www.processing.org/) to plot the data just like an # EKG you would see in a hospital.
# EKG you would see in a hospital. while(1):
while(1):
print myAD8232.value() print myAD8232.value()
time.sleep(.001) time.sleep(.001)
if __name__ == '__main__':
main()

82
examples/python/adafruitms1438-stepper.py Normal file → Executable file
View File

@ -24,65 +24,65 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_adafruitms1438 as upmAdafruitms1438 import pyupm_adafruitms1438 as upmAdafruitms1438
def main():
# Import header values
I2CBus = upmAdafruitms1438.ADAFRUITMS1438_I2C_BUS
I2CAddr = upmAdafruitms1438.ADAFRUITMS1438_DEFAULT_I2C_ADDR
# Import header values M12Motor = upmAdafruitms1438.AdafruitMS1438.STEPMOTOR_M12
I2CBus = upmAdafruitms1438.ADAFRUITMS1438_I2C_BUS MotorDirCW = upmAdafruitms1438.AdafruitMS1438.DIR_CW
I2CAddr = upmAdafruitms1438.ADAFRUITMS1438_DEFAULT_I2C_ADDR MotorDirCCW = upmAdafruitms1438.AdafruitMS1438.DIR_CCW
M12Motor = upmAdafruitms1438.AdafruitMS1438.STEPMOTOR_M12 # Instantiate an Adafruit MS 1438 on I2C bus 0
MotorDirCW = upmAdafruitms1438.AdafruitMS1438.DIR_CW myMotorShield = upmAdafruitms1438.AdafruitMS1438(I2CBus, I2CAddr)
MotorDirCCW = upmAdafruitms1438.AdafruitMS1438.DIR_CCW
## Exit handlers ##
# Instantiate an Adafruit MS 1438 on I2C bus 0 # This stops python from printing a stacktrace when you hit control-C
myMotorShield = upmAdafruitms1438.AdafruitMS1438(I2CBus, I2CAddr) def SIGINTHandler(signum, frame):
## Exit handlers ##
# This stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, # This function lets you run code on exit,
# including functions from myMotorShield # including functions from myMotorShield
def exitHandler(): def exitHandler():
myMotorShield.disableStepper(M12Motor) myMotorShield.disableStepper(M12Motor)
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Setup for use with a stepper motor connected to the M1 & M2 ports
# Setup for use with a stepper motor connected to the M1 & M2 ports # set a PWM period of 50Hz
# set a PWM period of 50Hz # disable first, to be safe
myMotorShield.disableStepper(M12Motor)
# disable first, to be safe # configure for a NEMA-17, 200 steps per revolution
myMotorShield.disableStepper(M12Motor) myMotorShield.stepConfig(M12Motor, 200)
# configure for a NEMA-17, 200 steps per revolution # set speed at 10 RPM's
myMotorShield.stepConfig(M12Motor, 200) myMotorShield.setStepperSpeed(M12Motor, 10);
myMotorShield.setStepperDirection(M12Motor, MotorDirCW)
# set speed at 10 RPM's # enable
myMotorShield.setStepperSpeed(M12Motor, 10); print "Enabling..."
myMotorShield.setStepperDirection(M12Motor, MotorDirCW) myMotorShield.enableStepper(M12Motor)
# enable print "Rotating 1 full revolution at 10 RPM speed."
print "Enabling..." myMotorShield.stepperSteps(M12Motor, 200)
myMotorShield.enableStepper(M12Motor)
print "Rotating 1 full revolution at 10 RPM speed." print "Sleeping for 2 seconds..."
myMotorShield.stepperSteps(M12Motor, 200) time.sleep(2)
print "Rotating 1/2 revolution in opposite direction at 10 RPM speed."
print "Sleeping for 2 seconds..." myMotorShield.setStepperDirection(M12Motor, MotorDirCCW)
time.sleep(2) myMotorShield.stepperSteps(M12Motor, 100)
print "Rotating 1/2 revolution in opposite direction at 10 RPM speed."
myMotorShield.setStepperDirection(M12Motor, MotorDirCCW) print "Disabling..."
myMotorShield.stepperSteps(M12Motor, 100)
print "Disabling..." # exitHandler runs automatically
# exitHandler runs automatically if __name__ == '__main__':
main()

74
examples/python/adafruitms1438.py Normal file → Executable file
View File

@ -24,60 +24,60 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_adafruitms1438 as upmAdafruitms1438 import pyupm_adafruitms1438 as upmAdafruitms1438
def main():
# Import header values
I2CBus = upmAdafruitms1438.ADAFRUITMS1438_I2C_BUS
I2CAddr = upmAdafruitms1438.ADAFRUITMS1438_DEFAULT_I2C_ADDR
# Import header values M3Motor = upmAdafruitms1438.AdafruitMS1438.MOTOR_M3
I2CBus = upmAdafruitms1438.ADAFRUITMS1438_I2C_BUS MotorDirCW = upmAdafruitms1438.AdafruitMS1438.DIR_CW
I2CAddr = upmAdafruitms1438.ADAFRUITMS1438_DEFAULT_I2C_ADDR MotorDirCCW = upmAdafruitms1438.AdafruitMS1438.DIR_CCW
M3Motor = upmAdafruitms1438.AdafruitMS1438.MOTOR_M3 # Instantiate an Adafruit MS 1438 on I2C bus 0
MotorDirCW = upmAdafruitms1438.AdafruitMS1438.DIR_CW myMotorShield = upmAdafruitms1438.AdafruitMS1438(I2CBus, I2CAddr)
MotorDirCCW = upmAdafruitms1438.AdafruitMS1438.DIR_CCW
## Exit handlers ##
# Instantiate an Adafruit MS 1438 on I2C bus 0 # This stops python from printing a stacktrace when you hit control-C
myMotorShield = upmAdafruitms1438.AdafruitMS1438(I2CBus, I2CAddr) def SIGINTHandler(signum, frame):
## Exit handlers ##
# This stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, # This function lets you run code on exit,
# including functions from myMotorShield # including functions from myMotorShield
def exitHandler(): def exitHandler():
myMotorShield.disableMotor(M3Motor) myMotorShield.disableMotor(M3Motor)
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Setup for use with a DC motor connected to the M3 port
# Setup for use with a DC motor connected to the M3 port # set a PWM period of 50Hz
myMotorShield.setPWMPeriod(50)
# set a PWM period of 50Hz # disable first, to be safe
myMotorShield.setPWMPeriod(50) myMotorShield.disableMotor(M3Motor)
# disable first, to be safe # set speed at 50%
myMotorShield.disableMotor(M3Motor) myMotorShield.setMotorSpeed(M3Motor, 50)
myMotorShield.setMotorDirection(M3Motor, MotorDirCW)
# set speed at 50% print ("Spin M3 at half speed for 3 seconds, "
myMotorShield.setMotorSpeed(M3Motor, 50) "then reverse for 3 seconds.")
myMotorShield.setMotorDirection(M3Motor, MotorDirCW) myMotorShield.enableMotor(M3Motor)
print ("Spin M3 at half speed for 3 seconds, " time.sleep(3)
"then reverse for 3 seconds.")
myMotorShield.enableMotor(M3Motor)
time.sleep(3) print "Reversing M3"
myMotorShield.setMotorDirection(M3Motor, MotorDirCCW)
print "Reversing M3" time.sleep(3)
myMotorShield.setMotorDirection(M3Motor, MotorDirCCW)
time.sleep(3) print "Stopping M3"
print "Stopping M3" # exitHandler runs automatically
# exitHandler runs automatically if __name__ == '__main__':
main()

36
examples/python/adc121c021.py Normal file → Executable file
View File

@ -24,32 +24,34 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_adc121c021 as upmAdc121c021 import pyupm_adc121c021 as upmAdc121c021
# Instantiate an ADC121C021 on I2C bus 0 def main():
busID = upmAdc121c021.ADC121C021_I2C_BUS # Instantiate an ADC121C021 on I2C bus 0
I2CAddr = upmAdc121c021.ADC121C021_DEFAULT_I2C_ADDR busID = upmAdc121c021.ADC121C021_I2C_BUS
I2CAddr = upmAdc121c021.ADC121C021_DEFAULT_I2C_ADDR
myAnalogDigitalConv = upmAdc121c021.ADC121C021(busID, I2CAddr) myAnalogDigitalConv = upmAdc121c021.ADC121C021(busID, I2CAddr)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myAnalogDigitalConv # including functions from myAnalogDigitalConv
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# get the data every 50 milliseconds
# get the data every 50 milliseconds while(1):
while(1):
val = myAnalogDigitalConv.value() val = myAnalogDigitalConv.value()
voltsVal = myAnalogDigitalConv.valueToVolts(val) voltsVal = myAnalogDigitalConv.valueToVolts(val)
print "ADC value: %s Volts = %s" % (val, voltsVal) print "ADC value: %s Volts = %s" % (val, voltsVal)
time.sleep(.05) time.sleep(.05)
if __name__ == '__main__':
main()

50
examples/python/adxl335.py Normal file → Executable file
View File

@ -24,41 +24,40 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_adxl335 as upmAdxl335 import pyupm_adxl335 as upmAdxl335
myAnalogAccel = upmAdxl335.ADXL335(0, 1, 2) def main():
myAnalogAccel = upmAdxl335.ADXL335(0, 1, 2)
print "Please make sure the sensor is completely still." print "Please make sure the sensor is completely still."
print "Sleeping for 2 seconds" print "Sleeping for 2 seconds"
time.sleep(2) time.sleep(2)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, # This function lets you run code on exit,
# including functions from myAnalogAccel # including functions from myAnalogAccel
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Calibrating..."
myAnalogAccel.calibrate()
print "Calibrating..." x = upmAdxl335.new_intPointer()
myAnalogAccel.calibrate() y = upmAdxl335.new_intPointer()
z = upmAdxl335.new_intPointer()
x = upmAdxl335.new_intPointer() aX = upmAdxl335.new_floatPointer()
y = upmAdxl335.new_intPointer() aY = upmAdxl335.new_floatPointer()
z = upmAdxl335.new_intPointer() aZ = upmAdxl335.new_floatPointer()
aX = upmAdxl335.new_floatPointer() while (1):
aY = upmAdxl335.new_floatPointer()
aZ = upmAdxl335.new_floatPointer()
while (1):
myAnalogAccel.values(x, y, z) myAnalogAccel.values(x, y, z)
outputStr = "Raw Values: X: {0} Y: {1} Z: {2}".format( outputStr = "Raw Values: X: {0} Y: {1} Z: {2}".format(
upmAdxl335.intPointer_value(x), upmAdxl335.intPointer_value(y), upmAdxl335.intPointer_value(x), upmAdxl335.intPointer_value(y),
@ -76,3 +75,6 @@ while (1):
print " " print " "
time.sleep(.2) time.sleep(.2)
if __name__ == '__main__':
main()

13
examples/python/adxl345.py Normal file → Executable file
View File

@ -23,12 +23,12 @@
from time import sleep from time import sleep
import pyupm_adxl345 as adxl345 import pyupm_adxl345 as adxl345
# Create an I2C accelerometer object def main():
adxl = adxl345.Adxl345(0) # Create an I2C accelerometer object
adxl = adxl345.Adxl345(0)
# Loop indefinitely
while True:
# Loop indefinitely
while True:
adxl.update() # Update the data adxl.update() # Update the data
raw = adxl.getRawValues() # Read raw sensor data raw = adxl.getRawValues() # Read raw sensor data
force = adxl.getAcceleration() # Read acceleration force (g) force = adxl.getAcceleration() # Read acceleration force (g)
@ -39,3 +39,6 @@ while True:
# Sleep for 1 s # Sleep for 1 s
sleep(1) sleep(1)
if __name__ == '__main__':
main()

38
examples/python/adxrs610.py Normal file → Executable file
View File

@ -24,32 +24,36 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_adxrs610 as sensorObj import pyupm_adxrs610 as sensorObj
# Instantiate a ADXRS610 sensor on analog pin A0 (dataout), and def main():
# analog A1 (temp out) with an analog reference voltage of # Instantiate a ADXRS610 sensor on analog pin A0 (dataout), and
# 5.0 # analog A1 (temp out) with an analog reference voltage of
sensor = sensorObj.ADXRS610(0, 1, 5.0) # 5.0
sensor = sensorObj.ADXRS610(0, 1, 5.0)
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# set a deadband region around the zero point to report 0.0 (optional) # set a deadband region around the zero point to report 0.0 (optional)
sensor.setDeadband(0.015); sensor.setDeadband(0.015);
# Every tenth of a second, sample the ADXRS610 and output it's # Every tenth of a second, sample the ADXRS610 and output it's
# corresponding temperature and angular velocity # corresponding temperature and angular velocity
while (1): while (1):
print "Vel (deg/s):", sensor.getAngularVelocity() print "Vel (deg/s):", sensor.getAngularVelocity()
print "Temp (C):", sensor.getTemperature() print "Temp (C):", sensor.getTemperature()
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

77
examples/python/aeotecdsb09104.py Normal file → Executable file
View File

@ -24,65 +24,50 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ozw as sensorObj import pyupm_ozw as sensorObj
# This function lets you run code on exit def main():
def exitHandler(): # This function lets you run code on exit
def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
defaultDev = "/dev/ttyACM0" defaultDev = "/dev/ttyACM0"
if (len(sys.argv) > 1): if (len(sys.argv) > 1):
defaultDev = sys.argv[1] defaultDev = sys.argv[1]
print "Using device", defaultDev print "Using device", defaultDev
# Instantiate an Aeotec DSB09104 instance, on device node 12. You # Instantiate an Aeotec DSB09104 instance, on device node 12. You
# will almost certainly need to change this to reflect your own # will almost certainly need to change this to reflect your own
# network. Use the ozwdump example to see what nodes are available. # network. Use the ozwdump example to see what nodes are available.
sensor = sensorObj.AeotecDSB09104(12) sensor = sensorObj.AeotecDSB09104(12)
# The first thing to do is create options, then lock them when done. # The first thing to do is create options, then lock them when done.
sensor.optionsCreate() sensor.optionsCreate()
sensor.optionsLock() sensor.optionsLock()
# Next, initialize it. # Next, initialize it.
print "Initializing, this may take awhile depending on your ZWave network" print "Initializing, this may take awhile depending on your ZWave network"
sensor.init(defaultDev) sensor.init(defaultDev)
print "Initialization complete" print "Initialization complete"
print "Querying data..." print "Querying data..."
while (True): while (True):
sensor.update() sensor.update()
print "Watts, Channel 1:", print "Watts, Channel 1: %0.03f W" % sensor.getWattsC1()
print sensor.getWattsC1(), print "Watts, Channel 2: %0.03f W" % sensor.getWattsC2()
print "W" print "Watts, Channel 3: %0.03f W" % sensor.getWattsC3()
print "Watts, Channel 2:", print "Energy, Channel 1: %0.03f kWh" % sensor.getEnergyC1()
print sensor.getWattsC2(), print "Energy, Channel 2: %0.03f kWh" % sensor.getEnergyC2()
print "W" print "Energy, Channel 3: %0.03f kWh" % sensor.getEnergyC3()
print "Watts, Channel 3:", print "Battery Level: %d\n" % sensor.getBatteryLevel()
print sensor.getWattsC3(),
print "W"
print "Energy, Channel 1:",
print sensor.getEnergyC1(),
print "kWh"
print "Energy, Channel 2:",
print sensor.getEnergyC2(),
print "kWh"
print "Energy, Channel 3:",
print sensor.getEnergyC3(),
print "kWh"
print "Battery Level:",
print sensor.getBatteryLevel(),
print "%"
print
time.sleep(3) time.sleep(3)
if __name__ == '__main__':
main()

48
examples/python/aeotecdw2e.py Normal file → Executable file
View File

@ -24,39 +24,39 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ozw as sensorObj import pyupm_ozw as sensorObj
# This function lets you run code on exit def main():
def exitHandler(): # This function lets you run code on exit
def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
defaultDev = "/dev/ttyACM0" defaultDev = "/dev/ttyACM0"
if (len(sys.argv) > 1): if (len(sys.argv) > 1):
defaultDev = sys.argv[1] defaultDev = sys.argv[1]
print "Using device", defaultDev print "Using device", defaultDev
# Instantiate an Aeotec Door/Window 2nd Edition sensor instance, on # Instantiate an Aeotec Door/Window 2nd Edition sensor instance, on
# device node 10. You will almost certainly need to change this to # device node 10. You will almost certainly need to change this to
# reflect your own network. Use the ozwdump example to see what nodes # reflect your own network. Use the ozwdump example to see what nodes
# are available. # are available.
sensor = sensorObj.AeotecDW2E(10) sensor = sensorObj.AeotecDW2E(10)
# The first thing to do is create options, then lock them when done. # The first thing to do is create options, then lock them when done.
sensor.optionsCreate() sensor.optionsCreate()
sensor.optionsLock() sensor.optionsLock()
# Next, initialize it. # Next, initialize it.
print "Initializing, this may take awhile depending on your ZWave network" print "Initializing, this may take awhile depending on your ZWave network"
sensor.init(defaultDev) sensor.init(defaultDev)
print "Initialization complete" print "Initialization complete"
print "Querying data..." print "Querying data..."
while (True):
while (True):
if (sensor.isDeviceAvailable()): if (sensor.isDeviceAvailable()):
print "Alarm status:", print "Alarm status:",
print sensor.isAlarmTripped() print sensor.isAlarmTripped()
@ -76,5 +76,7 @@ while (True):
print print
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

56
examples/python/aeotecsdg2.py Normal file → Executable file
View File

@ -24,46 +24,47 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ozw as sensorObj import pyupm_ozw as sensorObj
# This function lets you run code on exit def main():
def exitHandler(): # This function lets you run code on exit
def exitHandler():
print "Turning switch off and sleeping for 5 seconds..." print "Turning switch off and sleeping for 5 seconds..."
sensor.off() sensor.off()
time.sleep(5) time.sleep(5)
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
defaultDev = "/dev/ttyACM0" defaultDev = "/dev/ttyACM0"
if (len(sys.argv) > 1): if (len(sys.argv) > 1):
defaultDev = sys.argv[1] defaultDev = sys.argv[1]
print "Using device", defaultDev print "Using device", defaultDev
# Instantiate an Aeotec Smart Dimmer Gen2 instance, on device node # Instantiate an Aeotec Smart Dimmer Gen2 instance, on device node
# 9. You will almost certainly need to change this to reflect your # 9. You will almost certainly need to change this to reflect your
# own network. Use the ozwdump example to see what nodes are # own network. Use the ozwdump example to see what nodes are
# available. # available.
sensor = sensorObj.AeotecSDG2(9) sensor = sensorObj.AeotecSDG2(9)
# The first thing to do is create options, then lock them when done. # The first thing to do is create options, then lock them when done.
sensor.optionsCreate() sensor.optionsCreate()
sensor.optionsLock() sensor.optionsLock()
# Next, initialize it. # Next, initialize it.
print "Initializing, this may take awhile depending on your ZWave network" print "Initializing, this may take awhile depending on your ZWave network"
sensor.init(defaultDev) sensor.init(defaultDev)
print "Initialization complete" print "Initialization complete"
# turn light on # turn light on
print "Turning switch on, then sleeping for 5 secs" print "Turning switch on, then sleeping for 5 secs"
sensor.on(); sensor.on();
time.sleep(5); time.sleep(5);
print "Querying data..." print "Querying data..."
dim = False; dim = False;
while (True): while (True):
# put on a light show... # put on a light show...
if (dim): if (dim):
sensor.setLevel(25) sensor.setLevel(25)
@ -94,3 +95,6 @@ while (True):
print print
time.sleep(5) time.sleep(5)
if __name__ == '__main__':
main()

52
examples/python/aeotecss6.py Normal file → Executable file
View File

@ -24,45 +24,46 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ozw as sensorObj import pyupm_ozw as sensorObj
# This function lets you run code on exit def main():
def exitHandler(): # This function lets you run code on exit
def exitHandler():
print "Turning switch off and sleeping for 5 seconds..." print "Turning switch off and sleeping for 5 seconds..."
sensor.off() sensor.off()
time.sleep(5) time.sleep(5)
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
defaultDev = "/dev/ttyACM0" defaultDev = "/dev/ttyACM0"
if (len(sys.argv) > 1): if (len(sys.argv) > 1):
defaultDev = sys.argv[1] defaultDev = sys.argv[1]
print "Using device", defaultDev print "Using device", defaultDev
# Instantiate an Aeotec Smart Switch 6 instance, on device node 11. # Instantiate an Aeotec Smart Switch 6 instance, on device node 11.
# You will almost certainly need to change this to reflect your own # You will almost certainly need to change this to reflect your own
# network. Use the ozwdump example to see what nodes are available. # network. Use the ozwdump example to see what nodes are available.
sensor = sensorObj.AeotecSS6(11) sensor = sensorObj.AeotecSS6(11)
# The first thing to do is create options, then lock them when done. # The first thing to do is create options, then lock them when done.
sensor.optionsCreate() sensor.optionsCreate()
sensor.optionsLock() sensor.optionsLock()
# Next, initialize it. # Next, initialize it.
print "Initializing, this may take awhile depending on your ZWave network" print "Initializing, this may take awhile depending on your ZWave network"
sensor.init(defaultDev) sensor.init(defaultDev)
print "Initialization complete" print "Initialization complete"
# turn light on # turn light on
print "Turning switch on, then sleeping for 5 secs" print "Turning switch on, then sleeping for 5 secs"
sensor.on(); sensor.on();
time.sleep(5); time.sleep(5);
print "Querying data..." print "Querying data..."
while (True): while (True):
sensor.update() sensor.update()
print "Switch status:", print "Switch status:",
@ -85,3 +86,6 @@ while (True):
print print
time.sleep(3) time.sleep(3)
if __name__ == '__main__':
main()

34
examples/python/ak8975.py Normal file → Executable file
View File

@ -24,30 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_mpu9150 as sensorObj import pyupm_mpu9150 as sensorObj
# Instantiate an AK8975 on I2C bus 0 def main():
sensor = sensorObj.AK8975() # Instantiate an AK8975 on I2C bus 0
sensor = sensorObj.AK8975()
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
sensor.init() sensor.init()
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
while (1): while (1):
sensor.update() sensor.update()
sensor.getMagnetometer(x, y, z) sensor.getMagnetometer(x, y, z)
print "Magnetometer: MX: ", sensorObj.floatp_value(x), print "Magnetometer: MX: ", sensorObj.floatp_value(x),
@ -57,3 +58,6 @@ while (1):
print print
time.sleep(.5) time.sleep(.5)
if __name__ == '__main__':
main()

31
examples/python/apa102.py Normal file → Executable file
View File

@ -21,28 +21,29 @@
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_apa102 as mylib import pyupm_apa102 as mylib
# Instantiate a strip of 30 LEDs on SPI bus 0 def main():
ledStrip = mylib.APA102(30, 0, False) # Instantiate a strip of 30 LEDs on SPI bus 0
ledStrip = mylib.APA102(30, 0, False)
## Exit handlers ## ## Exit handlers ##
# This stops python from printing a stacktrace when you hit control-C # This stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# Register exit handlers # Register exit handlers
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Setting all LEDs to Green" print "Setting all LEDs to Green"
ledStrip.setAllLeds(31, 0, 255, 0) ledStrip.setAllLeds(31, 0, 255, 0)
print "Setting LEDs between 10 and 20 to Red" print "Setting LEDs between 10 and 20 to Red"
ledStrip.setLeds(10, 20, 31, 255, 0, 0) ledStrip.setLeds(10, 20, 31, 255, 0, 0)
print "Setting LED 15 to Blue"
ledStrip.setLed(15, 31, 0, 0, 255)
print "Setting LED 15 to Blue"
ledStrip.setLed(15, 31, 0, 0, 255)
if __name__ == '__main__':
main()

28
examples/python/apds9002.py Normal file → Executable file
View File

@ -24,27 +24,29 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_apds9002 as upmApds9002 import pyupm_apds9002 as upmApds9002
# Instantiate a Grove Luminance sensor on analog pin A0 def main():
myLuminance = upmApds9002.APDS9002(0) # Instantiate a Grove Luminance sensor on analog pin A0
myLuminance = upmApds9002.APDS9002(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, including functions from myLuminance # This lets you run code on exit, including functions from myLuminance
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while(1):
while(1):
print "Luminance value is {0}".format( print "Luminance value is {0}".format(
myLuminance.value()) myLuminance.value())
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

40
examples/python/at42qt1070.py Normal file → Executable file
View File

@ -24,8 +24,9 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_at42qt1070 as upmAt42qt1070 import pyupm_at42qt1070 as upmAt42qt1070
# functions def main():
def printButtons(touchObj): # functions
def printButtons(touchObj):
buttonPressed = False buttonPressed = False
buttons = touchObj.getButtons() buttons = touchObj.getButtons()
@ -46,34 +47,33 @@ def printButtons(touchObj):
if (touchObj.isOverflowed()): if (touchObj.isOverflowed()):
print "Overflow was detected." print "Overflow was detected."
# Global code that runs on startup
# Global code that runs on startup I2C_BUS = upmAt42qt1070.AT42QT1070_I2C_BUS
DEFAULT_I2C_ADDR = upmAt42qt1070.AT42QT1070_DEFAULT_I2C_ADDR
I2C_BUS = upmAt42qt1070.AT42QT1070_I2C_BUS # Instantiate an AT42QT1070 on I2C bus 0
DEFAULT_I2C_ADDR = upmAt42qt1070.AT42QT1070_DEFAULT_I2C_ADDR myTouchSensor = upmAt42qt1070.AT42QT1070(I2C_BUS,
# Instantiate an AT42QT1070 on I2C bus 0
myTouchSensor = upmAt42qt1070.AT42QT1070(I2C_BUS,
DEFAULT_I2C_ADDR) DEFAULT_I2C_ADDR)
# Exit handlers
# Exit handlers def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# This function lets you run code on exit, including functions from myTouchSensor
atexit.register(exitHandler)
# This function stops python from printing a stacktrace when you hit control-C
signal.signal(signal.SIGINT, SIGINTHandler)
# This function lets you run code on exit, including functions from myTouchSensor # Print the button being touched every 0.1 seconds
atexit.register(exitHandler) while(1):
# This function stops python from printing a stacktrace when you hit control-C
signal.signal(signal.SIGINT, SIGINTHandler)
# Print the button being touched every 0.1 seconds
while(1):
myTouchSensor.updateState() myTouchSensor.updateState()
printButtons(myTouchSensor) printButtons(myTouchSensor)
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

32
examples/python/bh1750.py Normal file → Executable file
View File

@ -24,27 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bh1750 as sensorObj import pyupm_bh1750 as sensorObj
# Instantiate a BH1750 sensor using defaults (I2C bus (0), using def main():
# the default I2C address (0x23), and setting the mode to highest # Instantiate a BH1750 sensor using defaults (I2C bus (0), using
# resolution, lowest power mode). # the default I2C address (0x23), and setting the mode to highest
sensor = sensorObj.BH1750() # resolution, lowest power mode).
sensor = sensorObj.BH1750()
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Every second, sample the BH1750 and output the measured lux value # Every second, sample the BH1750 and output the measured lux value
while (True): while (True):
print "Detected Light Level (lux):", sensor.getLux() print "Detected Light Level (lux):", sensor.getLux()
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

30
examples/python/biss0001.py Normal file → Executable file
View File

@ -24,29 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_biss0001 as upmMotion import pyupm_biss0001 as upmMotion
# Instantiate a Grove Motion sensor on GPIO pin D2 def main():
myMotion = upmMotion.BISS0001(2) # Instantiate a Grove Motion sensor on GPIO pin D2
myMotion = upmMotion.BISS0001(2)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myMotion # This function lets you run code on exit, including functions from myMotion
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Read the value every second and detect motion
# Read the value every second and detect motion while(1):
while(1):
if (myMotion.value()): if (myMotion.value()):
print "Detecting moving object" print "Detecting moving object"
else: else:
print "No moving objects detected" print "No moving objects detected"
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

32
examples/python/bma220.py Normal file → Executable file
View File

@ -24,28 +24,29 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bma220 as sensorObj import pyupm_bma220 as sensorObj
# Instantiate an BMA220 using default parameters (bus 0, addr 0x0a) def main():
sensor = sensorObj.BMA220() # Instantiate an BMA220 using default parameters (bus 0, addr 0x0a)
sensor = sensorObj.BMA220()
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
while (1): while (1):
sensor.update() sensor.update()
sensor.getAccelerometer(x, y, z) sensor.getAccelerometer(x, y, z)
print "Accelerometer: AX:", sensorObj.floatp_value(x), print "Accelerometer: AX:", sensorObj.floatp_value(x),
@ -53,3 +54,6 @@ while (1):
print " AZ:", sensorObj.floatp_value(z) print " AZ:", sensorObj.floatp_value(z)
time.sleep(.5) time.sleep(.5)
if __name__ == '__main__':
main()

38
examples/python/bma250e.py Normal file → Executable file
View File

@ -24,32 +24,33 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmx055 as sensorObj import pyupm_bmx055 as sensorObj
# Instantiate a BMP250E instance using default i2c bus and address def main():
sensor = sensorObj.BMA250E() # Instantiate a BMP250E instance using default i2c bus and address
sensor = sensorObj.BMA250E()
# For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS: # For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS:
# BMA250E(0, -1, 10); # BMA250E(0, -1, 10);
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
# now output data every 250 milliseconds # now output data every 250 milliseconds
while (1): while (1):
sensor.update() sensor.update()
sensor.getAccelerometer(x, y, z) sensor.getAccelerometer(x, y, z)
@ -64,3 +65,6 @@ while (1):
print print
time.sleep(.250) time.sleep(.250)
if __name__ == '__main__':
main()

34
examples/python/bmc150.py Normal file → Executable file
View File

@ -24,29 +24,30 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmx055 as sensorObj import pyupm_bmx055 as sensorObj
# Instantiate a BMC150 instance using default i2c bus and address def main():
sensor = sensorObj.BMC150() # Instantiate a BMC150 instance using default i2c bus and address
sensor = sensorObj.BMC150()
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
# now output data every 250 milliseconds # now output data every 250 milliseconds
while (1): while (1):
sensor.update() sensor.update()
sensor.getAccelerometer(x, y, z) sensor.getAccelerometer(x, y, z)
@ -63,3 +64,6 @@ while (1):
print print
time.sleep(.250) time.sleep(.250)
if __name__ == '__main__':
main()

30
examples/python/bme280.py Normal file → Executable file
View File

@ -24,27 +24,28 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmp280 as sensorObj import pyupm_bmp280 as sensorObj
# Instantiate a BME280 instance using default i2c bus and address def main():
sensor = sensorObj.BME280() # Instantiate a BME280 instance using default i2c bus and address
sensor = sensorObj.BME280()
# For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS: # For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS:
# BME280(0, -1, 10); # BME280(0, -1, 10);
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while (1): while (1):
sensor.update() sensor.update()
print "Compensation Temperature:", sensor.getTemperature(), "C /", print "Compensation Temperature:", sensor.getTemperature(), "C /",
@ -58,3 +59,6 @@ while (1):
print print
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

38
examples/python/bmg160.py Normal file → Executable file
View File

@ -24,32 +24,33 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmx055 as sensorObj import pyupm_bmx055 as sensorObj
# Instantiate a BMP250E instance using default i2c bus and address def main():
sensor = sensorObj.BMG160() # Instantiate a BMP250E instance using default i2c bus and address
sensor = sensorObj.BMG160()
# For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS: # For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS:
# BMG160(0, -1, 10); # BMG160(0, -1, 10);
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
# now output data every 250 milliseconds # now output data every 250 milliseconds
while (1): while (1):
sensor.update() sensor.update()
sensor.getGyroscope(x, y, z) sensor.getGyroscope(x, y, z)
@ -64,3 +65,6 @@ while (1):
print print
time.sleep(.250) time.sleep(.250)
if __name__ == '__main__':
main()

34
examples/python/bmi055.py Normal file → Executable file
View File

@ -24,29 +24,30 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmx055 as sensorObj import pyupm_bmx055 as sensorObj
# Instantiate a BMI055 instance using default i2c bus and address def main():
sensor = sensorObj.BMI055() # Instantiate a BMI055 instance using default i2c bus and address
sensor = sensorObj.BMI055()
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
# now output data every 250 milliseconds # now output data every 250 milliseconds
while (1): while (1):
sensor.update() sensor.update()
sensor.getAccelerometer(x, y, z) sensor.getAccelerometer(x, y, z)
@ -63,3 +64,6 @@ while (1):
print print
time.sleep(.250) time.sleep(.250)
if __name__ == '__main__':
main()

32
examples/python/bmi160.py Normal file → Executable file
View File

@ -24,28 +24,29 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmi160 as sensorObj import pyupm_bmi160 as sensorObj
# Instantiate a BMI160 instance using default i2c bus and address def main():
sensor = sensorObj.BMI160() # Instantiate a BMI160 instance using default i2c bus and address
sensor = sensorObj.BMI160()
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
while (1): while (1):
sensor.update() sensor.update()
sensor.getAccelerometer(x, y, z) sensor.getAccelerometer(x, y, z)
print "Accelerometer: AX: ", sensorObj.floatp_value(x), print "Accelerometer: AX: ", sensorObj.floatp_value(x),
@ -64,3 +65,6 @@ while (1):
print print
time.sleep(.5) time.sleep(.5)
if __name__ == '__main__':
main()

38
examples/python/bmm150.py Normal file → Executable file
View File

@ -24,32 +24,33 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmx055 as sensorObj import pyupm_bmx055 as sensorObj
# Instantiate a BMP250E instance using default i2c bus and address def main():
sensor = sensorObj.BMM150() # Instantiate a BMP250E instance using default i2c bus and address
sensor = sensorObj.BMM150()
# For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS: # For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS:
# BMM150(0, -1, 10); # BMM150(0, -1, 10);
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
# now output data every 250 milliseconds # now output data every 250 milliseconds
while (1): while (1):
sensor.update() sensor.update()
sensor.getMagnetometer(x, y, z) sensor.getMagnetometer(x, y, z)
@ -60,3 +61,6 @@ while (1):
print print
time.sleep(.250) time.sleep(.250)
if __name__ == '__main__':
main()

30
examples/python/bmp280.py Normal file → Executable file
View File

@ -24,27 +24,28 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmp280 as sensorObj import pyupm_bmp280 as sensorObj
# Instantiate a BMP280 instance using default i2c bus and address def main():
sensor = sensorObj.BMP280() # Instantiate a BMP280 instance using default i2c bus and address
sensor = sensorObj.BMP280()
# For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS: # For SPI, bus 0, you would pass -1 as the address, and a valid pin for CS:
# BMP280(0, -1, 10); # BMP280(0, -1, 10);
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while (1): while (1):
sensor.update() sensor.update()
print "Compensation Temperature:", sensor.getTemperature(), "C /", print "Compensation Temperature:", sensor.getTemperature(), "C /",
@ -56,3 +57,6 @@ while (1):
print print
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

32
examples/python/bmpx8x.py Normal file → Executable file
View File

@ -24,28 +24,27 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmpx8x as upmBmpx8x import pyupm_bmpx8x as upmBmpx8x
# Load Barometer module on i2c def main():
myBarometer = upmBmpx8x.BMPX8X(0, upmBmpx8x.ADDR); # Load Barometer module on i2c
myBarometer = upmBmpx8x.BMPX8X(0, upmBmpx8x.ADDR);
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myBarometer # This function lets you run code on exit, including functions from myBarometer
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Print the pressure, altitude, sea level, and
# Print the pressure, altitude, sea level, and # temperature values every 0.1 seconds
# temperature values every 0.1 seconds while(1):
while(1):
outputStr = ("pressure value = {0}" outputStr = ("pressure value = {0}"
", altitude value = {1}" ", altitude value = {1}"
", sealevel value = {2}" ", sealevel value = {2}"
@ -57,3 +56,6 @@ while(1):
print outputStr print outputStr
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

34
examples/python/bmx055.py Normal file → Executable file
View File

@ -24,29 +24,30 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bmx055 as sensorObj import pyupm_bmx055 as sensorObj
# Instantiate a BMX055 instance using default i2c bus and address def main():
sensor = sensorObj.BMX055() # Instantiate a BMX055 instance using default i2c bus and address
sensor = sensorObj.BMX055()
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
# now output data every 250 milliseconds # now output data every 250 milliseconds
while (1): while (1):
sensor.update() sensor.update()
sensor.getAccelerometer(x, y, z) sensor.getAccelerometer(x, y, z)
@ -69,3 +70,6 @@ while (1):
print print
time.sleep(.250) time.sleep(.250)
if __name__ == '__main__':
main()

68
examples/python/bno055.py Normal file → Executable file
View File

@ -24,43 +24,44 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_bno055 as sensorObj import pyupm_bno055 as sensorObj
# Instantiate an BNO055 using default parameters (bus 0, addr def main():
# 0x28). The default running mode is NDOF absolute orientation # Instantiate an BNO055 using default parameters (bus 0, addr
# mode. # 0x28). The default running mode is NDOF absolute orientation
sensor = sensorObj.BNO055() # mode.
sensor = sensorObj.BNO055()
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting..." print "Exiting..."
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
mag = sensorObj.new_intp() mag = sensorObj.new_intp()
acc = sensorObj.new_intp() acc = sensorObj.new_intp()
gyr = sensorObj.new_intp() gyr = sensorObj.new_intp()
syst = sensorObj.new_intp() syst = sensorObj.new_intp()
w = sensorObj.new_floatp() w = sensorObj.new_floatp()
x = sensorObj.new_floatp() x = sensorObj.new_floatp()
y = sensorObj.new_floatp() y = sensorObj.new_floatp()
z = sensorObj.new_floatp() z = sensorObj.new_floatp()
print "First we need to calibrate. 4 numbers will be output every" print "First we need to calibrate. 4 numbers will be output every"
print "second for each sensor. 0 means uncalibrated, and 3 means" print "second for each sensor. 0 means uncalibrated, and 3 means"
print "fully calibrated." print "fully calibrated."
print "See the UPM documentation on this sensor for instructions on" print "See the UPM documentation on this sensor for instructions on"
print "what actions are required to calibrate." print "what actions are required to calibrate."
print print
while (not sensor.isFullyCalibrated()): while (not sensor.isFullyCalibrated()):
sensor.getCalibrationStatus(mag, acc, gyr, syst) sensor.getCalibrationStatus(mag, acc, gyr, syst)
print "Magnetometer:", sensorObj.intp_value(mag), print "Magnetometer:", sensorObj.intp_value(mag),
print " Accelerometer:", sensorObj.intp_value(acc), print " Accelerometer:", sensorObj.intp_value(acc),
@ -68,13 +69,13 @@ while (not sensor.isFullyCalibrated()):
print " System:", sensorObj.intp_value(syst), print " System:", sensorObj.intp_value(syst),
time.sleep(1) time.sleep(1)
print print
print "Calibration complete." print "Calibration complete."
print print
# now output various fusion data every 250 milliseconds # now output various fusion data every 250 milliseconds
while (True): while (True):
sensor.update() sensor.update()
sensor.getEulerAngles(x, y, z) sensor.getEulerAngles(x, y, z)
@ -103,3 +104,6 @@ while (True):
print print
time.sleep(.25); time.sleep(.25);
if __name__ == '__main__':
main()

16
examples/python/button.py Normal file → Executable file
View File

@ -23,13 +23,17 @@
import time import time
import pyupm_grove as grove import pyupm_grove as grove
# Create the button object using GPIO pin 0 def main():
button = grove.Button(0) # Create the button object using GPIO pin 0
button = grove.Button(0)
# Read the input and print, waiting one second between readings # Read the input and print, waiting one second between readings
while 1: while 1:
print button.name(), ' value is ', button.value() print button.name(), ' value is ', button.value()
time.sleep(1) time.sleep(1)
# Delete the button object # Delete the button object
del button del button
if __name__ == '__main__':
main()

24
examples/python/buzzer.py Normal file → Executable file
View File

@ -23,23 +23,27 @@
import time import time
import pyupm_buzzer as upmBuzzer import pyupm_buzzer as upmBuzzer
# Create the buzzer object using GPIO pin 5 def main():
buzzer = upmBuzzer.Buzzer(5) # Create the buzzer object using GPIO pin 5
buzzer = upmBuzzer.Buzzer(5)
chords = [upmBuzzer.DO, upmBuzzer.RE, upmBuzzer.MI, upmBuzzer.FA, chords = [upmBuzzer.DO, upmBuzzer.RE, upmBuzzer.MI, upmBuzzer.FA,
upmBuzzer.SOL, upmBuzzer.LA, upmBuzzer.SI, upmBuzzer.DO, upmBuzzer.SOL, upmBuzzer.LA, upmBuzzer.SI, upmBuzzer.DO,
upmBuzzer.SI]; upmBuzzer.SI];
# Print sensor name # Print sensor name
print buzzer.name() print buzzer.name()
# Play sound (DO, RE, MI, etc.), pausing for 0.1 seconds between notes # Play sound (DO, RE, MI, etc.), pausing for 0.1 seconds between notes
for chord_ind in range (0,7): for chord_ind in range (0,7):
# play each note for one second # play each note for one second
print buzzer.playSound(chords[chord_ind], 1000000) print buzzer.playSound(chords[chord_ind], 1000000)
time.sleep(0.1) time.sleep(0.1)
print "exiting application" print "exiting application"
# Delete the buzzer object # Delete the buzzer object
del buzzer del buzzer
if __name__ == '__main__':
main()

27
examples/python/cjq4435.py Normal file → Executable file
View File

@ -25,22 +25,25 @@ from __future__ import division
import time import time
import pyupm_cjq4435 as upmCjq4435 import pyupm_cjq4435 as upmCjq4435
# Instantiate a CJQ4435 MOSFET on a PWM capable digital pin D3 def main():
myMOSFETsensor = upmCjq4435.CJQ4435(3) # Instantiate a CJQ4435 MOSFET on a PWM capable digital pin D3
myMOSFETsensor = upmCjq4435.CJQ4435(3)
myMOSFETsensor.setPeriodMS(10)
myMOSFETsensor.enable(True)
myMOSFETsensor.setPeriodMS(10) # start with a duty cycle of 0.0 (off) and increment to 1.0 (on)
myMOSFETsensor.enable(True) for i in range(11):
# start with a duty cycle of 0.0 (off) and increment to 1.0 (on)
for i in range(11):
myMOSFETsensor.setDutyCycle(i / 10) myMOSFETsensor.setDutyCycle(i / 10)
time.sleep(.1) time.sleep(.1)
time.sleep(1) time.sleep(1)
# Now take it back down # Now take it back down
# start with a duty cycle of 1.0 (on) and decrement to 0.0 (off) # start with a duty cycle of 1.0 (on) and decrement to 0.0 (off)
for i in range(10, -1, -1): for i in range(10, -1, -1):
myMOSFETsensor.setDutyCycle(i / 10) myMOSFETsensor.setDutyCycle(i / 10)
time.sleep(.1) time.sleep(.1)
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

36
examples/python/collision.py Normal file → Executable file
View File

@ -24,34 +24,36 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_collision as upmcollision import pyupm_collision as upmcollision
# The was tested with the Collision Sensor def main():
# Instantiate a Collision on digital pin D2 # The was tested with the Collision Sensor
mycollision = upmcollision.Collision(2) # Instantiate a Collision on digital pin D2
mycollision = upmcollision.Collision(2)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myGrovecollision # including functions from myGrovecollision
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
collisionState = False
print "No collision"
collisionState = False while(1):
print "No collision"
while(1):
if (mycollision.isColliding() and not collisionState): if (mycollision.isColliding() and not collisionState):
print "Collision!" print "Collision!"
collisionState = True collisionState = True
elif (not mycollision.isColliding() and collisionState): elif (not mycollision.isColliding() and collisionState):
print "No collision" print "No collision"
collisionState = False collisionState = False
if __name__ == '__main__':
main()

22
examples/python/curieimu.py Normal file → Executable file
View File

@ -30,22 +30,23 @@ mraa.addSubplatform(mraa.GENERIC_FIRMATA, "/dev/ttyACM0")
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_curieimu as curieimu import pyupm_curieimu as curieimu
sensor = curieimu.CurieImu()
## Exit handlers ## def main():
def SIGINTHandler(signum, frame): sensor = curieimu.CurieImu()
## Exit handlers ##
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while(1):
while(1):
sensor.updateAccel(); sensor.updateAccel();
outputStr = "acc: gX {0} - gY {1} - gZ {2}".format( outputStr = "acc: gX {0} - gY {1} - gZ {2}".format(
@ -54,3 +55,6 @@ while(1):
print outputStr print outputStr
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

32
examples/python/cwlsxxa.py Normal file → Executable file
View File

@ -24,28 +24,29 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_cwlsxxa as sensorObj import pyupm_cwlsxxa as sensorObj
## Exit handlers ## def main():
# This function stops python from printing a stacktrace when you hit control-C ## Exit handlers ##
def SIGINTHandler(signum, frame): # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Initializing..." print "Initializing..."
# Instantiate an CWLSXXA instance, using A0 for CO2, A1 for # Instantiate an CWLSXXA instance, using A0 for CO2, A1 for
# humidity and A2 for temperature # humidity and A2 for temperature
sensor = sensorObj.CWLSXXA(0, 1, 2) sensor = sensorObj.CWLSXXA(0, 1, 2)
# update and print available values every second # update and print available values every second
while (1): while (1):
# update our values from the sensor # update our values from the sensor
sensor.update() sensor.update()
@ -59,3 +60,6 @@ while (1):
print print
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

34
examples/python/dfrec.py Normal file → Executable file
View File

@ -24,28 +24,29 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_dfrec as sensorObj import pyupm_dfrec as sensorObj
# Instantiate a DFRobot EC sensor on analog pin A0, with a ds18b20 def main():
# temperature sensor connected to UART 0, and a device index (for # Instantiate a DFRobot EC sensor on analog pin A0, with a ds18b20
# the ds1820b uart bus) of 0, and an analog reference voltage of # temperature sensor connected to UART 0, and a device index (for
# 5.0. # the ds1820b uart bus) of 0, and an analog reference voltage of
sensor = sensorObj.DFREC(0, 0, 0, 5.0) # 5.0.
sensor = sensorObj.DFREC(0, 0, 0, 5.0)
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Every 2 seconds, update and print values # Every 2 seconds, update and print values
while (True): while (True):
sensor.update() sensor.update()
print "EC =", sensor.getEC(), "ms/cm" print "EC =", sensor.getEC(), "ms/cm"
@ -54,3 +55,6 @@ while (True):
print print
time.sleep(2) time.sleep(2)
if __name__ == '__main__':
main()

58
examples/python/dfrorp.py Normal file → Executable file
View File

@ -24,41 +24,42 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_dfrorp as sensorObj import pyupm_dfrorp as sensorObj
# Instantiate a DFRobot ORP sensor on analog pin A0 with an analog def main():
# reference voltage of 5.0. # Instantiate a DFRobot ORP sensor on analog pin A0 with an analog
sensor = sensorObj.DFRORP(0, 5.0) # reference voltage of 5.0.
sensor = sensorObj.DFRORP(0, 5.0)
# To calibrate: # To calibrate:
# #
# Disconnect the sensor probe (but leave the sensor interface board # Disconnect the sensor probe (but leave the sensor interface board
# connected). Then run one of the examples while holding down the # connected). Then run one of the examples while holding down the
# 'calibrate' button on the device. Read the ORP value reported # 'calibrate' button on the device. Read the ORP value reported
# (it should be fairly small). # (it should be fairly small).
# #
# This value is what you should supply to setCalibrationOffset(). # This value is what you should supply to setCalibrationOffset().
# Then reconnect the probe to the interface board and you should be # Then reconnect the probe to the interface board and you should be
# ready to go. # ready to go.
# #
# DO NOT press the calibrate button on the interface board while # DO NOT press the calibrate button on the interface board while
# the probe is attached or you can permanently damage the probe. # the probe is attached or you can permanently damage the probe.
sensor.setCalibrationOffset(0.97); sensor.setCalibrationOffset(0.97);
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Every second, update and print values # Every second, update and print values
while (True): while (True):
sensor.update() sensor.update()
print "ORP:", sensor.getORP(), "mV" print "ORP:", sensor.getORP(), "mV"
@ -66,3 +67,6 @@ while (True):
print print
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

40
examples/python/dfrph.py Normal file → Executable file
View File

@ -24,33 +24,37 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_dfrph as sensorObj import pyupm_dfrph as sensorObj
# Instantiate a DFRPH sensor on analog pin A0, with an analog def main():
# reference voltage of 5.0 # Instantiate a DFRPH sensor on analog pin A0, with an analog
sensor = sensorObj.DFRPH(0, 5.0) # reference voltage of 5.0
sensor = sensorObj.DFRPH(0, 5.0)
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# After calibration, set the offset (based on calibration with a pH # After calibration, set the offset (based on calibration with a pH
# 7.0 buffer solution). See the UPM sensor documentation for # 7.0 buffer solution). See the UPM sensor documentation for
# calibrations instructions. # calibrations instructions.
sensor.setOffset(0.065); sensor.setOffset(0.065);
# Every second, sample the pH and output it's corresponding # Every second, sample the pH and output it's corresponding
# analog voltage. # analog voltage.
while (1): while (1):
print "Detected volts: ", sensor.volts() print "Detected volts: ", sensor.volts()
print "pH value: ", sensor.pH() print "pH value: ", sensor.pH()
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

35
examples/python/ds1307.py Normal file → Executable file
View File

@ -24,10 +24,11 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ds1307 as upmDs1307 import pyupm_ds1307 as upmDs1307
# load RTC clock on i2c bus 0 def main():
myRTCClock = upmDs1307.DS1307(0) # load RTC clock on i2c bus 0
myRTCClock = upmDs1307.DS1307(0)
def printTime(RTCObj): def printTime(RTCObj):
timeStr = "The time is: {0}/{1}/{2} {3}:{4}:{5}".format( timeStr = "The time is: {0}/{1}/{2} {3}:{4}:{5}".format(
RTCObj.month, RTCObj.dayOfMonth, RTCObj.year, RTCObj.month, RTCObj.dayOfMonth, RTCObj.year,
RTCObj.hours, RTCObj.minutes, RTCObj.seconds) RTCObj.hours, RTCObj.minutes, RTCObj.seconds)
@ -40,21 +41,23 @@ def printTime(RTCObj):
print "Clock is in", ("AM/PM mode" print "Clock is in", ("AM/PM mode"
if RTCObj.amPmMode else "24hr mode") if RTCObj.amPmMode else "24hr mode")
# always do this first
# always do this first print "Loading the current time... "
print "Loading the current time... " result = myRTCClock.loadTime()
result = myRTCClock.loadTime() if (not result):
if (not result):
print "myRTCClock.loadTime() failed." print "myRTCClock.loadTime() failed."
sys.exit(0) sys.exit(0)
printTime(myRTCClock); printTime(myRTCClock);
# set the year as an example # set the year as an example
print "setting the year to 50" print "setting the year to 50"
myRTCClock.year = 50 myRTCClock.year = 50
myRTCClock.setTime() myRTCClock.setTime()
# reload the time and print it # reload the time and print it
myRTCClock.loadTime() myRTCClock.loadTime()
printTime(myRTCClock) printTime(myRTCClock)
if __name__ == '__main__':
main()

40
examples/python/ds18b20.py Normal file → Executable file
View File

@ -24,36 +24,37 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ds18b20 as sensorObj import pyupm_ds18b20 as sensorObj
## Exit handlers ## def main():
# This function stops python from printing a stacktrace when you hit control-C ## Exit handlers ##
def SIGINTHandler(signum, frame): # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting..." print "Exiting..."
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Initializing..." print "Initializing..."
# Instantiate an DS18B20 instance using the default values (uart 0) # Instantiate an DS18B20 instance using the default values (uart 0)
sensor = sensorObj.DS18B20(0) sensor = sensorObj.DS18B20(0)
# locate and setup our devices # locate and setup our devices
sensor.init() sensor.init()
print "Found", sensor.devicesFound(), "device(s)" print "Found", sensor.devicesFound(), "device(s)"
print print
if (not sensor.devicesFound()): if (not sensor.devicesFound()):
sys.exit(1); sys.exit(1);
# update and print available values every second # update and print available values every second
while (1): while (1):
# update our values for the first sensor # update our values for the first sensor
sensor.update(0) sensor.update(0)
@ -62,3 +63,6 @@ while (1):
print sensor.getTemperature(0, True), "F" print sensor.getTemperature(0, True), "F"
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

46
examples/python/ds2413.py Normal file → Executable file
View File

@ -24,34 +24,38 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ds2413 as sensorObj import pyupm_ds2413 as sensorObj
# Instantiate a DS2413 Module on a Dallas 1-wire bus connected to UART 0 def main():
sensor = sensorObj.DS2413(0) # Instantiate a DS2413 Module on a Dallas 1-wire bus connected to UART 0
sensor = sensorObj.DS2413(0)
## Exit handlers ## ## Exit handlers ##
# This stops python from printing a stacktrace when you hit control-C # This stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting..." print "Exiting..."
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# find all of the DS2413 devices present on the bus # find all of the DS2413 devices present on the bus
sensor.init(); sensor.init();
# how many devices were found? # how many devices were found?
print "Found", sensor.devicesFound(), "device(s)" print "Found", sensor.devicesFound(), "device(s)"
# read the gpio and latch values from the first device # read the gpio and latch values from the first device
# the lower 4 bits are of the form: # the lower 4 bits are of the form:
# <gpioB latch> <gpioB value> <gpioA latch> <gpioA value> # <gpioB latch> <gpioB value> <gpioA latch> <gpioA value>
print "GPIO device 0 values:", sensor.readGpios(0) print "GPIO device 0 values:", sensor.readGpios(0)
# set the gpio latch values of the first device # set the gpio latch values of the first device
print "Setting GPIO latches to on" print "Setting GPIO latches to on"
sensor.writeGpios(0, 0x03); sensor.writeGpios(0, 0x03);
if __name__ == '__main__':
main()

76
examples/python/e50hx.py Normal file → Executable file
View File

@ -24,57 +24,58 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_e50hx as sensorObj import pyupm_e50hx as sensorObj
## Exit handlers ## def main():
# This function stops python from printing a stacktrace when you hit control-C ## Exit handlers ##
def SIGINTHandler(signum, frame): # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting..." print "Exiting..."
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# You will need to edit this example to conform to your site and your # You will need to edit this example to conform to your site and your
# devices, specifically the Device Object Instance ID passed to the # devices, specifically the Device Object Instance ID passed to the
# constructor, and the arguments to initMaster() that are # constructor, and the arguments to initMaster() that are
# appropriate for your BACnet network. # appropriate for your BACnet network.
defaultDev = "/dev/ttyUSB0" defaultDev = "/dev/ttyUSB0"
# if an argument was specified, use it as the device instead # if an argument was specified, use it as the device instead
if (len(sys.argv) > 1): if (len(sys.argv) > 1):
defaultDev = sys.argv[1] defaultDev = sys.argv[1]
print "Using device", defaultDev print "Using device", defaultDev
print "Initializing..." print "Initializing..."
# Instantiate an E50HX object for an E50HX device that has 1075425 # Instantiate an E50HX object for an E50HX device that has 1075425
# as it's unique Device Object Instance ID. NOTE: You will # as it's unique Device Object Instance ID. NOTE: You will
# certainly want to change this to the correct value for your # certainly want to change this to the correct value for your
# device(s). # device(s).
sensor = sensorObj.E50HX(1075425) sensor = sensorObj.E50HX(1075425)
# Initialize our BACnet master, if it has not already been # Initialize our BACnet master, if it has not already been
# initialized, with the device and baudrate, choosing 1000001 as # initialized, with the device and baudrate, choosing 1000001 as
# our unique Device Object Instance ID, 2 as our MAC address and # our unique Device Object Instance ID, 2 as our MAC address and
# using default values for maxMaster and maxInfoFrames # using default values for maxMaster and maxInfoFrames
sensor.initMaster(defaultDev, 38400, 1000001, 2) sensor.initMaster(defaultDev, 38400, 1000001, 2)
# Uncomment to enable debugging output # Uncomment to enable debugging output
# sensor.setDebug(True); # sensor.setDebug(True);
# output the serial number and firmware revision # output the serial number and firmware revision
print print
print "Device Description:", sensor.getDeviceDescription() print "Device Description:", sensor.getDeviceDescription()
print "Device Location:", sensor.getDeviceLocation() print "Device Location:", sensor.getDeviceLocation()
print print
# update and print available values every second # update and print available values every second
while (1): while (1):
print "System Voltage:", print "System Voltage:",
print sensor.getAnalogValue(sensorObj.E50HX.AV_System_Voltage), print sensor.getAnalogValue(sensorObj.E50HX.AV_System_Voltage),
print " ", print " ",
@ -93,3 +94,6 @@ while (1):
print print
time.sleep(5) time.sleep(5)
if __name__ == '__main__':
main()

25
examples/python/eboled.py Normal file → Executable file
View File

@ -25,17 +25,18 @@ import time, sys
import pyupm_i2clcd as lcdObj import pyupm_i2clcd as lcdObj
# setup with default values def main():
lcd = lcdObj.EBOLED(); # setup with default values
lcd = lcdObj.EBOLED();
lcd.clear();
lcd.setCursor(10, 15);
lcd.write("Hello");
lcd.setCursor(30, 15);
lcd.write("World!");
lcd.refresh();
print "Sleeping for 5 seconds..."
time.sleep(5)
lcd.clear();
lcd.setCursor(10, 15);
lcd.write("Hello");
lcd.setCursor(30, 15);
lcd.write("World!");
lcd.refresh();
print "Sleeping for 5 seconds..."
time.sleep(5)
if __name__ == '__main__':
main()

39
examples/python/ehr.py Normal file → Executable file
View File

@ -21,37 +21,35 @@
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ehr as upmehr import pyupm_ehr as upmehr
# Instantiate a Ear-clip Heart Rate sensor on digital pin D2 def main():
myHeartRateSensor = upmehr.EHR(2) # Instantiate a Ear-clip Heart Rate sensor on digital pin D2
myHeartRateSensor = upmehr.EHR(2)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myHeartRateSensor # including functions from myHeartRateSensor
def exitHandler(): def exitHandler():
myHeartRateSensor.stopBeatCounter() myHeartRateSensor.stopBeatCounter()
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# set the beat counter to 0, init the clock and start counting beats
myHeartRateSensor.clearBeatCounter()
myHeartRateSensor.initClock()
myHeartRateSensor.startBeatCounter()
# set the beat counter to 0, init the clock and start counting beats while(1):
myHeartRateSensor.clearBeatCounter()
myHeartRateSensor.initClock()
myHeartRateSensor.startBeatCounter()
while(1):
# we grab these (millis and flowCount) just for display # we grab these (millis and flowCount) just for display
# purposes in this example # purposes in this example
millis = myHeartRateSensor.getMillis() millis = myHeartRateSensor.getMillis()
@ -66,3 +64,6 @@ while(1):
millis, beats, fr) millis, beats, fr)
print outputStr print outputStr
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

32
examples/python/eldriver.py Normal file → Executable file
View File

@ -24,30 +24,29 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_eldriver as upmeldriver import pyupm_eldriver as upmeldriver
# The was tested with the El Driver Module def main():
# Instantiate a El Driver on digital pin D2 # The was tested with the El Driver Module
myEldriver = upmeldriver.ElDriver(2) # Instantiate a El Driver on digital pin D2
myEldriver = upmeldriver.ElDriver(2)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myEldriver # This function lets you run code on exit, including functions from myEldriver
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
myEldriver.off() myEldriver.off()
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
lightState = True
lightState = True while(1):
while(1):
if (lightState): if (lightState):
myEldriver.on() myEldriver.on()
else: else:
@ -55,3 +54,6 @@ while(1):
lightState = not lightState lightState = not lightState
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

36
examples/python/electromagnet.py Normal file → Executable file
View File

@ -24,32 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_electromagnet as upmelectromagnet import pyupm_electromagnet as upmelectromagnet
# This was tested with the Electromagnetic Module def main():
# Instantiate a Electromagnet on digital pin D2 # This was tested with the Electromagnetic Module
myElectromagnet = upmelectromagnet.Electromagnet(2) # Instantiate a Electromagnet on digital pin D2
myElectromagnet = upmelectromagnet.Electromagnet(2)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myElectromagnet # including functions from myElectromagnet
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
myElectromagnet.off() myElectromagnet.off()
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
magnetState = False
magnetState = False # Turn magnet on and off every 5 seconds
while(1):
# Turn magnet on and off every 5 seconds
while(1):
magnetState = not magnetState magnetState = not magnetState
if (magnetState): if (magnetState):
myElectromagnet.on() myElectromagnet.on()
@ -58,3 +57,6 @@ while(1):
print "Turning magnet", ("on" if magnetState else "off") print "Turning magnet", ("on" if magnetState else "off")
time.sleep(5) time.sleep(5)
if __name__ == '__main__':
main()

34
examples/python/emg.py Normal file → Executable file
View File

@ -24,29 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_emg as upmEmg import pyupm_emg as upmEmg
# Tested with the EMG Muscle Signal Reader Sensor Module def main():
# Instantiate a EMG on analog pin A0 # Tested with the EMG Muscle Signal Reader Sensor Module
myEMG = upmEmg.EMG(0) # Instantiate a EMG on analog pin A0
myEMG = upmEmg.EMG(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, including functions from myEMG # This lets you run code on exit, including functions from myEMG
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Calibrating...."
myEMG.calibrate()
print "Calibrating...." while (1):
myEMG.calibrate()
while (1):
print myEMG.value() print myEMG.value()
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

44
examples/python/enc03r.py Normal file → Executable file
View File

@ -24,37 +24,36 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_enc03r as upmEnc03r import pyupm_enc03r as upmEnc03r
# Instantiate an ENC03R on analog pin A0 def main():
myAnalogGyro = upmEnc03r.ENC03R(0) # Instantiate an ENC03R on analog pin A0
myAnalogGyro = upmEnc03r.ENC03R(0)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, # This function lets you run code on exit,
# including functions from myAnalogGyro # including functions from myAnalogGyro
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
CALIBRATION_SAMPLES = 1000
CALIBRATION_SAMPLES = 1000 print ("Please place the sensor in a stable location,\n"
"and do not move it while calibration takes place.\n"
"This may take a couple of minutes.")
print ("Please place the sensor in a stable location,\n" myAnalogGyro.calibrate(CALIBRATION_SAMPLES)
"and do not move it while calibration takes place.\n" print "Calibration complete. "
"This may take a couple of minutes.") print "Reference value: ", myAnalogGyro.calibrationValue()
myAnalogGyro.calibrate(CALIBRATION_SAMPLES) while(1):
print "Calibration complete. "
print "Reference value: ", myAnalogGyro.calibrationValue()
while(1):
gyroVal = myAnalogGyro.value(); gyroVal = myAnalogGyro.value();
outputStr = ("Raw value: {0}, " outputStr = ("Raw value: {0}, "
"angular velocity: {1}" "angular velocity: {1}"
@ -62,3 +61,6 @@ while(1):
print outputStr print outputStr
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

14
examples/python/es08a.py Normal file → Executable file
View File

@ -23,10 +23,11 @@
import time import time
import pyupm_servo as servo import pyupm_servo as servo
# Create the servo object using D5 def main():
gServo = servo.ES08A(5) # Create the servo object using D5
gServo = servo.ES08A(5)
for i in range(0,10): for i in range(0,10):
# Set the servo arm to 0 degrees # Set the servo arm to 0 degrees
gServo.setAngle(0) gServo.setAngle(0)
print 'Set angle to 0' print 'Set angle to 0'
@ -42,5 +43,8 @@ for i in range(0,10):
print 'Set angle to 180' print 'Set angle to 180'
time.sleep(1) time.sleep(1)
# Delete the servo object # Delete the servo object
del gServo del gServo
if __name__ == '__main__':
main()

50
examples/python/gp2y0a.py Normal file → Executable file
View File

@ -24,39 +24,41 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_gp2y0a as upmGp2y0a import pyupm_gp2y0a as upmGp2y0a
# Note, for the Grove 80cm version of this sensor, due to the way it is wired, def main():
# you need to plug this into the A0 port, where it will use the available # Note, for the Grove 80cm version of this sensor, due to the way it is wired,
# A1 pin for data. # you need to plug this into the A0 port, where it will use the available
# Instantiate a GP2Y0A on analog pin A1 # A1 pin for data.
myIRProximity = upmGp2y0a.GP2Y0A(1) # Instantiate a GP2Y0A on analog pin A1
myIRProximity = upmGp2y0a.GP2Y0A(1)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myIRProximity # including functions from myIRProximity
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# analog voltage, usually 3.3 or 5.0
GP2Y0A_AREF = 5.0;
SAMPLES_PER_QUERY = 20;
# analog voltage, usually 3.3 or 5.0 # The higher the voltage (closer to AREF) the closer the object is.
GP2Y0A_AREF = 5.0; # NOTE: The measured voltage will probably not exceed 3.3 volts.
SAMPLES_PER_QUERY = 20; # Every second, print the averaged voltage value
# (averaged over 20 samples).
# The higher the voltage (closer to AREF) the closer the object is. while (1):
# NOTE: The measured voltage will probably not exceed 3.3 volts.
# Every second, print the averaged voltage value
# (averaged over 20 samples).
while (1):
print "AREF: {0}, Voltage value (higher means closer): {1}".format( print "AREF: {0}, Voltage value (higher means closer): {1}".format(
GP2Y0A_AREF, GP2Y0A_AREF,
myIRProximity.value(GP2Y0A_AREF, SAMPLES_PER_QUERY)) myIRProximity.value(GP2Y0A_AREF, SAMPLES_PER_QUERY))
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

50
examples/python/gprs.py Normal file → Executable file
View File

@ -24,38 +24,38 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_gprs as sensorObj import pyupm_gprs as sensorObj
# Instantiate a GPRS Module on UART 0 def main():
sensor = sensorObj.GPRS(0) # Instantiate a GPRS Module on UART 0
sensor = sensorObj.GPRS(0)
## Exit handlers ## ## Exit handlers ##
# This stops python from printing a stacktrace when you hit control-C # This stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Set the baud rate, 19200 baud is the default. # Set the baud rate, 19200 baud is the default.
if (sensor.setBaudRate(19200)): if (sensor.setBaudRate(19200)):
print "Failed to set baud rate" print "Failed to set baud rate"
sys.exit(0) sys.exit(0)
usageStr = ("Usage:\n"
"If an argument is supplied on the command line, that argument is\n"
"sent to the module and the response is printed out.\n\n"
"If no argument is used, then the manufacturer and the current\n"
"saved profiles are queried and the results printed out.\n\n")
print usageStr
usageStr = ("Usage:\n" # simple helper function to send a command and wait for a response
"If an argument is supplied on the command line, that argument is\n" def sendCommand(sensor, cmd):
"sent to the module and the response is printed out.\n\n"
"If no argument is used, then the manufacturer and the current\n"
"saved profiles are queried and the results printed out.\n\n")
print usageStr
# simple helper function to send a command and wait for a response
def sendCommand(sensor, cmd):
# commands need to be terminated with a carriage return # commands need to be terminated with a carriage return
cmd += "\r"; cmd += "\r";
sensor.writeDataStr(cmd) sensor.writeDataStr(cmd)
@ -67,11 +67,10 @@ def sendCommand(sensor, cmd):
else: else:
print "Timed out waiting for response" print "Timed out waiting for response"
if (len(sys.argv) > 1):
if (len(sys.argv) > 1):
print "Sending command line argument (" + sys.argv[1] + ")..." print "Sending command line argument (" + sys.argv[1] + ")..."
sendCommand(sensor, sys.argv[1]) sendCommand(sensor, sys.argv[1])
else: else:
# query the module manufacturer # query the module manufacturer
print "Querying module manufacturer (AT+CGMI)..." print "Querying module manufacturer (AT+CGMI)..."
sendCommand(sensor, "AT+CGMI"); sendCommand(sensor, "AT+CGMI");
@ -84,3 +83,6 @@ else:
# A comprehensive list is available from the datasheet at: # A comprehensive list is available from the datasheet at:
# http://www.seeedstudio.com/wiki/images/7/72/AT_Commands_v1.11.pdf # http://www.seeedstudio.com/wiki/images/7/72/AT_Commands_v1.11.pdf
if __name__ == '__main__':
main()

16
examples/python/grovebutton.py Normal file → Executable file
View File

@ -23,13 +23,17 @@
import time import time
import pyupm_grove as grove import pyupm_grove as grove
# Create the button object using GPIO pin 0 def main():
button = grove.GroveButton(0) # Create the button object using GPIO pin 0
button = grove.GroveButton(0)
# Read the input and print, waiting one second between readings # Read the input and print, waiting one second between readings
while 1: while 1:
print button.name(), ' value is ', button.value() print button.name(), ' value is ', button.value()
time.sleep(1) time.sleep(1)
# Delete the button object # Delete the button object
del button del button
if __name__ == '__main__':
main()

26
examples/python/grovecircularled.py Normal file → Executable file
View File

@ -25,26 +25,30 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_my9221 as upmGroveCircularLED import pyupm_my9221 as upmGroveCircularLED
# Exit handlers def main():
def SIGINTHandler(signum, frame): # Exit handlers
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
def exitHandler(): def exitHandler():
circle.setLevel(0, True) circle.setLevel(0, True)
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# This function lets you run code on exit # This function lets you run code on exit
atexit.register(exitHandler) atexit.register(exitHandler)
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Instantiate a Grove Circular LED on gpio pins 9 and 8 # Instantiate a Grove Circular LED on gpio pins 9 and 8
circle = upmGroveCircularLED.GroveCircularLED(9, 8) circle = upmGroveCircularLED.GroveCircularLED(9, 8)
level = 0 level = 0
while(1): while(1):
circle.setSpinner(level) circle.setSpinner(level)
level = (level + 1) % 24 level = (level + 1) % 24
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

36
examples/python/grovecollision.py Normal file → Executable file
View File

@ -24,34 +24,36 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_grovecollision as upmGrovecollision import pyupm_grovecollision as upmGrovecollision
# The was tested with the Grove Collision Sensor def main():
# Instantiate a Grove Collision on digital pin D2 # The was tested with the Grove Collision Sensor
myGrovecollision = upmGrovecollision.GroveCollision(2) # Instantiate a Grove Collision on digital pin D2
myGrovecollision = upmGrovecollision.GroveCollision(2)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myGrovecollision # including functions from myGrovecollision
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
collisionState = False
print "No collision"
collisionState = False while(1):
print "No collision"
while(1):
if (myGrovecollision.isColliding() and not collisionState): if (myGrovecollision.isColliding() and not collisionState):
print "Collision!" print "Collision!"
collisionState = True collisionState = True
elif (not myGrovecollision.isColliding() and collisionState): elif (not myGrovecollision.isColliding() and collisionState):
print "No collision" print "No collision"
collisionState = False collisionState = False
if __name__ == '__main__':
main()

39
examples/python/groveehr.py Normal file → Executable file
View File

@ -21,37 +21,35 @@
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_groveehr as upmGroveehr import pyupm_groveehr as upmGroveehr
# Instantiate a Grove Ear-clip Heart Rate sensor on digital pin D2 def main():
myHeartRateSensor = upmGroveehr.GroveEHR(2) # Instantiate a Grove Ear-clip Heart Rate sensor on digital pin D2
myHeartRateSensor = upmGroveehr.GroveEHR(2)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myHeartRateSensor # including functions from myHeartRateSensor
def exitHandler(): def exitHandler():
myHeartRateSensor.stopBeatCounter() myHeartRateSensor.stopBeatCounter()
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# set the beat counter to 0, init the clock and start counting beats
myHeartRateSensor.clearBeatCounter()
myHeartRateSensor.initClock()
myHeartRateSensor.startBeatCounter()
# set the beat counter to 0, init the clock and start counting beats while(1):
myHeartRateSensor.clearBeatCounter()
myHeartRateSensor.initClock()
myHeartRateSensor.startBeatCounter()
while(1):
# we grab these (millis and flowCount) just for display # we grab these (millis and flowCount) just for display
# purposes in this example # purposes in this example
millis = myHeartRateSensor.getMillis() millis = myHeartRateSensor.getMillis()
@ -66,3 +64,6 @@ while(1):
millis, beats, fr) millis, beats, fr)
print outputStr print outputStr
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

32
examples/python/groveeldriver.py Normal file → Executable file
View File

@ -24,30 +24,29 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_groveeldriver as upmGroveeldriver import pyupm_groveeldriver as upmGroveeldriver
# The was tested with the Grove El Driver Module def main():
# Instantiate a Grove El Driver on digital pin D2 # The was tested with the Grove El Driver Module
myEldriver = upmGroveeldriver.GroveElDriver(2) # Instantiate a Grove El Driver on digital pin D2
myEldriver = upmGroveeldriver.GroveElDriver(2)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myEldriver # This function lets you run code on exit, including functions from myEldriver
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
myEldriver.off() myEldriver.off()
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
lightState = True
lightState = True while(1):
while(1):
if (lightState): if (lightState):
myEldriver.on() myEldriver.on()
else: else:
@ -55,3 +54,6 @@ while(1):
lightState = not lightState lightState = not lightState
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

36
examples/python/groveelectromagnet.py Normal file → Executable file
View File

@ -24,32 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_groveelectromagnet as upmGroveelectromagnet import pyupm_groveelectromagnet as upmGroveelectromagnet
# This was tested with the Grove Electromagnetic Module def main():
# Instantiate a Grove Electromagnet on digital pin D2 # This was tested with the Grove Electromagnetic Module
myElectromagnet = upmGroveelectromagnet.GroveElectromagnet(2) # Instantiate a Grove Electromagnet on digital pin D2
myElectromagnet = upmGroveelectromagnet.GroveElectromagnet(2)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myElectromagnet # including functions from myElectromagnet
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
myElectromagnet.off() myElectromagnet.off()
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
magnetState = False
magnetState = False # Turn magnet on and off every 5 seconds
while(1):
# Turn magnet on and off every 5 seconds
while(1):
magnetState = not magnetState magnetState = not magnetState
if (magnetState): if (magnetState):
myElectromagnet.on() myElectromagnet.on()
@ -58,3 +57,6 @@ while(1):
print "Turning magnet", ("on" if magnetState else "off") print "Turning magnet", ("on" if magnetState else "off")
time.sleep(5) time.sleep(5)
if __name__ == '__main__':
main()

34
examples/python/groveemg.py Normal file → Executable file
View File

@ -24,29 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_groveemg as upmGroveemg import pyupm_groveemg as upmGroveemg
# Tested with the GroveEMG Muscle Signal Reader Sensor Module def main():
# Instantiate a GroveEMG on analog pin A0 # Tested with the GroveEMG Muscle Signal Reader Sensor Module
myEMG = upmGroveemg.GroveEMG(0) # Instantiate a GroveEMG on analog pin A0
myEMG = upmGroveemg.GroveEMG(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, including functions from myEMG # This lets you run code on exit, including functions from myEMG
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Calibrating...."
myEMG.calibrate()
print "Calibrating...." while (1):
myEMG.calibrate()
while (1):
print myEMG.value() print myEMG.value()
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

50
examples/python/grovegprs.py Normal file → Executable file
View File

@ -24,38 +24,38 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_grovegprs as sensorObj import pyupm_grovegprs as sensorObj
# Instantiate a GroveGPRS Module on UART 0 def main():
sensor = sensorObj.GroveGPRS(0) # Instantiate a GroveGPRS Module on UART 0
sensor = sensorObj.GroveGPRS(0)
## Exit handlers ## ## Exit handlers ##
# This stops python from printing a stacktrace when you hit control-C # This stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Set the baud rate, 19200 baud is the default. # Set the baud rate, 19200 baud is the default.
if (sensor.setBaudRate(19200)): if (sensor.setBaudRate(19200)):
print "Failed to set baud rate" print "Failed to set baud rate"
sys.exit(0) sys.exit(0)
usageStr = ("Usage:\n"
"If an argument is supplied on the command line, that argument is\n"
"sent to the module and the response is printed out.\n\n"
"If no argument is used, then the manufacturer and the current\n"
"saved profiles are queried and the results printed out.\n\n")
print usageStr
usageStr = ("Usage:\n" # simple helper function to send a command and wait for a response
"If an argument is supplied on the command line, that argument is\n" def sendCommand(sensor, cmd):
"sent to the module and the response is printed out.\n\n"
"If no argument is used, then the manufacturer and the current\n"
"saved profiles are queried and the results printed out.\n\n")
print usageStr
# simple helper function to send a command and wait for a response
def sendCommand(sensor, cmd):
# commands need to be terminated with a carriage return # commands need to be terminated with a carriage return
cmd += "\r"; cmd += "\r";
sensor.writeDataStr(cmd) sensor.writeDataStr(cmd)
@ -67,11 +67,10 @@ def sendCommand(sensor, cmd):
else: else:
print "Timed out waiting for response" print "Timed out waiting for response"
if (len(sys.argv) > 1):
if (len(sys.argv) > 1):
print "Sending command line argument (" + sys.argv[1] + ")..." print "Sending command line argument (" + sys.argv[1] + ")..."
sendCommand(sensor, sys.argv[1]) sendCommand(sensor, sys.argv[1])
else: else:
# query the module manufacturer # query the module manufacturer
print "Querying module manufacturer (AT+CGMI)..." print "Querying module manufacturer (AT+CGMI)..."
sendCommand(sensor, "AT+CGMI"); sendCommand(sensor, "AT+CGMI");
@ -84,3 +83,6 @@ else:
# A comprehensive list is available from the datasheet at: # A comprehensive list is available from the datasheet at:
# http://www.seeedstudio.com/wiki/images/7/72/AT_Commands_v1.11.pdf # http://www.seeedstudio.com/wiki/images/7/72/AT_Commands_v1.11.pdf
if __name__ == '__main__':
main()

34
examples/python/grovegsr.py Normal file → Executable file
View File

@ -24,30 +24,32 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_grovegsr as upmGrovegsr import pyupm_grovegsr as upmGrovegsr
# Tested with the GroveGSR Galvanic Skin Response Sensor module. def main():
# Tested with the GroveGSR Galvanic Skin Response Sensor module.
# Instantiate a GroveGSR on analog pin A0 # Instantiate a GroveGSR on analog pin A0
myGSR = upmGrovegsr.GroveGSR(0) myGSR = upmGrovegsr.GroveGSR(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, including functions from myGSR # This lets you run code on exit, including functions from myGSR
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Calibrating...."
myGSR.calibrate()
print "Calibrating...." while (1):
myGSR.calibrate()
while (1):
print myGSR.value() print myGSR.value()
time.sleep(.5) time.sleep(.5)
if __name__ == '__main__':
main()

22
examples/python/groveled.py Normal file → Executable file
View File

@ -23,19 +23,23 @@
import time import time
import pyupm_grove as grove import pyupm_grove as grove
# Create the Grove LED object using GPIO pin 2 def main():
led = grove.GroveLed(2) # Create the Grove LED object using GPIO pin 2
led = grove.GroveLed(2)
# Print the name # Print the name
print led.name() print led.name()
# Turn the LED on and off 10 times, pausing one second # Turn the LED on and off 10 times, pausing one second
# between transitions # between transitions
for i in range (0,10): for i in range (0,10):
led.on() led.on()
time.sleep(1) time.sleep(1)
led.off() led.off()
time.sleep(1) time.sleep(1)
# Delete the Grove LED object # Delete the Grove LED object
del led del led
if __name__ == '__main__':
main()

34
examples/python/groveledbar.py Normal file → Executable file
View File

@ -24,31 +24,30 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_my9221 as upmMy9221 import pyupm_my9221 as upmMy9221
# Instantiate a MY9221, we use D8 for the data, and D9 for the def main():
# data clock. This was tested with a Grove LED bar. # Instantiate a MY9221, we use D8 for the data, and D9 for the
myLEDBar = upmMy9221.GroveLEDBar(8, 9) # data clock. This was tested with a Grove LED bar.
myLEDBar = upmMy9221.GroveLEDBar(8, 9)
# Exit handlers
# Exit handlers def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
def exitHandler(): def exitHandler():
myLEDBar.setBarLevel(0, True) myLEDBar.setBarLevel(0, True)
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# This function lets you run code on exit # This function lets you run code on exit
atexit.register(exitHandler) atexit.register(exitHandler)
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
directionBool = True
level = 1
directionBool = True x = 0
level = 1 while(1):
x = 0
while(1):
# If it's less than 10 # If it's less than 10
# light up the LED now # light up the LED now
# call show_LED again in 50 ms # call show_LED again in 50 ms
@ -62,3 +61,6 @@ while(1):
time.sleep(1) time.sleep(1)
time.sleep(.05) time.sleep(.05)
x += 1 x += 1
if __name__ == '__main__':
main()

18
examples/python/grovelight.py Normal file → Executable file
View File

@ -23,15 +23,19 @@
import time import time
import pyupm_grove as grove import pyupm_grove as grove
# Create the light sensor object using AIO pin 0 def main():
light = grove.GroveLight(0) # Create the light sensor object using AIO pin 0
light = grove.GroveLight(0)
# Read the input and print both the raw value and a rough lux value, # Read the input and print both the raw value and a rough lux value,
# waiting one second between readings # waiting one second between readings
while 1: while 1:
print light.name() + " raw value is %d" % light.raw_value() + \ print light.name() + " raw value is %d" % light.raw_value() + \
", which is roughly %d" % light.value() + " lux"; ", which is roughly %d" % light.value() + " lux";
time.sleep(1) time.sleep(1)
# Delete the light sensor object # Delete the light sensor object
del light del light
if __name__ == '__main__':
main()

28
examples/python/grovelinefinder.py Normal file → Executable file
View File

@ -24,28 +24,30 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_grovelinefinder as upmGrovelinefinder import pyupm_grovelinefinder as upmGrovelinefinder
# Instantiate a Grove line finder sensor on digital pin D2 def main():
myLineFinder = upmGrovelinefinder.GroveLineFinder(2) # Instantiate a Grove line finder sensor on digital pin D2
myLineFinder = upmGrovelinefinder.GroveLineFinder(2)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myLineFinder # This function lets you run code on exit, including functions from myLineFinder
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while(1):
while(1):
if (myLineFinder.whiteDetected()): if (myLineFinder.whiteDetected()):
print "White detected." print "White detected."
else: else:
print "Black detected." print "Black detected."
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

37
examples/python/grovemd-stepper.py Normal file → Executable file
View File

@ -24,29 +24,32 @@
import time import time
import pyupm_grovemd as upmGrovemd import pyupm_grovemd as upmGrovemd
I2C_BUS = upmGrovemd.GROVEMD_I2C_BUS def main():
I2C_ADDR = upmGrovemd.GROVEMD_DEFAULT_I2C_ADDR I2C_BUS = upmGrovemd.GROVEMD_I2C_BUS
I2C_ADDR = upmGrovemd.GROVEMD_DEFAULT_I2C_ADDR
# Instantiate an I2C Grove Motor Driver on I2C bus 0 # Instantiate an I2C Grove Motor Driver on I2C bus 0
myMotorDriver = upmGrovemd.GroveMD(I2C_BUS, I2C_ADDR) myMotorDriver = upmGrovemd.GroveMD(I2C_BUS, I2C_ADDR)
# This example demonstrates using the GroveMD to drive a stepper motor # This example demonstrates using the GroveMD to drive a stepper motor
# configure it, for this example, we'll assume 200 steps per rev # configure it, for this example, we'll assume 200 steps per rev
myMotorDriver.configStepper(200) myMotorDriver.configStepper(200)
# set for half a rotation # set for half a rotation
myMotorDriver.setStepperSteps(100) myMotorDriver.setStepperSteps(100)
# let it go - clockwise rotation, 10 RPM speed # let it go - clockwise rotation, 10 RPM speed
myMotorDriver.enableStepper(upmGrovemd.GroveMD.STEP_DIR_CW, 10) myMotorDriver.enableStepper(upmGrovemd.GroveMD.STEP_DIR_CW, 10)
time.sleep(3) time.sleep(3)
# Now do it backwards... # Now do it backwards...
myMotorDriver.setStepperSteps(100) myMotorDriver.setStepperSteps(100)
myMotorDriver.enableStepper(upmGrovemd.GroveMD.STEP_DIR_CCW, 10) myMotorDriver.enableStepper(upmGrovemd.GroveMD.STEP_DIR_CCW, 10)
# now disable # now disable
myMotorDriver.disableStepper() myMotorDriver.disableStepper()
if __name__ == '__main__':
main()

35
examples/python/grovemd.py Normal file → Executable file
View File

@ -24,24 +24,27 @@
import time import time
import pyupm_grovemd as upmGrovemd import pyupm_grovemd as upmGrovemd
I2C_BUS = upmGrovemd.GROVEMD_I2C_BUS def main():
I2C_ADDR = upmGrovemd.GROVEMD_DEFAULT_I2C_ADDR I2C_BUS = upmGrovemd.GROVEMD_I2C_BUS
I2C_ADDR = upmGrovemd.GROVEMD_DEFAULT_I2C_ADDR
# Instantiate an I2C Grove Motor Driver on I2C bus 0 # Instantiate an I2C Grove Motor Driver on I2C bus 0
myMotorDriver = upmGrovemd.GroveMD(I2C_BUS, I2C_ADDR) myMotorDriver = upmGrovemd.GroveMD(I2C_BUS, I2C_ADDR)
# set direction to CW and set speed to 50%
print "Spin M1 and M2 at half speed for 3 seconds"
myMotorDriver.setMotorDirections(upmGrovemd.GroveMD.DIR_CW, upmGrovemd.GroveMD.DIR_CW)
myMotorDriver.setMotorSpeeds(127, 127)
# set direction to CW and set speed to 50% time.sleep(3)
print "Spin M1 and M2 at half speed for 3 seconds" # counter clockwise
myMotorDriver.setMotorDirections(upmGrovemd.GroveMD.DIR_CW, upmGrovemd.GroveMD.DIR_CW) print "Reversing M1 and M2 for 3 seconds"
myMotorDriver.setMotorSpeeds(127, 127) myMotorDriver.setMotorDirections(upmGrovemd.GroveMD.DIR_CCW,
upmGrovemd.GroveMD.DIR_CCW)
time.sleep(3)
time.sleep(3) print "Stopping motors"
# counter clockwise myMotorDriver.setMotorSpeeds(0, 0)
print "Reversing M1 and M2 for 3 seconds"
myMotorDriver.setMotorDirections(upmGrovemd.GroveMD.DIR_CCW,
upmGrovemd.GroveMD.DIR_CCW)
time.sleep(3)
print "Stopping motors" if __name__ == '__main__':
myMotorDriver.setMotorSpeeds(0, 0) main()

38
examples/python/grovemoisture.py Normal file → Executable file
View File

@ -24,32 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_grovemoisture as upmMoisture import pyupm_grovemoisture as upmMoisture
# Instantiate a Grove Moisture sensor on analog pin A0 def main():
myMoisture = upmMoisture.GroveMoisture(0) # Instantiate a Grove Moisture sensor on analog pin A0
myMoisture = upmMoisture.GroveMoisture(0)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myMoisture # This function lets you run code on exit, including functions from myMoisture
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Values (approximate):
# 0-300, sensor in air or dry soil
# 300-600, sensor in humid soil
# 600+, sensor in wet soil or submerged in water
# Values (approximate): # Read the value every second and print the corresponding moisture level
# 0-300, sensor in air or dry soil while(1):
# 300-600, sensor in humid soil
# 600+, sensor in wet soil or submerged in water
# Read the value every second and print the corresponding moisture level
while(1):
moisture_val = myMoisture.value() moisture_val = myMoisture.value()
if (moisture_val >= 0 and moisture_val < 300): if (moisture_val >= 0 and moisture_val < 300):
result = "Dry" result = "Dry"
@ -59,3 +58,6 @@ while(1):
result = "Wet" result = "Wet"
print "Moisture value: {0}, {1}".format(moisture_val, result) print "Moisture value: {0}, {1}".format(moisture_val, result)
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

30
examples/python/groveo2.py Normal file → Executable file
View File

@ -24,28 +24,30 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_groveo2 as upmGroveo2 import pyupm_groveo2 as upmGroveo2
# This was tested with the O2 Oxygen Concentration Sensor Module def main():
# Instantiate a GroveO2 on analog pin A0 # This was tested with the O2 Oxygen Concentration Sensor Module
myGroveO2 = upmGroveo2.GroveO2(0) # Instantiate a GroveO2 on analog pin A0
myGroveO2 = upmGroveo2.GroveO2(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, including functions from myGroveO2 # This lets you run code on exit, including functions from myGroveO2
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while(1):
while(1):
print "The output voltage is: {0}mV".format( print "The output voltage is: {0}mV".format(
myGroveO2.voltageValue()) myGroveO2.voltageValue())
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

22
examples/python/groverelay.py Normal file → Executable file
View File

@ -23,14 +23,15 @@
import time import time
import pyupm_grove as grove import pyupm_grove as grove
# Create the relay switch object using GPIO pin 0 def main():
relay = grove.GroveRelay(0) # Create the relay switch object using GPIO pin 0
relay = grove.GroveRelay(0)
# Close and then open the relay switch 3 times, # Close and then open the relay switch 3 times,
# waiting one second each time. The LED on the relay switch # waiting one second each time. The LED on the relay switch
# will light up when the switch is on (closed). # will light up when the switch is on (closed).
# The switch will also make a noise between transitions. # The switch will also make a noise between transitions.
for i in range (0,3): for i in range (0,3):
relay.on() relay.on()
if relay.isOn(): if relay.isOn():
print relay.name(), 'is on' print relay.name(), 'is on'
@ -40,5 +41,8 @@ for i in range (0,3):
print relay.name(), 'is off' print relay.name(), 'is off'
time.sleep(1) time.sleep(1)
# Delete the relay switch object # Delete the relay switch object
del relay del relay
if __name__ == '__main__':
main()

13
examples/python/groverotary.py Normal file → Executable file
View File

@ -23,12 +23,12 @@
from time import sleep from time import sleep
import pyupm_grove as grove import pyupm_grove as grove
# New knob on AIO pin 0 def main():
knob = grove.GroveRotary(0) # New knob on AIO pin 0
knob = grove.GroveRotary(0)
# Loop indefinitely
while True:
# Loop indefinitely
while True:
# Read values # Read values
abs = knob.abs_value() abs = knob.abs_value()
absdeg = knob.abs_deg() absdeg = knob.abs_deg()
@ -43,3 +43,6 @@ while True:
# Sleep for 2.5 s # Sleep for 2.5 s
sleep(2.5) sleep(2.5)
if __name__ == '__main__':
main()

32
examples/python/grovescam.py Normal file → Executable file
View File

@ -25,37 +25,41 @@
import sys import sys
import pyupm_grovescam as upmGrovescam import pyupm_grovescam as upmGrovescam
# Instantiate a Grove Serial Camera on UART 0 def main():
camera = upmGrovescam.GROVESCAM(0) # Instantiate a Grove Serial Camera on UART 0
camera = upmGrovescam.GROVESCAM(0)
# make sure port is initialized properly. 115200 baud is the default. # make sure port is initialized properly. 115200 baud is the default.
if (not camera.setupTty()): if (not camera.setupTty()):
print "Failed to setup tty port parameters" print "Failed to setup tty port parameters"
sys.exit(1) sys.exit(1)
if (camera.init()): if (camera.init()):
print "Initialized..." print "Initialized..."
else: else:
print "init() failed" print "init() failed"
if (camera.preCapture()): if (camera.preCapture()):
print "preCapture succeeded..." print "preCapture succeeded..."
else: else:
print "preCapture failed." print "preCapture failed."
if (camera.doCapture()): if (camera.doCapture()):
print "doCapture succeeded..." print "doCapture succeeded..."
else: else:
print "doCapture failed." print "doCapture failed."
print "Image size is", camera.getImageSize(), "bytes" print "Image size is", camera.getImageSize(), "bytes"
if (camera.getImageSize() > 0): if (camera.getImageSize() > 0):
print "Storing image.jpg..." print "Storing image.jpg..."
if (camera.storeImage("image.jpg")): if (camera.storeImage("image.jpg")):
print "storeImage succeeded..." print "storeImage succeeded..."
else: else:
print "storeImage failed." print "storeImage failed."
print "Exiting." print "Exiting."
sys.exit(0) sys.exit(0)
if __name__ == '__main__':
main()

13
examples/python/groveslide.py Normal file → Executable file
View File

@ -23,12 +23,12 @@
from time import sleep from time import sleep
import pyupm_grove as grove import pyupm_grove as grove
# New Grove Slider on AIO pin 0 def main():
slider = grove.GroveSlide(0) # New Grove Slider on AIO pin 0
slider = grove.GroveSlide(0)
# Loop indefinitely
while True:
# Loop indefinitely
while True:
# Read values # Read values
raw = slider.raw_value() raw = slider.raw_value()
volts = slider.voltage_value() volts = slider.voltage_value()
@ -37,3 +37,6 @@ while True:
# Sleep for 2.5 s # Sleep for 2.5 s
sleep(2.5) sleep(2.5)
if __name__ == '__main__':
main()

16
examples/python/grovespeaker.py Normal file → Executable file
View File

@ -24,11 +24,15 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_grovespeaker as upmGrovespeaker import pyupm_grovespeaker as upmGrovespeaker
# Instantiate a Grove Speaker on digital pin D2 def main():
mySpeaker = upmGrovespeaker.GroveSpeaker(2) # Instantiate a Grove Speaker on digital pin D2
mySpeaker = upmGrovespeaker.GroveSpeaker(2)
# Play all 7 of the lowest notes # Play all 7 of the lowest notes
mySpeaker.playAll() mySpeaker.playAll()
# Play a medium C-sharp # Play a medium C-sharp
mySpeaker.playSound('c', True, "med") mySpeaker.playSound('c', True, "med")
if __name__ == '__main__':
main()

20
examples/python/grovetemp.py Normal file → Executable file
View File

@ -24,18 +24,22 @@
import time import time
import pyupm_grove as grove import pyupm_grove as grove
# Create the temperature sensor object using AIO pin 0 def main():
temp = grove.GroveTemp(0) # Create the temperature sensor object using AIO pin 0
print temp.name() temp = grove.GroveTemp(0)
print temp.name()
# Read the temperature ten times, printing both the Celsius and # Read the temperature ten times, printing both the Celsius and
# equivalent Fahrenheit temperature, waiting one second between readings # equivalent Fahrenheit temperature, waiting one second between readings
for i in range(0, 10): for i in range(0, 10):
celsius = temp.value() celsius = temp.value()
fahrenheit = celsius * 9.0/5.0 + 32.0; fahrenheit = celsius * 9.0/5.0 + 32.0;
print "%d degrees Celsius, or %d degrees Fahrenheit" \ print "%d degrees Celsius, or %d degrees Fahrenheit" \
% (celsius, fahrenheit) % (celsius, fahrenheit)
time.sleep(1) time.sleep(1)
# Delete the temperature sensor object # Delete the temperature sensor object
del temp del temp
if __name__ == '__main__':
main()

30
examples/python/grovevdiv.py Normal file → Executable file
View File

@ -24,27 +24,26 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_grovevdiv as upmGrovevdiv import pyupm_grovevdiv as upmGrovevdiv
# Instantiate a Grove Voltage Divider sensor on analog pin A0 def main():
myVoltageDivider = upmGrovevdiv.GroveVDiv(0) # Instantiate a Grove Voltage Divider sensor on analog pin A0
myVoltageDivider = upmGrovevdiv.GroveVDiv(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, # This function lets you run code on exit,
# including functions from myVoltageDivider # including functions from myVoltageDivider
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while(1):
while(1):
val = myVoltageDivider.value(100) val = myVoltageDivider.value(100)
gain3val = myVoltageDivider.computedValue(3, val) gain3val = myVoltageDivider.computedValue(3, val)
gain10val = myVoltageDivider.computedValue(10, val) gain10val = myVoltageDivider.computedValue(10, val)
@ -52,3 +51,6 @@ while(1):
val, gain3val, gain10val) val, gain3val, gain10val)
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

28
examples/python/grovewater.py Normal file → Executable file
View File

@ -24,28 +24,30 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_grovewater as upmGrovewater import pyupm_grovewater as upmGrovewater
# Instantiate a Grove Water sensor on digital pin D2 def main():
myWaterSensor = upmGrovewater.GroveWater(2) # Instantiate a Grove Water sensor on digital pin D2
myWaterSensor = upmGrovewater.GroveWater(2)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myWaterSensor # This function lets you run code on exit, including functions from myWaterSensor
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while(1):
while(1):
if (myWaterSensor.isWet()): if (myWaterSensor.isWet()):
print "Sensor is wet" print "Sensor is wet"
else: else:
print "Sensor is dry" print "Sensor is dry"
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

36
examples/python/grovewfs.py Normal file → Executable file
View File

@ -24,32 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_grovewfs as upmGrovewfs import pyupm_grovewfs as upmGrovewfs
# Instantiate a Grove Water Flow Sensor on digital pin D2 def main():
myWaterFlow = upmGrovewfs.GroveWFS(2) # Instantiate a Grove Water Flow Sensor on digital pin D2
myWaterFlow = upmGrovewfs.GroveWFS(2)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, # This function lets you run code on exit,
# including functions from myWaterFlow # including functions from myWaterFlow
def exitHandler(): def exitHandler():
myWaterFlow.stopFlowCounter() myWaterFlow.stopFlowCounter()
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# set the flow counter to 0 and start counting
myWaterFlow.clearFlowCounter()
myWaterFlow.startFlowCounter()
# set the flow counter to 0 and start counting while (1):
myWaterFlow.clearFlowCounter()
myWaterFlow.startFlowCounter()
while (1):
# we grab these (millis and flowCount) just for display # we grab these (millis and flowCount) just for display
# purposes in this example # purposes in this example
millis = myWaterFlow.getMillis() millis = myWaterFlow.getMillis()
@ -62,3 +61,6 @@ while (1):
millis, flowCount, fr) millis, flowCount, fr)
print outputStr print outputStr
time.sleep(2) time.sleep(2)
if __name__ == '__main__':
main()

34
examples/python/gsr.py Normal file → Executable file
View File

@ -24,30 +24,32 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_gsr as upmGsr import pyupm_gsr as upmGsr
# Tested with the GSR Galvanic Skin Response Sensor module. def main():
# Tested with the GSR Galvanic Skin Response Sensor module.
# Instantiate a GSR on analog pin A0 # Instantiate a GSR on analog pin A0
myGSR = upmGsr.GSR(0) myGSR = upmGsr.GSR(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, including functions from myGSR # This lets you run code on exit, including functions from myGSR
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Calibrating...."
myGSR.calibrate()
print "Calibrating...." while (1):
myGSR.calibrate()
while (1):
print myGSR.value() print myGSR.value()
time.sleep(.5) time.sleep(.5)
if __name__ == '__main__':
main()

34
examples/python/guvas12d.py Normal file → Executable file
View File

@ -24,33 +24,35 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_guvas12d as upmUV import pyupm_guvas12d as upmUV
# Instantiate a UV sensor on analog pin A0 def main():
myUVSensor = upmUV.GUVAS12D(0); # Instantiate a UV sensor on analog pin A0
myUVSensor = upmUV.GUVAS12D(0);
# analog voltage, usually 3.3 or 5.0 # analog voltage, usually 3.3 or 5.0
GUVAS12D_AREF = 5.0; GUVAS12D_AREF = 5.0;
SAMPLES_PER_QUERY = 1024; SAMPLES_PER_QUERY = 1024;
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myUVSensor # This function lets you run code on exit, including functions from myUVSensor
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while(1):
while(1):
s = ("AREF: {0}, " s = ("AREF: {0}, "
"Voltage value (higher means more UV): " "Voltage value (higher means more UV): "
"{1}".format(GUVAS12D_AREF, "{1}".format(GUVAS12D_AREF,
myUVSensor.value(GUVAS12D_AREF, SAMPLES_PER_QUERY))) myUVSensor.value(GUVAS12D_AREF, SAMPLES_PER_QUERY)))
print s print s
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

44
examples/python/h3lis331dl.py Normal file → Executable file
View File

@ -24,39 +24,38 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_h3lis331dl as upmH3LIS331DL import pyupm_h3lis331dl as upmH3LIS331DL
# Instantiate an H3LIS331DL on I2C bus 0 def main():
myDigitalAccelerometer = upmH3LIS331DL.H3LIS331DL( # Instantiate an H3LIS331DL on I2C bus 0
myDigitalAccelerometer = upmH3LIS331DL.H3LIS331DL(
upmH3LIS331DL.H3LIS331DL_I2C_BUS, upmH3LIS331DL.H3LIS331DL_I2C_BUS,
upmH3LIS331DL.H3LIS331DL_DEFAULT_I2C_ADDR); upmH3LIS331DL.H3LIS331DL_DEFAULT_I2C_ADDR);
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myDigitalAccelerometer # This function lets you run code on exit, including functions from myDigitalAccelerometer
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Initialize the device with default values
myDigitalAccelerometer.init()
# Initialize the device with default values x = upmH3LIS331DL.new_intp()
myDigitalAccelerometer.init() y = upmH3LIS331DL.new_intp()
z = upmH3LIS331DL.new_intp()
x = upmH3LIS331DL.new_intp() ax = upmH3LIS331DL.new_floatp()
y = upmH3LIS331DL.new_intp() ay = upmH3LIS331DL.new_floatp()
z = upmH3LIS331DL.new_intp() az = upmH3LIS331DL.new_floatp()
ax = upmH3LIS331DL.new_floatp() while (1):
ay = upmH3LIS331DL.new_floatp()
az = upmH3LIS331DL.new_floatp()
while (1):
myDigitalAccelerometer.update() myDigitalAccelerometer.update()
myDigitalAccelerometer.getRawXYZ(x, y, z) myDigitalAccelerometer.getRawXYZ(x, y, z)
outputStr = ("Raw: X = {0}" outputStr = ("Raw: X = {0}"
@ -74,3 +73,6 @@ while (1):
upmH3LIS331DL.floatp_value(az)) upmH3LIS331DL.floatp_value(az))
print outputStr print outputStr
time.sleep(.5) time.sleep(.5)
if __name__ == '__main__':
main()

46
examples/python/h803x.py Normal file → Executable file
View File

@ -24,40 +24,41 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_h803x as sensorObj import pyupm_h803x as sensorObj
## Exit handlers ## def main():
# This function stops python from printing a stacktrace when you hit control-C ## Exit handlers ##
def SIGINTHandler(signum, frame): # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting..." print "Exiting..."
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
defaultDev = "/dev/ttyUSB0" defaultDev = "/dev/ttyUSB0"
# if an argument was specified, use it as the device instead # if an argument was specified, use it as the device instead
if (len(sys.argv) > 1): if (len(sys.argv) > 1):
defaultDev = sys.argv[1] defaultDev = sys.argv[1]
print "Using device", defaultDev print "Using device", defaultDev
print "Initializing..." print "Initializing..."
# Instantiate an H803X instance, using MODBUS slave address 1, and # Instantiate an H803X instance, using MODBUS slave address 1, and
# default comm parameters (9600, 8, N, 2) # default comm parameters (9600, 8, N, 2)
sensor = sensorObj.H803X(defaultDev, 1) sensor = sensorObj.H803X(defaultDev, 1)
# output the serial number and firmware revision # output the serial number and firmware revision
print "Slave ID:", sensor.getSlaveID() print "Slave ID:", sensor.getSlaveID()
print print
# update and print available values every second # update and print available values every second
while (1): while (1):
# update our values from the sensor # update our values from the sensor
sensor.update() sensor.update()
@ -104,3 +105,6 @@ while (1):
print print
time.sleep(2) time.sleep(2)
if __name__ == '__main__':
main()

32
examples/python/hdxxvxta.py Normal file → Executable file
View File

@ -24,28 +24,29 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_hdxxvxta as sensorObj import pyupm_hdxxvxta as sensorObj
## Exit handlers ## def main():
# This function stops python from printing a stacktrace when you hit control-C ## Exit handlers ##
def SIGINTHandler(signum, frame): # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Initializing..." print "Initializing..."
# Instantiate an HDXXVXTA instance, using A1 for humidity and A0 # Instantiate an HDXXVXTA instance, using A1 for humidity and A0
# for temperature # for temperature
sensor = sensorObj.HDXXVXTA(1, 0) sensor = sensorObj.HDXXVXTA(1, 0)
# update and print available values every second # update and print available values every second
while (1): while (1):
# update our values from the sensor # update our values from the sensor
sensor.update() sensor.update()
@ -57,3 +58,6 @@ while (1):
print print
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

30
examples/python/hka5.py Normal file → Executable file
View File

@ -24,26 +24,27 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_hka5 as sensorObj import pyupm_hka5 as sensorObj
# Instantiate a HKA5 sensor on uart 0. We don't use the set or def main():
# reset pins, so we pass -1 for them. # Instantiate a HKA5 sensor on uart 0. We don't use the set or
sensor = sensorObj.HKA5(0, -1, -1) # reset pins, so we pass -1 for them.
sensor = sensorObj.HKA5(0, -1, -1)
## Exit handlers ## ## Exit handlers ##
# This function stops python from printing a stacktrace when you hit control-C # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# update once every 2 seconds and output data # update once every 2 seconds and output data
while (True): while (True):
sensor.update() sensor.update()
print "PM 1 :", print "PM 1 :",
@ -60,3 +61,6 @@ while (True):
print print
time.sleep(2) time.sleep(2)
if __name__ == '__main__':
main()

59
examples/python/hm11.py Normal file → Executable file
View File

@ -24,45 +24,43 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_hm11 as upmHm11 import pyupm_hm11 as upmHm11
# Instantiate a HM11 BLE Module on UART 0 def main():
my_ble_obj = upmHm11.HM11(0) # Instantiate a HM11 BLE Module on UART 0
my_ble_obj = upmHm11.HM11(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, # This function lets you run code on exit,
# including functions from my_ble_obj # including functions from my_ble_obj
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
bufferLength = 256
bufferLength = 256 # make sure port is initialized properly. 9600 baud is the default.
if (not my_ble_obj.setupTty(upmHm11.cvar.int_B9600)):
# make sure port is initialized properly. 9600 baud is the default.
if (not my_ble_obj.setupTty(upmHm11.cvar.int_B9600)):
print "Failed to setup tty port parameters" print "Failed to setup tty port parameters"
sys.exit(0) sys.exit(0)
usageStr = ("Usage:\n"
"Pass a commandline argument (any argument) to this program\n"
"to query the radio configuration and output it. NOTE: the\n"
"radio must be in CONFIG mode for this to work.\n\n"
"Running this program without arguments will simply transmit\n"
"'Hello World!' every second, and output any data received from\n"
"another radio.\n\n")
print usageStr
usageStr = ("Usage:\n" # simple helper function to send a command and wait for a response
"Pass a commandline argument (any argument) to this program\n" def sendCommand(bleObj, cmd):
"to query the radio configuration and output it. NOTE: the\n"
"radio must be in CONFIG mode for this to work.\n\n"
"Running this program without arguments will simply transmit\n"
"'Hello World!' every second, and output any data received from\n"
"another radio.\n\n")
print usageStr
# simple helper function to send a command and wait for a response
def sendCommand(bleObj, cmd):
bleBuffer = upmHm11.charArray(bufferLength) bleBuffer = upmHm11.charArray(bufferLength)
bleObj.writeData(cmd, len(cmd)) bleObj.writeData(cmd, len(cmd))
@ -81,11 +79,10 @@ def sendCommand(bleObj, cmd):
else: else:
print "Timed out waiting for response" print "Timed out waiting for response"
if (len(sys.argv) > 1):
if (len(sys.argv) > 1):
print "Sending command line argument (" + sys.argv[1] + ")..." print "Sending command line argument (" + sys.argv[1] + ")..."
sendCommand(my_ble_obj, sys.argv[1]) sendCommand(my_ble_obj, sys.argv[1])
else: else:
# query the module address # query the module address
addr = "AT+ADDR?"; addr = "AT+ADDR?";
print "Querying module address (" + addr + ")..." print "Querying module address (" + addr + ")..."
@ -108,3 +105,5 @@ else:
# A comprehensive list is available from the datasheet at: # A comprehensive list is available from the datasheet at:
# http://www.seeedstudio.com/wiki/images/c/cd/Bluetooth4_en.pdf # http://www.seeedstudio.com/wiki/images/c/cd/Bluetooth4_en.pdf
if __name__ == '__main__':
main()

15
examples/python/hmc5883l.py Normal file → Executable file
View File

@ -23,13 +23,13 @@
from time import sleep from time import sleep
import pyupm_hmc5883l as hmc5883l import pyupm_hmc5883l as hmc5883l
# Create an I2C compass object and set declination def main():
hmc = hmc5883l.Hmc5883l(0) # Create an I2C compass object and set declination
hmc.set_declination(0.2749) hmc = hmc5883l.Hmc5883l(0)
hmc.set_declination(0.2749)
# Loop indefinitely
while True:
# Loop indefinitely
while True:
hmc.update() # Update the data hmc.update() # Update the data
pos = hmc.coordinates() # Read raw coordinates pos = hmc.coordinates() # Read raw coordinates
hdg = hmc.heading() # Read heading hdg = hmc.heading() # Read heading
@ -42,3 +42,6 @@ while True:
# Sleep for 1 s # Sleep for 1 s
sleep(1) sleep(1)
if __name__ == '__main__':
main()

90
examples/python/hmtrp.py Normal file → Executable file
View File

@ -24,66 +24,63 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_hmtrp as upmHmtrp import pyupm_hmtrp as upmHmtrp
# Instantiate a HMTRP radio device on uart 0 def main():
my_HMTRP_Radio = upmHmtrp.HMTRP(0) # Instantiate a HMTRP radio device on uart 0
my_HMTRP_Radio = upmHmtrp.HMTRP(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, # This function lets you run code on exit,
# including functions from my_HMTRP_Radio # including functions from my_HMTRP_Radio
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
myCounter = 0
myCounter = 0 # normal read/write mode
bufferLength = 256
radioBuffer = upmHmtrp.charArray(bufferLength)
# normal read/write mode # make sure port is initialized properly. 9600 baud is the default.
bufferLength = 256 if (not my_HMTRP_Radio.setupTty(upmHmtrp.cvar.int_B9600)):
radioBuffer = upmHmtrp.charArray(bufferLength)
# make sure port is initialized properly. 9600 baud is the default.
if (not my_HMTRP_Radio.setupTty(upmHmtrp.cvar.int_B9600)):
print "Failed to setup tty port parameters" print "Failed to setup tty port parameters"
sys.exit(0) sys.exit(0)
usageStr = ("Usage:\n"
"Pass a commandline argument (any argument) to this program\n"
"to query the radio configuration and output it. NOTE: the\n"
"radio must be in CONFIG mode for this to work.\n\n"
"Running this program without arguments will simply transmit\n"
"'Hello World!' every second, and output any data received from\n"
"another radio.\n\n")
print usageStr
usageStr = ("Usage:\n" '''
"Pass a commandline argument (any argument) to this program\n" By default, this radio simply transmits data sent via writeData()
"to query the radio configuration and output it. NOTE: the\n" and reads any available data via readData().
"radio must be in CONFIG mode for this to work.\n\n"
"Running this program without arguments will simply transmit\n"
"'Hello World!' every second, and output any data received from\n"
"another radio.\n\n")
print usageStr
''' It can be placed into a configuration mode by grounding the
By default, this radio simply transmits data sent via writeData() CONFIG pin on the module. When this is done, the various
and reads any available data via readData(). configuration query and config methods can be used. In this
example, by default, we just read any data available fom the
device, and periodically transmit "Hello World".
It can be placed into a configuration mode by grounding the If any argument was specified on the command line, do a simple
CONFIG pin on the module. When this is done, the various configuration query and output the results. The radio must be in
configuration query and config methods can be used. In this CONFIG mode for this to work.
example, by default, we just read any data available fom the
device, and periodically transmit "Hello World".
If any argument was specified on the command line, do a simple Note that the first command-line argument should be "hmtry.py"
configuration query and output the results. The radio must be in The data we want would be the second... if it exists
CONFIG mode for this to work. '''
if (len(sys.argv) > 1):
Note that the first command-line argument should be "hmtry.py"
The data we want would be the second... if it exists
'''
if (len(sys.argv) > 1):
# config mode # config mode
freq = upmHmtrp.uint32Array(0) freq = upmHmtrp.uint32Array(0)
dataRate = upmHmtrp.uint32Array(0) dataRate = upmHmtrp.uint32Array(0)
@ -109,7 +106,7 @@ if (len(sys.argv) > 1):
errString = ("getConfig() failed. Make sure the radio " errString = ("getConfig() failed. Make sure the radio "
"is in CONFIG mode.") "is in CONFIG mode.")
print errString print errString
else: else:
print "Running in normal read/write mode." print "Running in normal read/write mode."
while (1): while (1):
# we don't want the read to block in this example, so always # we don't want the read to block in this example, so always
@ -141,3 +138,6 @@ else:
my_HMTRP_Radio.writeData(msg, (len(msg) + 1)) my_HMTRP_Radio.writeData(msg, (len(msg) + 1))
myCounter = 0 myCounter = 0
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

31
examples/python/hp20x.py Normal file → Executable file
View File

@ -24,31 +24,34 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_hp20x as barometerObj import pyupm_hp20x as barometerObj
## Exit handlers ## def main():
# This stops python from printing a stacktrace when you hit control-C ## Exit handlers ##
def SIGINTHandler(signum, frame): # This stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, # This function lets you run code on exit,
# including functions from ringCoder # including functions from ringCoder
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Instantiate an HP20X on default I2C bus and address # Instantiate an HP20X on default I2C bus and address
bar = barometerObj.HP20X() bar = barometerObj.HP20X()
# Initialize the device with default values # Initialize the device with default values
bar.init() bar.init()
while(1): while(1):
print "Temperature:", bar.getTemperature(), "Celsius" print "Temperature:", bar.getTemperature(), "Celsius"
print "Pressure: ", bar.getPressure(), "Millibars" print "Pressure: ", bar.getPressure(), "Millibars"
print "Altitude: ", bar.getAltitude(), "Meters" print "Altitude: ", bar.getAltitude(), "Meters"
print print
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

33
examples/python/ht9170.py Normal file → Executable file
View File

@ -24,31 +24,34 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ht9170 as upmHt9170 import pyupm_ht9170 as upmHt9170
# Instantiate a DTMF decoder def main():
myDTMF = upmHt9170.HT9170(12, 11, 10, 9, 8) # Instantiate a DTMF decoder
myDTMF = upmHt9170.HT9170(12, 11, 10, 9, 8)
## Exit handlers ## ## Exit handlers ##
# This stops python from printing a stacktrace when you hit control-C # This stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame): def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, including functions from myDTMF # This lets you run code on exit, including functions from myDTMF
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Now we just spin in a loop, sleeping every 100ms, checking to see
# Now we just spin in a loop, sleeping every 100ms, checking to see # if a digit is available. If so, we decode and print the digit,
# if a digit is available. If so, we decode and print the digit, # and continue looping.
# and continue looping. while (1):
while (1):
if (dtmf_obj.digitReady()): if (dtmf_obj.digitReady()):
print "Got DTMF code:", dtmf_obj.decodeDigit() print "Got DTMF code:", dtmf_obj.decodeDigit()
# now spin until digitReady() goes false again # now spin until digitReady() goes false again
while (dtmf.digitReady()): while (dtmf.digitReady()):
pass pass
time.sleep(.1) time.sleep(.1)
if __name__ == '__main__':
main()

52
examples/python/hwxpxx.py Normal file → Executable file
View File

@ -24,44 +24,45 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_hwxpxx as sensorObj import pyupm_hwxpxx as sensorObj
## Exit handlers ## def main():
# This function stops python from printing a stacktrace when you hit control-C ## Exit handlers ##
def SIGINTHandler(signum, frame): # This function stops python from printing a stacktrace when you hit control-C
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit # This function lets you run code on exit
def exitHandler(): def exitHandler():
print "Exiting..." print "Exiting..."
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
defaultDev = "/dev/ttyUSB0" defaultDev = "/dev/ttyUSB0"
# if an argument was specified, use it as the device instead # if an argument was specified, use it as the device instead
if (len(sys.argv) > 1): if (len(sys.argv) > 1):
defaultDev = sys.argv[1] defaultDev = sys.argv[1]
print "Using device", defaultDev print "Using device", defaultDev
print "Initializing..." print "Initializing..."
# Instantiate an HWXPXX instance, using MODBUS slave address 3, and # Instantiate an HWXPXX instance, using MODBUS slave address 3, and
# default comm parameters (19200, 8, N, 2) # default comm parameters (19200, 8, N, 2)
sensor = sensorObj.HWXPXX(defaultDev, 3) sensor = sensorObj.HWXPXX(defaultDev, 3)
# output the serial number and firmware revision # output the serial number and firmware revision
print "Slave ID:", sensor.getSlaveID() print "Slave ID:", sensor.getSlaveID()
# stored temperature and humidity offsets # stored temperature and humidity offsets
print "Temperature Offset:", sensor.getTemperatureOffset() print "Temperature Offset:", sensor.getTemperatureOffset()
print "Humidity Offset:", sensor.getHumidityOffset() print "Humidity Offset:", sensor.getHumidityOffset()
print print
# update and print available values every second # update and print available values every second
while (1): while (1):
# update our values from the sensor # update our values from the sensor
sensor.update() sensor.update()
@ -77,3 +78,6 @@ while (1):
print print
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

84
examples/python/ili9341.py Normal file → Executable file
View File

@ -24,52 +24,56 @@
import time import time
import pyupm_ili9341 as ili9341 import pyupm_ili9341 as ili9341
# Pins (Edison) def main():
# CS_LCD GP44 (MRAA 31) # Pins (Edison)
# CS_SD GP43 (MRAA 38) unused # CS_LCD GP44 (MRAA 31)
# DC GP12 (MRAA 20) # CS_SD GP43 (MRAA 38) unused
# RESEST GP13 (MRAA 14) # DC GP12 (MRAA 20)
lcd = ili9341.ILI9341(31, 38, 20, 14) # RESEST GP13 (MRAA 14)
lcd = ili9341.ILI9341(31, 38, 20, 14)
# Fill the screen with a solid color # Fill the screen with a solid color
lcd.fillScreen(lcd.color565(0, 40, 16)) lcd.fillScreen(lcd.color565(0, 40, 16))
# Draw some shapes # Draw some shapes
lcd.drawFastVLine(10, 10, 100, ili9341.ILI9341_RED) lcd.drawFastVLine(10, 10, 100, ili9341.ILI9341_RED)
lcd.drawFastHLine(20, 10, 50, ili9341.ILI9341_CYAN) lcd.drawFastHLine(20, 10, 50, ili9341.ILI9341_CYAN)
lcd.drawLine(160, 30, 200, 60, ili9341.ILI9341_GREEN) lcd.drawLine(160, 30, 200, 60, ili9341.ILI9341_GREEN)
lcd.fillRect(20, 30, 75, 60, ili9341.ILI9341_ORANGE) lcd.fillRect(20, 30, 75, 60, ili9341.ILI9341_ORANGE)
lcd.drawCircle(70, 50, 20, ili9341.ILI9341_PURPLE) lcd.drawCircle(70, 50, 20, ili9341.ILI9341_PURPLE)
lcd.fillCircle(120, 50, 20, ili9341.ILI9341_PURPLE) lcd.fillCircle(120, 50, 20, ili9341.ILI9341_PURPLE)
lcd.drawTriangle(50, 100, 10, 140, 90, 140, ili9341.ILI9341_YELLOW) lcd.drawTriangle(50, 100, 10, 140, 90, 140, ili9341.ILI9341_YELLOW)
lcd.fillTriangle(150, 100, 110, 140, 190, 140, ili9341.ILI9341_YELLOW) lcd.fillTriangle(150, 100, 110, 140, 190, 140, ili9341.ILI9341_YELLOW)
lcd.drawRoundRect(20, 150, 50, 30, 10, ili9341.ILI9341_RED) lcd.drawRoundRect(20, 150, 50, 30, 10, ili9341.ILI9341_RED)
lcd.drawRoundRect(130, 150, 50, 30, 10, ili9341.ILI9341_RED) lcd.drawRoundRect(130, 150, 50, 30, 10, ili9341.ILI9341_RED)
lcd.fillRoundRect(75, 150, 50, 30, 10, ili9341.ILI9341_RED) lcd.fillRoundRect(75, 150, 50, 30, 10, ili9341.ILI9341_RED)
# Write some text # Write some text
lcd.setCursor(0, 200) lcd.setCursor(0, 200)
lcd.setTextColor(ili9341.ILI9341_LIGHTGREY) lcd.setTextColor(ili9341.ILI9341_LIGHTGREY)
lcd.setTextWrap(True) lcd.setTextWrap(True)
lcd.setTextSize(1) lcd.setTextSize(1)
lcd._print("Text 1\n") lcd._print("Text 1\n")
lcd.setTextSize(2) lcd.setTextSize(2)
lcd._print("Text 2\n") lcd._print("Text 2\n")
lcd.setTextSize(3) lcd.setTextSize(3)
lcd._print("Text 3\n") lcd._print("Text 3\n")
lcd.setTextSize(4) lcd.setTextSize(4)
lcd._print("Text 4\n") lcd._print("Text 4\n")
# Test screen rotation # Test screen rotation
for r in range(0, 4): for r in range(0, 4):
lcd.setRotation(r) lcd.setRotation(r)
lcd.fillRect(0, 0, 5, 5, ili9341.ILI9341_WHITE) lcd.fillRect(0, 0, 5, 5, ili9341.ILI9341_WHITE)
time.sleep(1) time.sleep(1)
# Invert colors, wait, then revert back # Invert colors, wait, then revert back
lcd.invertDisplay(True) lcd.invertDisplay(True)
time.sleep(2) time.sleep(2)
lcd.invertDisplay(False) lcd.invertDisplay(False)
# Don't forget to free up that memory! # Don't forget to free up that memory!
del lcd del lcd
if __name__ == '__main__':
main()

33
examples/python/ina132.py Normal file → Executable file
View File

@ -21,31 +21,32 @@
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_ina132 as upmIna132 import pyupm_ina132 as upmIna132
# Tested with the INA132 Differential Amplifier Sensor module. def main():
# Instantiate an INA132 on analog pin A0 # Tested with the INA132 Differential Amplifier Sensor module.
myDifferentialAmplifier = upmIna132.INA132(0) # Instantiate an INA132 on analog pin A0
myDifferentialAmplifier = upmIna132.INA132(0)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myDifferentialAmplifier # including functions from myDifferentialAmplifier
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
while(1):
while(1):
print myDifferentialAmplifier.value() print myDifferentialAmplifier.value()
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

55
examples/python/isd1820.py Normal file → Executable file
View File

@ -24,20 +24,19 @@
import time, sys, atexit import time, sys, atexit
import pyupm_isd1820 as upmIsd1820 import pyupm_isd1820 as upmIsd1820
# Instantiate a ISD1820 on digital pins 2 (play) and 3 (record) def main():
# This example was tested on the Grove Recorder. # Instantiate a ISD1820 on digital pins 2 (play) and 3 (record)
myRecorder = upmIsd1820.ISD1820(2, 3) # This example was tested on the Grove Recorder.
myRecorder = upmIsd1820.ISD1820(2, 3)
doRecord = False
doRecord = False if len(sys.argv) > 1:
if len(sys.argv) > 1:
doRecord = True doRecord = True
# This lets you run code on exit,
# This lets you run code on exit, # including functions from myRecorder
# including functions from myRecorder def exitHandler():
def exitHandler():
# turn off whatever we were doing. # turn off whatever we were doing.
if (doRecord): if (doRecord):
myRecorder.record(False) myRecorder.record(False)
@ -46,29 +45,29 @@ def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
# if an argument was specified (any argument), go into record mode,
# else playback a previously recorded sample
# if an argument was specified (any argument), go into record mode, print "Supply any argument to the command line to record."
# else playback a previously recorded sample print "Running this example without arguments will play back any "
print "previously recorded sound."
print "There is approximately 10 seconds of recording time.\n"
print "Supply any argument to the command line to record." # depending on what was selected, do it, and sleep for 15 seconds
print "Running this example without arguments will play back any " if (doRecord):
print "previously recorded sound."
print "There is approximately 10 seconds of recording time.\n"
# depending on what was selected, do it, and sleep for 15 seconds
if (doRecord):
myRecorder.record(True) myRecorder.record(True)
else: else:
myRecorder.play(True) myRecorder.play(True)
# There are about 10 seconds of recording/playback time, so we will # There are about 10 seconds of recording/playback time, so we will
# sleep for a little extra time. # sleep for a little extra time.
print "Sleeping for 15 seconds..." print "Sleeping for 15 seconds..."
time.sleep(15) time.sleep(15)
# exitHandler runs automatically
# exitHandler runs automatically if __name__ == '__main__':
main()

14
examples/python/itg3200.py Normal file → Executable file
View File

@ -23,10 +23,11 @@
import time import time
import pyupm_itg3200 as itg3200 import pyupm_itg3200 as itg3200
# Create an I2C gyro object def main():
gyro = itg3200.Itg3200(0) # Create an I2C gyro object
gyro = itg3200.Itg3200(0)
while(1): while(1):
gyro.update() # Update the data gyro.update() # Update the data
rot = gyro.getRawValues() # Read raw sensor data rot = gyro.getRawValues() # Read raw sensor data
ang = gyro.getRotation() # Read rotational speed (deg/sec) ang = gyro.getRotation() # Read rotational speed (deg/sec)
@ -38,5 +39,8 @@ while(1):
print ' ' print ' '
time.sleep(1) time.sleep(1)
# Delete the gyro object # Delete the gyro object
del gyro del gyro
if __name__ == '__main__':
main()

24
examples/python/jhd1313m1-lcd.py Normal file → Executable file
View File

@ -23,16 +23,20 @@
import pyupm_i2clcd as lcd import pyupm_i2clcd as lcd
# Initialize Jhd1313m1 at 0x3E (LCD_ADDRESS) and 0x62 (RGB_ADDRESS) def main():
myLcd = lcd.Jhd1313m1(0, 0x3E, 0x62) # Initialize Jhd1313m1 at 0x3E (LCD_ADDRESS) and 0x62 (RGB_ADDRESS)
myLcd = lcd.Jhd1313m1(0, 0x3E, 0x62)
myLcd.setCursor(0,0) myLcd.setCursor(0,0)
# RGB Blue # RGB Blue
#myLcd.setColor(53, 39, 249) #myLcd.setColor(53, 39, 249)
# RGB Red # RGB Red
myLcd.setColor(255, 0, 0) myLcd.setColor(255, 0, 0)
myLcd.write('Hello World') myLcd.write('Hello World')
myLcd.setCursor(1,2) myLcd.setCursor(1,2)
myLcd.write('Hello World') myLcd.write('Hello World')
if __name__ == '__main__':
main()

30
examples/python/joystick12.py Normal file → Executable file
View File

@ -24,29 +24,31 @@
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_joystick12 as upmJoystick12 import pyupm_joystick12 as upmJoystick12
# Instantiate a joystick on analog pins A0 and A1 def main():
myJoystick = upmJoystick12.Joystick12(0, 1) # Instantiate a joystick on analog pins A0 and A1
myJoystick = upmJoystick12.Joystick12(0, 1)
## Exit handlers ##
## Exit handlers ## # This function stops python from printing a stacktrace when you hit control-C
# This function stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This function lets you run code on exit, including functions from myJoystick # This function lets you run code on exit, including functions from myJoystick
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
# Print the X and Y input values every second
# Print the X and Y input values every second while(1):
while(1):
XString = "Driving X:" + str(myJoystick.getXInput()) XString = "Driving X:" + str(myJoystick.getXInput())
YString = ": and Y:" + str(myJoystick.getYInput()) YString = ": and Y:" + str(myJoystick.getYInput())
print XString + YString print XString + YString
time.sleep(1) time.sleep(1)
if __name__ == '__main__':
main()

57
examples/python/l298-stepper.py Normal file → Executable file
View File

@ -21,47 +21,48 @@
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_l298 as upmL298 import pyupm_l298 as upmL298
# Instantiate a Stepper motor on a L298 Dual H-Bridge. def main():
# This was tested with the NEMA-17 12V, 350mA, with 200 steps per rev. # Instantiate a Stepper motor on a L298 Dual H-Bridge.
myHBridge = upmL298.L298(200, 3, 4, 7, 8, 9) # This was tested with the NEMA-17 12V, 350mA, with 200 steps per rev.
myHBridge = upmL298.L298(200, 3, 4, 7, 8, 9)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myHBridge # including functions from myHBridge
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
myHBridge.setSpeed(10) # 10 RPMs
myHBridge.setDirection(upmL298.L298.DIR_CW)
myHBridge.enable(True)
myHBridge.setSpeed(10) # 10 RPMs print "Rotating 1 full revolution at 10 RPM speed."
myHBridge.setDirection(upmL298.L298.DIR_CW) # move 200 steps, a full rev
myHBridge.enable(True) myHBridge.stepperSteps(200)
print "Rotating 1 full revolution at 10 RPM speed." print "Sleeping for 2 seconds..."
# move 200 steps, a full rev time.sleep(2)
myHBridge.stepperSteps(200)
print "Sleeping for 2 seconds..." print "Rotating 1/2 revolution in opposite direction at 10 RPM speed."
time.sleep(2) myHBridge.setDirection(upmL298.L298.DIR_CCW)
myHBridge.stepperSteps(100)
print "Rotating 1/2 revolution in opposite direction at 10 RPM speed." # release
myHBridge.setDirection(upmL298.L298.DIR_CCW) myHBridge.enable(False)
myHBridge.stepperSteps(100)
# release # exitHandler is called automatically
myHBridge.enable(False)
# exitHandler is called automatically if __name__ == '__main__':
main()

55
examples/python/l298.py Normal file → Executable file
View File

@ -21,45 +21,46 @@
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import time, sys, signal, atexit import time, sys, signal, atexit
import pyupm_l298 as upmL298 import pyupm_l298 as upmL298
# Instantiate one of the 2 possible DC motors on a L298 Dual def main():
# H-Bridge. For controlling a stepper motor, see the l298-stepper # Instantiate one of the 2 possible DC motors on a L298 Dual
# example. # H-Bridge. For controlling a stepper motor, see the l298-stepper
myHBridge = upmL298.L298(3, 4, 7) # example.
myHBridge = upmL298.L298(3, 4, 7)
## Exit handlers ##
## Exit handlers ## # This stops python from printing a stacktrace when you hit control-C
# This stops python from printing a stacktrace when you hit control-C def SIGINTHandler(signum, frame):
def SIGINTHandler(signum, frame):
raise SystemExit raise SystemExit
# This lets you run code on exit, # This lets you run code on exit,
# including functions from myHBridge # including functions from myHBridge
def exitHandler(): def exitHandler():
print "Exiting" print "Exiting"
sys.exit(0) sys.exit(0)
# Register exit handlers # Register exit handlers
atexit.register(exitHandler) atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler) signal.signal(signal.SIGINT, SIGINTHandler)
print "Starting motor at 50% for 3 seconds..."
myHBridge.setSpeed(50)
myHBridge.setDirection(upmL298.L298.DIR_CW)
myHBridge.enable(True)
print "Starting motor at 50% for 3 seconds..." time.sleep(3)
myHBridge.setSpeed(50)
myHBridge.setDirection(upmL298.L298.DIR_CW)
myHBridge.enable(True)
time.sleep(3) print "Reversing direction..."
myHBridge.setDirection(upmL298.L298.DIR_NONE) # fast stop
myHBridge.setDirection(upmL298.L298.DIR_CCW)
time.sleep(3);
print "Reversing direction..." myHBridge.setSpeed(0)
myHBridge.setDirection(upmL298.L298.DIR_NONE) # fast stop myHBridge.enable(False)
myHBridge.setDirection(upmL298.L298.DIR_CCW)
time.sleep(3);
myHBridge.setSpeed(0) # exitHandler is called automatically
myHBridge.enable(False)
# exitHandler is called automatically if __name__ == '__main__':
main()

Some files were not shown because too many files have changed in this diff Show More