void setRGBState_command(char *property, app_context_t * const inContext){
if(0==strcmp(property, "RGB red")){
hsb2rgb_led_open(0, 100, 50);
}else if(0==strcmp(property, "RGB green")){
hsb2rgb_led_open(120, 100, 50);
}
else if(0==strcmp(property, "RGB blue")){
hsb2rgb_led_open(240, 100, 50);
}
else if(0==strcmp(property, "RGB off")){
hsb2rgb_led_open(0, 0, 0);
}
}
OSStatus user_modules_init(void)
{
OSStatus err = kUnknownErr;
// init DC Motor(GPIO)
dc_motor_init();
dc_motor_set(0); // off
// init RGB LED(P9813)
hsb2rgb_led_init();
hsb2rgb_led_open(0, 0, 0); // off
// init OLED
OLED_Init();
//OLED_Clear();
LCD_Clear(0x00);
OLED_ShowString(20,0,"M X C H I P");
OLED_ShowString(20,3,(uint8_t*)DEFAULT_DEVICE_NAME);
OLED_ShowString(0,6,"T: 0C H: 0%");
// init Light sensor(ADC)
light_sensor_init();
// init infrared sensor(ADC)
infrared_reflective_init();
// init user key1 && key2
user_key1_init();
user_key2_init();
err = kNoErr;
return err;
}
void user_test(user_context_t *user_context)
{
if(rgb_led_test_flag){
hsb2rgb_led_open(rgb_led_test_color_value,100,50);
rgb_led_test_color_value += 120;
if(rgb_led_test_color_value >= 360){
rgb_led_test_color_value = 0;
}
}
else{
//hsb2rgb_led_open(0,0,0);
}
}
void except_handle(void *inContext)
{
char str[20];
while(1)
{
if(dht11_temp_data >= 32)
{
hsb2rgb_led_open(0, 100, 50);
mico_thread_msleep(500);
hsb2rgb_led_open(0, 0, 0);
mico_thread_msleep(500);
}
sprintf(str, "T:%3.1fC H:%3.1f%%",(float)dht11_temp_data, (float)dht11_hum_data);
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_4, (uint8_t*)str);
memset(str,0,20);
sprintf(str, "infrared: %d",infrared_reflective_data);
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_3, (uint8_t*)str);
memset(str,0,20);
sprintf(str, "light: %d",light_sensor_data);
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_2, (uint8_t*)str);
}
}
/** Handle a command specific to the specification for this device */
void handleSpecificationCommand(byte* payload, unsigned int length) {
ArduinoCustom__Header header;
memset(buffer,0,300);
ArduinoCustom_testData testEvents;
pb_istream_t stream = pb_istream_from_buffer(payload, length);
if (pb_decode_delimited(&stream, ArduinoCustom__Header_fields, &header)) {
baseEvents_log("Decoded header for custom command.");
if (header.command == ArduinoCustom_Command_RGB_LED) {
if (pb_decode_delimited(&stream, ArduinoCustom_RGB_fields, &RGB_LED)) {
baseEvents_log("Command: RGB_LED set(h=%d, s=%d, b=%d)",
RGB_LED.rgbled_h, RGB_LED.rgbled_s, RGB_LED.rgbled_b);
hsb2rgb_led_open(RGB_LED.rgbled_h, RGB_LED.rgbled_s, RGB_LED.rgbled_b);
}
}
else if (header.command == ArduinoCustom_Command_DC_MOTOR) {
ArduinoCustom_DC_MOTOR dc_motor;
if (pb_decode_delimited(&stream, ArduinoCustom__Header_fields, &dc_motor)) {
baseEvents_log("Command: DC_MOTOR set: %d", dc_motor.motor_sw);
dc_motor_set(dc_motor.motor_sw);
}
}
else if (header.command == ArduinoCustom_Command_PING) {
ArduinoCustom_ping ping;
if (pb_decode_delimited(&stream, ArduinoCustom_ping_fields, &ping)) {
handlePing(ping, header.originator);
}
}
else if (header.command == ArduinoCustom_Command_TESTEVENTS) {
if (pb_decode_delimited(&stream, ArduinoCustom_testEvents_fields, &testEvents)) {
handleTestEvents(testEvents, header.originator);
}
}
else if (header.command == ArduinoCustom_Command_SERIALPRINTLN) {
ArduinoCustom_serialPrintln serialPrintln;
if (pb_decode_delimited(&stream, ArduinoCustom_serialPrintln_fields, &serialPrintln)) {
handleSerialPrintln(serialPrintln,header.originator);
}
}
else {
baseEvents_log("Unknown command.");
}
}
}
// brightness set function
int rgb_led_brightness_set(struct mico_prop_t *prop, void *arg, void *val, uint32_t val_len)
{
int ret = 0;
int brightness = *((int*)val);
user_context_t *uct = (user_context_t*)arg;
properties_user_log("rgb_led_brightness_set: val=%d, val_len=%d.", *((int*)val), val_len);
// control hardware
if(uct->config.rgb_led_sw){
hsb2rgb_led_open((float)uct->config.rgb_led_hues, (float)uct->config.rgb_led_saturation, (float)brightness);
}
else{
hsb2rgb_led_close();
}
return ret; // return 0, succeed.
}
// swtich set function
int rgb_led_sw_set(struct mico_prop_t *prop, void *arg, void *val, uint32_t val_len)
{
int ret = 0;
bool set_sw_state = *((bool*)val);
user_context_t *uct = (user_context_t*)arg;
//properties_user_log("rgb_led_sw_set: val=%d, val_len=%d.", *((bool*)val), val_len);
//properties_user_log("h=%d, s=%d, b=%d", uct->config.rgb_led_hues, uct->config.rgb_led_saturation, uct->config.rgb_led_brightness);
// control hardware
if(set_sw_state){
properties_user_log("Open LED.");
hsb2rgb_led_open((float)uct->config.rgb_led_hues, (float)uct->config.rgb_led_saturation, (float)uct->config.rgb_led_brightness);
}
else{
properties_user_log("Close LED.");
hsb2rgb_led_close();
}
return ret; // return 0, succeed.
}
void micokit_ext_mfg_test(mico_Context_t *inContext)
{
OSStatus err = kUnknownErr;
char str[64] = {'\0'};
char mac[6];
int rgb_led_hue = 0;
uint8_t dht11_ret = 0;
uint8_t dht11_temp_data = 0;
uint8_t dht11_hum_data = 0;
int light_ret = 0;
uint16_t light_sensor_data = 0;
int infrared_ret = 0;
uint16_t infrared_reflective_data = 0;
int32_t bme280_temp = 0;
uint32_t bme280_hum = 0;
uint32_t bme280_press = 0;
UNUSED_PARAMETER(inContext);
mico_rtos_init_semaphore(&mfg_test_state_change_sem, 1);
err = MICOAddNotification( mico_notify_WIFI_SCAN_COMPLETED, (void *)mico_notify_WifiScanCompleteHandler );
require_noerr( err, exit );
while(1){
switch(mfg_test_module_number){
case 0: // mfg mode start
{
sprintf(str, "%s\r\nStart:\r\n%s\r\n%s", "TEST MODE", " next: Key2", " prev: Key1");
mf_printf(str);
while(kNoErr != mico_rtos_get_semaphore(&mfg_test_state_change_sem, MICO_WAIT_FOREVER));
break;
}
case 1: // OLED
{
while(kNoErr != mico_rtos_get_semaphore(&mfg_test_state_change_sem, 0))
{
sprintf(str, "%s OLED\r\n", OLED_MFG_TEST_PREFIX);
mf_printf(str);
mico_thread_msleep(300);
mf_printf(mfg_test_oled_test_string);
mico_thread_msleep(300);
}
OLED_Clear();
break;
}
case 2: // RGB_LED
{
sprintf(str, "%s RGB LED\r\nBlink: \r\n R=>G=>B", OLED_MFG_TEST_PREFIX);
mf_printf(str);
while(kNoErr != mico_rtos_get_semaphore(&mfg_test_state_change_sem, 0))
{
hsb2rgb_led_open(rgb_led_hue, 100, 50);
rgb_led_hue += 120;
if(rgb_led_hue >= 360){
rgb_led_hue = 0;
}
mico_thread_msleep(300);
}
hsb2rgb_led_open(0, 0, 0);
break;
}
case 3: // infrared sensor
{
while(kNoErr != mico_rtos_get_semaphore(&mfg_test_state_change_sem, 0))
{
infrared_ret = infrared_reflective_read(&infrared_reflective_data);
if(0 == infrared_ret){
sprintf(str, "%s Infrared\r\nInfrared: %d", OLED_MFG_TEST_PREFIX,
infrared_reflective_data);
mf_printf(str);
}
mico_thread_msleep(300);
}
break;
}
case 4: // DC Motor
{
sprintf(str, "%s DC Motor\r\nRun:\r\n on : 500ms\r\n off: 500ms", OLED_MFG_TEST_PREFIX);
mf_printf(str);
while(kNoErr != mico_rtos_get_semaphore(&mfg_test_state_change_sem, 0))
{
dc_motor_set(1);
mico_thread_msleep(500);
dc_motor_set(0);
mico_thread_msleep(500);
}
dc_motor_set(0);
break;
}
case 5: // BME280
{
while(kNoErr != mico_rtos_get_semaphore(&mfg_test_state_change_sem, 0))
{
err = bme280_sensor_init();
if(kNoErr != err){
sprintf(str, "%s BME280\r\nMoule not found!", OLED_MFG_TEST_PREFIX);
mf_printf(str);
// goto next mdoule
mico_thread_msleep(500);
mfg_test_module_number = (mfg_test_module_number+1)%(MFG_TEST_MAX_MODULE_NUM+1);
break;
}
else{
err = bme280_data_readout(&bme280_temp, &bme280_press, &bme280_hum);
if(kNoErr == err){
sprintf(str, "%s BME280\r\nT: %3.1fC\r\nH: %3.1f%%\r\nP: %5.2fkPa", OLED_MFG_TEST_PREFIX,
(float)bme280_temp/100, (float)bme280_hum/1024, (float)bme280_press/1000);
mf_printf(str);
}
else{
sprintf(str, "%s BME280\r\nRead error!", OLED_MFG_TEST_PREFIX);
mf_printf(str);
}
}
mico_thread_msleep(500);
}
break;
}
case 6: // DHT11
{
while(kNoErr != mico_rtos_get_semaphore(&mfg_test_state_change_sem, 0))
{
dht11_ret = DHT11_Read_Data(&dht11_temp_data, &dht11_hum_data);
if(0 == dht11_ret){
sprintf(str, "%s DHT11\r\nT: %3.1fC\r\nH: %3.1f%%", OLED_MFG_TEST_PREFIX,
(float)dht11_temp_data, (float)dht11_hum_data);
mf_printf(str);
}
mico_thread_sleep(1); // DHT11 must >= 1s
}
break;
}
case 7: // Light sensor
{
while(kNoErr != mico_rtos_get_semaphore(&mfg_test_state_change_sem, 0))
{
light_ret = light_sensor_read(&light_sensor_data);
if(0 == light_ret){
sprintf(str, "%s Light\r\nLight: %d", OLED_MFG_TEST_PREFIX,
light_sensor_data);
mf_printf(str);
}
mico_thread_msleep(300);
}
break;
}
case 8: // wifi
{
wlan_get_mac_address(mac);
sprintf(str, "%s Wi-Fi\r\nMAC:\r\n %02X%02X%02X%02X%02X%02X", OLED_MFG_TEST_PREFIX,
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
mf_printf(str);
//mico_thread_msleep(500);
scanap_done = false;
micoWlanStartScan();
while((!scanap_done) || (kNoErr != mico_rtos_get_semaphore(&mfg_test_state_change_sem, MICO_WAIT_FOREVER)));
break;
}
default:
goto exit; // error
break;
}
}
exit:
mico_thread_sleep(MICO_NEVER_TIMEOUT);
}
void test_jsonc()
{
/*control info*/
bool rgb_sw = false;
int rgb_hue = 0;
int rgb_sat = 0;
int rgb_bri = 0;
/*1:construct json object*/
struct json_object *recv_json_object=NULL;
recv_json_object=json_object_new_object();
struct json_object *device_object=NULL;
device_object=json_object_new_object();
json_object_object_add(device_object, "Hardware", json_object_new_string("MiCOKit3288"));
json_object_object_add(device_object, "RGBSwitch", json_object_new_boolean(false));
json_object_object_add(device_object, "RGBHues", json_object_new_int(0));
json_object_object_add(device_object, "RGBSaturation", json_object_new_int(100));
json_object_object_add(device_object, "RGBBrightness", json_object_new_int(100));
json_object_object_add(recv_json_object,"device_info",device_object);/*one pair K-V*/
os_json_log("%s",json_object_to_json_string(recv_json_object));
/*recv_json_object*/
/*
{"device_info":
{ "Hardware": "MiCOKit3288",
"RGBSwitch": false,
"RGBHues": 0,
"RGBSaturation": 100,
"RGBBrightness": 100
}
}
*/
/*2:parse json object*/
json_object* parse_json_object=json_object_object_get(recv_json_object,"device_info");
/*get data one by one*/
json_object_object_foreach(parse_json_object, key, val) {
if(!strcmp(key, "RGBSwitch")){
rgb_sw = json_object_get_boolean(val);
os_json_log("rgb_sw=%d",rgb_sw);
}
else if(!strcmp(key, "RGBHues")){
rgb_hue = json_object_get_int(val);
os_json_log("rgb_hue=%d",rgb_hue);
}
else if(!strcmp(key, "RGBSaturation")){
rgb_sat = json_object_get_int(val);
os_json_log("rgb_sat=%d",rgb_sat);
}
else if(!strcmp(key, "RGBBrightness")){
rgb_bri = json_object_get_int(val);
os_json_log("rgb_bri=%d",rgb_bri);
}
}
/*3:parse finished,free memory*/
json_object_put(recv_json_object);/*free memory*/
recv_json_object=NULL;
/*4:operate rgb*/
os_json_log("control rgb led now");
rgb_led_init();
hsb2rgb_led_open(rgb_hue, rgb_sat, rgb_bri);/*turn red*/
}
