//
// main task
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#endif
/*************************************************************************
*
* your setup code here
*
**************************************************************************/
myBLE ble;
ble.enable();
bleTest test(ble);
CPin led(LED1);
while(1) {
/**********************************************************************
*
* your loop code here
*
**********************************************************************/
led = !led;
sleep(100);
if ( dbg.available() ) {
switch(dbg.parseInt()) {
case 0:
DBG("BLE TEST OFF\n");
test.interface(BLE_TEST_OFF);
break;
case 1:
DBG("BLE TEST OVER UART\n");
test.interface(BLE_TEST_OVER_UART);
break;
case 2:
DBG("BLE TEST OVER ACI\n");
test.interface(BLE_TEST_OVER_ACI);
}
}
}
return 0 ;
}
//
// main task
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#endif
/*************************************************************************
*
* your setup code here
*
**************************************************************************/
//
// LED Demo (can be removed)
//
uint8_t i = 0;
CBus port(LED1, LED2, LED3, LED4, END);
port.output(); // set all pins as output
while(1) {
/**********************************************************************
*
* your loop code here
*
**********************************************************************/
//
// LED Demo (can be removed)
//
port = led_scripts[i];
i = (i+1) < (int)sizeof(led_scripts) ? i+1 : 0;
sleep(100);
}
return 0 ;
}
//
// main task
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#endif
/*************************************************************************
*
* your setup code here
*
**************************************************************************/
// start the GC Test Thread
gcLED gc;
gc.start("gc", 48);
// send Pin to mailbox
send_mail_test();
while(1) {
/**********************************************************************
*
* your loop code here
*
**********************************************************************/
switch(dbg.isAnyKey()) {
//
// in DEBUG mode, press 'a' to test the 'auto_release_test()'
//
case 'a':
auto_release_test();
break;
}
}
return 0 ;
}
//
// main loop
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#else
#undef __USE_USB
#endif
/*************************************************************************
*
* your setup code here
*
**************************************************************************/
//
// BLE Engine (Serial Stream)
//
myBLE ble;
ble.advertising(100, -59); // set adv. interval = 100ms, calibrater tx power = -59dBm
ble.enable(); // start the ble engine first!!
//
// Device Information Service
//
bleDeviceInfo info(ble);
info.setManufactureName(u8"英倍達國際"); // u8 mean to use the UTF-8 string
info.setModelNumber("nano11U37");
info.setSerialNumber("140226000");
info.setFirmwareRevision(uCXpresso_VER_STR);
info.setHardwareRevision("R1");
info.setPnP(VS_USB, 1, 2, 0x3456); // vendor Id=1, product Id = 2, product ver. = 0x3456
SYS_ID_T sysId = {
{0x00, 0x01, 0x02, 0x03, 0x04}, // Manufacturer Identifier
{0x05, 0x06, 0x07} // Organizationally Unique Identifier
};
info.setSystemId(sysId);
//
// Proximity Service
//
myProximity alert(ble); // declare Proximity Service (Immediate alert + Lose Link)
//
// Battery Level Service
//
bleBatteryLevel bl(ble); // declare Battery Level Service object
//
// Health Thermometer Service
//
bleHealthThermometer ht(ble); // declare Health Thermometer Service object
ht.measurementInterval(1); // set measurement interval = 1 second
//
// Arduino Firmata
//
myFirmata.begin(ble); // begin the Firmata Object with the ble serial stream.
callback_init(); // initialize the callback functions for myFirmata Object.
//
// A key input for Alert (for Proximity)
//
CPin keyAlert(P8); // define P8 as a push button
keyAlert.input();
PIN_LEVEL_T pinVal = keyAlert;
//
// Timeout for time interval
//
CTimeout t1, t2, t3; // t1=analog input check, t2=temperature check, t3=battery check
#ifndef DEBUG
//
// Power Save Feature
//
myPowerSave ps; // use power Save feature
#endif
float value;
uint8_t level;
while(1) {
/**********************************************************************
*
* your loop code here
*
**********************************************************************/
if ( ble.isConnected() ) {
#ifndef DEBUG
//
// Power On
//
ps.disable(); // disable power save mode
#else
ledACT = !ledACT;
#endif
//
// UART Service
//
if ( ble.isAvailable() ) {
//
// BLE Firmata Demo
//
if ( myFirmata.available() ) {
do {
myFirmata.processInput();
} while(myFirmata.available());
} else {
//
// check the Digital Input
//
checkDigitalInputs();
//
// check the Analog Input with a sampling Interval
//
if (t1.isExpired(samplingInterval) ) {
t1.reset();
checkAnalogInputs();
}
}
}
//
// Proximity Service
//
if ( alert.isAvailable() ) {
//
// push button check (Proximity Service)
//
if ( keyAlert != pinVal ) {
pinVal = keyAlert; // keep last status of key
alert.sendEvent(keyAlert.read()==LOW ? 1 : 0);
}
}
//
// Health Thermometer Service
//
if ( ht.isAvailable() ) {
//
// check temperature
//
if ( t2.isExpired(1000) ) {
t2.reset();
if ( ht.readTemperature(value) ) {
ht.sendMeasure(value);
DBG("temp=%0.2f\n", value);
} // */
}
}
//
// Battery Service
//
if ( bl.isAvailable() ) {
//
// update Battery Level
//
if ( t3.isExpired(3000) ) {
t3.reset();
if ( bl.readSystemVoltage(value) ) {
if ( value>=2.4 && value<=3.6 ) {
level = map(value, 2.0, 3.3, 0, 100);
bl.sendBatteryLevel(level);
DBG("battery:%0.2fv %d%c\n", value, level, '%');
}
}
}
}
} // isConnected
else {
#ifndef DEBUG
//
// Power Save
//
ps.enable(POWER_DOWN); // enable power save mode
#else
ledACT = LED_ON;
#endif
sleep(1000);
}
}
return 0 ;
}
//
// main task
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#endif
CBus leds(LED1, LED2, LED3, LED4, END);
//
// your setup code here
//
myPulseSensor pulse(AD0);
pulse.start();
CTimeout t1, t2;
//
// your loop code here
//
while(1) {
//
// Indicate led in every 20ms
//
if ( t1.isExpired(20) ) {
t1.reset();
if ( pulse.fadeRate>0 ) {
leds[0] = LED_ON;
if ( pulse.fadeRate>64 ) {
leds[1] = LED_ON;
if ( pulse.fadeRate>128 ) {
leds[2] = LED_ON;
if ( pulse.fadeRate>196 ) {
leds[3] = LED_ON;
} else {
leds[3] = LED_OFF;
}
} else {
leds[2] = LED_OFF;
}
} else {
leds[1] = LED_OFF;
}
pulse.fadeRate -= 16;
} else leds = 0; // turn off all leds
}
//
// Show BPM in every 1 second
//
if ( t2.isExpired(1000) ) {
t2.reset();
DBG("BPM=%d\n", pulse.BPM);
}
}
return 0 ;
}
//
// main task
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#endif
/*************************************************************************
*
* your setup code here
*
**************************************************************************/
bleSerial ble("uCX-RSC");
ble.enable();
//
// Running Speed Cadence Service
//
bleRSC rsc(ble);
rsc.features(RSC_SUPPORT_STATUS);
//
// Battery Level Service
//
bleBatteryLevel bl(ble); // declare Battery Level Service object
float value;
uint8_t level;
CPin led(LED1);
while(1) {
/**********************************************************************
*
* your loop code here
*
**********************************************************************/
if ( rsc.isAvailable() ) {
// speed = 3m/s, cadence=2rpm, distance=2m
rsc.send( RSC_SPEED_KMH(6.5), 50, RSC_RUNNING);
}
if ( bl.isAvailable() ) {
if ( bl.readSystemVoltage(value) ) {
if ( value>=2.4 && value<=3.6 ) {
level = map(value, 2.0, 3.3, 0, 100);
bl.sendBatteryLevel(level);
}
}
}
led = !led;
sleep(500);
}
return 0 ;
}
//
// main task
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#endif
/*************************************************************************
*
* your setup code here
*
**************************************************************************/
//
// BLE engine (serial stream)
//
bleSerial ble("myHRM");
ble.enable(96);
//
// Heart Beat Rate Service
//
bleHeartRate hrm(ble);
hrm.supportContact(true);
hrm.contactStatus(true);
hrm.setSensorLocation(HRSL_FINGER);
//
// Battery Level & Health Thermometer Service (Use internal sensors)
//
bleBatteryLevel bat(ble);
bleHealthThermometer ht(ble);
//
// Pulse Sensor
//
myPulseSensor pulse(AD0); // signal on AD0
pulse.start();
//
// Fade LED task
//
ledTask led(pulse);
led.start("LED", 50); // reduce stack size to 58 to increase the heap memory
//
//
//
CTimeout t1, t2, t3;
float value;
uint8_t level;
while(1) {
/**********************************************************************
*
* your loop code here
*
**********************************************************************/
//
// Heart Rate Measurement
//
if ( hrm.isAvailable() ) {
if ( t1.isExpired(1000) ) { // interval 1 second
t1.reset();
hrm.sendMeasure((uint8_t)pulse.BPM);
}
}
//
// Battery Level
//
if ( t2.isExpired(10000) ) { // interval 10 seconds
t2.reset();
if ( bat.readSystemVoltage(value) ) {
level = map(value, 2.0, 3.3, 0, 100); // 0%~100%
bat.sendBatteryLevel(level);
}
}
//
// Health Thermometer Service
//
if ( t3.isExpired(5000) ) { // interval 5 seconds
t3.reset();
if ( ht.readTemperature(value) ) {
ht.sendMeasure(value);
}
}
}
return 0 ;
}
//
// main task
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#endif
/*************************************************************************
*
* your setup code here
*
**************************************************************************/
//
// LED Demo (can be removed)
//
DBG("Hello I'm in debug mode\n");
uint8_t i = 0;
CBus port(LED1, LED2, LED3, LED4, END);
port.output(); // set all pins as output
int devAddr=0;
CI2CMaster i2c;
i2c.enable();
uint8_t data;
while(1) {
/**********************************************************************
*
* your loop code here
*
**********************************************************************/
//
// LED Demo (can be removed)
//
port = led_scripts[i];
i = (i+1) < (int)sizeof(led_scripts) ? i+1 : 0;
sleep(100);
//
// Scan I2C Device
//
#ifdef DEBUG
switch( dbg.isAnyKey() ) {
case 't':
case 'T':
devAddr = 1; // set address =1 to start the scnner.
break;
}
//
// start to scan when devAddr >0 with timeout 200ms
//
if ( devAddr ) {
if ( i2c.readByte(devAddr, 0, &data)==I2C_OK ) {
DBG("I2C device found at address 0x%02X\n", devAddr);
}
devAddr = (devAddr+1)<127 ? devAddr+1 : 0;
}
#endif
}
return 0 ;
}
//
// main task
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#endif
/*************************************************************************
*
* your setup code here
*
**************************************************************************/
//
// Load Configuration
//
EEPROM::read(0, &config, sizeof(config));
if ( config.length!=sizeof(config) ) {
setDefault();
}
// class default I2C address is 0x68
// specific I2C addresses may be passed as a parameter here
// AD0 low = 0x68 (default for InvenSense evaluation board)
// AD0 high = 0x69
MPU6050 mpu;
// initialize device
mpu.initialize();
mpu.setRate(7);
mpu.setFullScaleGyroRange(MPU6050_GYRO_FS_250);
mpu.setFullScaleAccelRange(MPU6050_ACCEL_FS_2);
//
// check device
//
if (mpu.testConnection()) {
}
//
// H-Bridge
//
CPwm::frequency(KHZ(20));
HBridge left(PWM1, P18, P19);
HBridge right(PWM2, P22, P23);
left.enable();
right.enable();
BalanceRobot robot(mpu, left, right);
robot.start("Robot", 168, PRI_HIGH);
#ifndef DEBUG
myMenu menu(mpu, robot);
menu.start();
#endif
while (1) {
/**********************************************************************
*
* your loop code here
*
**********************************************************************/
LEDs[0] = !LEDs[0];
sleep(500);
}
return 0;
//
// main loop
//
int main(void) {
#ifdef DEBUG
#if __USE_USB
usbCDC ser;
ser.connect();
#else
CSerial ser;
ser.settings(115200);
#endif
CDebug dbg(ser);
dbg.start();
#endif
//
// your setup code here
//
myBLE ble;
ble.enable(128);
bleBatteryLevel bl(ble); // declare Battery Level Service object
bleHealthThermometer ht(ble); // declare Health Thermometer Service object
myFirmata.begin(ble); // begin the Firmata Object with the ble serial stream.
callback_init(); // initialize the callback functions for myFirmata Object.
CTimeout t1, t2; // t1=battery level update, t2=analog-input interval
#ifndef DEBUG
myPowerSave ps; // use power Save
#endif
ledACT = LED_ON;
float value;
uint8_t level;
//
// your loop code here
//
while(1) {
if ( ble.isConnected() ) {
#ifndef DEBUG
ps.disable(); // disable power save mode
#endif
//
// myFirmataClass Check
//
if ( myFirmata.available() ) {
do {
myFirmata.processInput();
} while(myFirmata.available());
} else {
if ( t1.isExpired(3000)==false ) {
//
// check the Digital Input
//
checkDigitalInputs();
//
// check the Analog Input with a sampling Interval
//
if (t2.isExpired(samplingInterval) ) {
t2.reset();
checkAnalogInputs();
}
} else {
t1.reset();
// update Battery Level
//
if ( bl.readSystemVoltage(value) ) {
if ( value>=2.0 && value<=3.6 ) {
level = map(value, 2.0, 3.3, 0, 100);
bl.sendBatteryLevel(level);
DBG("battery:%0.2f %d\n", value, level);
}
}
//
// update Temperature
//
if ( ht.readTemperature(value) ) {
ht.sendMeasure(value);
DBG("temp=%0.2f\n", value);
} // */
}
}// */
} else {
#ifndef DEBUG
ps.enable(POWER_DOWN); // enable power save mode
#endif
sleep(200);
}
}
return 0 ;
}
