Merge release updates from master

Xykon · Xykon · commit 055728a65b8c · 2018-02-13T19:52:00.000Z
diff --git a/Jenkinsfile b/Jenkinsfile
@@ -33,13 +33,7 @@ node {
 		stage(board) {
 			def parallelSteps = [:]
             def board_u = board.toUpperCase()
-            if (board_u == "LOPY" || board_u == "FIPY"  || board_u == "LOPY4") {
-        			parallelSteps[board+"_868"] = boardBuild(board+"_868")
-        			parallelSteps[board+"_915"] = boardBuild(board+"_915")
-        		}
-    			else{
-        			parallelSteps[board] = boardBuild(board)
-        		}
+        		parallelSteps[board] = boardBuild(board)
         		parallel parallelSteps
   		}
   	}
@@ -71,30 +65,23 @@ stage ('Test'){
 def boardBuild(name) {
     def name_u = name.toUpperCase()
     def name_short = name_u.split('_')[0]
-    def lora_band = ""
-    if (name_u == "LOPY_868" || name_u == "FIPY_868"  || name_u == "LOPY4_868") {
-        lora_band = " LORA_BAND=USE_BAND_868"
-    }
-    else if (name_u == "LOPY_915" || name_u == "FIPY_915" || name_u == "LOPY4_915") {
-        lora_band = " LORA_BAND=USE_BAND_915"
-    }
     def app_bin = name.toLowerCase() + '.bin'
     return {
     		release_dir = "${JENKINS_HOME}/release/${JOB_NAME}/" + PYCOM_VERSION + "/" + GIT_TAG + "/"
         sh '''export PATH=$PATH:/opt/xtensa-esp32-elf/bin;
         export IDF_PATH=${WORKSPACE}/esp-idf;
         cd esp32;
-        make clean BOARD=''' + name_short + lora_band
+        make clean BOARD=''' + name_short
 
         sh '''export PATH=$PATH:/opt/xtensa-esp32-elf/bin;
         export IDF_PATH=${WORKSPACE}/esp-idf;
         cd esp32;
-        make TARGET=boot -j2 BOARD=''' + name_short + lora_band
+        make TARGET=boot -j2 BOARD=''' + name_short
 
         sh '''export PATH=$PATH:/opt/xtensa-esp32-elf/bin;
         export IDF_PATH=${WORKSPACE}/esp-idf;
         cd esp32;
-        make TARGET=app -j2 BOARD=''' + name_short + lora_band
+        make TARGET=app -j2 BOARD=''' + name_short
 
         sh '''cd esp32/build/'''+ name_u +'''/release;
         mkdir -p firmware_package;
@@ -172,3 +159,4 @@ def get_remote_name(short_name) {
 def get_device_name(short_name) {
     return "/dev/serial/by-id/usb-" +  short_name + "-if00"   
 }
+
diff --git a/esp32/boards/FIPY/FIPY/script b/esp32/boards/FIPY/FIPY/script
@@ -9,5 +9,5 @@
     ["e", "0x1C1000",    "0x40000"],
     ["w", "0x1000", "bootloader.bin"],
     ["w", "0x8000", "partitions.bin"],
-    ["w", "0x10000", "fipy_868.bin"]
+    ["w", "0x10000", "fipy.bin"]
 ]
diff --git a/esp32/boards/LOPY/LOPY/script b/esp32/boards/LOPY/LOPY/script
@@ -9,5 +9,5 @@
     ["e", "0x1C1000",    "0x40000"],
     ["w", "0x1000", "bootloader.bin"],
     ["w", "0x8000", "partitions.bin"],
-    ["w", "0x10000", "fipy_915.bin"]
+    ["w", "0x10000", "lopy.bin"]
 ]
diff --git a/esp32/boards/LOPY/LOPY_915/script b/esp32/boards/LOPY/LOPY_915/script
diff --git a/esp32/boards/LOPY4/LOPY4/script b/esp32/boards/LOPY4/LOPY4/script
@@ -9,5 +9,5 @@
     ["e", "0x1C1000",    "0x40000"],
     ["w", "0x1000", "bootloader.bin"],
     ["w", "0x8000", "partitions.bin"],
-    ["w", "0x10000", "lopy_868.bin"]
+    ["w", "0x10000", "lopy4.bin"]
 ]
diff --git a/esp32/boards/LOPY4/LOPY4_868/script b/esp32/boards/LOPY4/LOPY4_868/script
diff --git a/esp32/boards/LOPY4/LOPY4_915/script b/esp32/boards/LOPY4/LOPY4_915/script
diff --git a/esp32/mods/modlora.c b/esp32/mods/modlora.c
@@ -1223,7 +1223,7 @@ static void lora_validate_device_class (DeviceClass_t device_class) {
 
 static void lora_validate_region (LoRaMacRegion_t region) {
     if (region != LORAMAC_REGION_AS923 && region != LORAMAC_REGION_AU915
-        && region != LORAMAC_REGION_EU868 && region != LORAMAC_REGION_US915_HYBRID) {
+        && region != LORAMAC_REGION_EU868 && region != LORAMAC_REGION_US915) {
             nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid region %d", region));
     }
 }
@@ -1409,7 +1409,11 @@ static mp_obj_t lora_init_helper(lora_obj_t *self, const mp_arg_val_t *args) {
     lora_validate_mode (cmd_data.info.init.stack_mode);
 
     // we need to know the region first
-    cmd_data.info.init.region = args[14].u_int;
+    if (args[14].u_obj == MP_OBJ_NULL) {
+        cmd_data.info.init.region = config_get_lora_region();
+    } else {
+        cmd_data.info.init.region = mp_obj_get_int(args[14].u_obj);
+    }
     lora_validate_region(cmd_data.info.init.region);
     // we need to do it here in advance for the rest of the validation to work
     lora_obj.region = cmd_data.info.init.region;
@@ -1501,7 +1505,7 @@ STATIC const mp_arg_t lora_init_args[] = {
     { MP_QSTR_public,       MP_ARG_KW_ONLY  | MP_ARG_BOOL,  {.u_bool = true} },
     { MP_QSTR_tx_retries,   MP_ARG_KW_ONLY  | MP_ARG_INT,   {.u_int = 2} },
     { MP_QSTR_device_class, MP_ARG_KW_ONLY  | MP_ARG_INT,   {.u_int = CLASS_A} },
-    { MP_QSTR_region,       MP_ARG_KW_ONLY  | MP_ARG_INT,   {.u_int = LORAMAC_REGION_EU868} },
+    { MP_QSTR_region,       MP_ARG_KW_ONLY  | MP_ARG_OBJ,   {.u_obj = MP_OBJ_NULL} },
 };
 STATIC mp_obj_t lora_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // parse args
@@ -2105,7 +2109,7 @@ STATIC const mp_map_elem_t lora_locals_dict_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_AS923),               MP_OBJ_NEW_SMALL_INT(LORAMAC_REGION_AS923) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_AU915),               MP_OBJ_NEW_SMALL_INT(LORAMAC_REGION_AU915) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_EU868),               MP_OBJ_NEW_SMALL_INT(LORAMAC_REGION_EU868) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_US915),               MP_OBJ_NEW_SMALL_INT(LORAMAC_REGION_US915_HYBRID) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_US915),               MP_OBJ_NEW_SMALL_INT(LORAMAC_REGION_US915) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(lora_locals_dict, lora_locals_dict_table);
diff --git a/esp32/mods/modpycom.c b/esp32/mods/modpycom.c
@@ -230,19 +230,6 @@ STATIC mp_obj_t mod_pycom_wifi_pwd (mp_uint_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_pycom_wifi_pwd_obj, 0, 1, mod_pycom_wifi_pwd);
 
-STATIC mp_obj_t mod_pycom_lora_country (mp_uint_t n_args, const mp_obj_t *args) {
-    if (n_args) {
-    		const char *lora_country = mp_obj_str_get_str(args[0]);
-    		config_set_lora_country ((const uint8_t*)lora_country);
-    } else {
-    		uint8_t lora_country[32];
-    		config_get_lora_country(lora_country);
-    		return mp_obj_new_str((const char*)lora_country,strlen((const char*)lora_country),false);
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_pycom_lora_country_obj, 0, 1, mod_pycom_lora_country);
-
 STATIC mp_obj_t mod_pycom_heartbeat_on_boot (mp_uint_t n_args, const mp_obj_t *args) {
     if (n_args) {
     		config_set_heartbeat_on_boot (mp_obj_is_true(args[0]));
@@ -269,7 +256,6 @@ STATIC const mp_map_elem_t pycom_module_globals_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_wifi_on_boot),        			(mp_obj_t)&mod_pycom_wifi_on_boot_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_wifi_ssid),        	   			(mp_obj_t)&mod_pycom_wifi_ssid_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_wifi_pwd),        	   			(mp_obj_t)&mod_pycom_wifi_pwd_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_lora_country),  				(mp_obj_t)&mod_pycom_lora_country_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_heartbeat_on_boot),        		(mp_obj_t)&mod_pycom_heartbeat_on_boot_obj },
 };
 
diff --git a/esp32/pycom_config.c b/esp32/pycom_config.c
@@ -25,7 +25,6 @@ static pycom_config_block_t pycom_config_block;
 void config_init0 (void) {
     // read the config struct from flash
     spi_flash_read(CONFIG_DATA_FLASH_ADDR, (void *)&pycom_config_block, sizeof(pycom_config_block));
-    printf("Size of configuration block: %d\n",sizeof(pycom_config_block));
 }
 
 bool config_set_lpwan_mac (const uint8_t *mac) {
@@ -73,16 +72,15 @@ void config_get_sigfox_private_key (uint8_t *private_key) {
     memcpy(private_key, pycom_config_block.lpwan_config.sigfox_private_key, sizeof(pycom_config_block.lpwan_config.sigfox_private_key));
 }
 
-bool config_set_lora_country (const uint8_t *lora_country) {
-	memcpy(pycom_config_block.lpwan_config.lora_country, lora_country, sizeof(pycom_config_block.lpwan_config.lora_country));
+bool config_set_lora_region (uint8_t lora_region) {
+    if (pycom_config_block.lpwan_config.lora_region != lora_region) {
+        pycom_config_block.lpwan_config.lora_region = lora_region;
+    }
     return config_write();
 }
 
-void config_get_lora_country (uint8_t *lora_country) {
-    memcpy( lora_country, pycom_config_block.lpwan_config.lora_country, sizeof(pycom_config_block.lpwan_config.lora_country));
-    if (lora_country[0]==0xFF) {
-    		lora_country[0]=0x00;
-    }
+uint8_t config_get_lora_region (void) {
+    return (pycom_config_block.lpwan_config.lora_region == 0xff) ? 5:pycom_config_block.lpwan_config.lora_region;
 }
 
 bool config_set_wifi_on_boot (uint8_t wifi_on_boot) {
@@ -117,7 +115,7 @@ bool config_set_wifi_ssid (const uint8_t *wifi_ssid) {
 void config_get_wifi_ssid (uint8_t *wifi_ssid) {
     memcpy( wifi_ssid, pycom_config_block.wifi_config.wifi_ssid, sizeof(pycom_config_block.wifi_config.wifi_ssid));
     if (wifi_ssid[0]==0xff) {
-    		wifi_ssid[0]=0x0;
+        wifi_ssid[0]=0x0;
     }
 }
 
@@ -129,12 +127,11 @@ bool config_set_wifi_pwd (const uint8_t *wifi_pwd) {
 void config_get_wifi_pwd (uint8_t *wifi_pwd) {
     memcpy( wifi_pwd, pycom_config_block.wifi_config.wifi_pwd, sizeof(pycom_config_block.wifi_config.wifi_pwd));
     if (wifi_pwd[0]==0xff) {
-    		wifi_pwd[0]=0x0;
+        wifi_pwd[0]=0x0;
     }
 }
 
 static bool config_write (void) {
-	printf("Size of configuration block: %d\n",sizeof(pycom_config_block));
     // erase the block first
     if (ESP_OK == spi_flash_erase_sector(CONFIG_DATA_FLASH_BLOCK)) {
         // then write it
diff --git a/esp32/pycom_config.h b/esp32/pycom_config.h
@@ -27,7 +27,7 @@ typedef struct {
 	uint8_t sigfox_pac[8];
 	uint8_t sigfox_private_key[16];
 	uint8_t sigfox_public_key[16];
-	uint8_t lora_country[33];
+	uint8_t lora_region;
 } pycom_lpwan_config_t;
 
 typedef struct {
@@ -50,7 +50,7 @@ typedef struct {
 	uint8_t pycom_hw_version;
 	uint8_t pycom_sw_version[12];
 	uint8_t pycom_reserved[335];
-	uint8_t pycom_dummy[228];
+	uint8_t pycom_dummy[258];
 } pycom_config_t;
 
 typedef struct {
@@ -101,9 +101,9 @@ bool config_set_wifi_pwd(const uint8_t *wifi_pwd);
 
 void config_get_wifi_pwd(uint8_t *wifi_pwd);
 
-bool config_set_lora_country(const uint8_t *lpwan_country);
+bool config_set_lora_region (uint8_t lora_region);
 
-void config_get_lora_country(uint8_t *lpwan_country);
+uint8_t config_get_lora_region (void);
 
 int config_size(void);
 
diff --git a/esp32/tools/pypic.py b/esp32/tools/pypic.py
@@ -9,7 +9,7 @@
 import struct
 import time
 
-__version__ = '0.9.1'
+__version__ = '0.9.2'
 
 CMD_PEEK = (0x0)
 CMD_POKE = (0x01)
@@ -131,24 +131,27 @@ def reset_pycom_module(self):
         self.mask_bits_in_memory(TRISC_ADDR, ~(1 << 5))
         # drive RC5 low
         self.mask_bits_in_memory(PORTC_ADDR, ~(1 << 5))
-        time.sleep(0.25)
+        time.sleep(0.2)
         # drive RC5 high
         self.set_bits_in_memory(PORTC_ADDR, 1 << 5)
         time.sleep(0.1)
+        # make RC5 an input
+        self.set_bits_in_memory(TRISC_ADDR, 1 << 5)
 
     def enter_pycom_programming_mode(self):
         # make RC0 an output
         self.mask_bits_in_memory(TRISC_ADDR, ~(1 << 0))
         # set RC0 low
         self.mask_bits_in_memory(PORTC_ADDR, ~(1 << 0))
+        # perform reset
         self.reset_pycom_module()
+        # We should keep RC0 low at this point in case someone
+        # presses the reset button before the firmware upgrade
+        # as this is mandatory for the regular expansion board
 
     def exit_pycom_programming_mode(self):
-       # make RC0 an output
-        self.mask_bits_in_memory(TRISC_ADDR, ~(1 << 0))
-        # set RC0 high
-        self.set_bits_in_memory(PORTC_ADDR, 1 << 0)
         # make RC0 an input
+        # This will prevent issues with the RGB LED
         self.set_bits_in_memory(TRISC_ADDR, 1 << 0)
         self.reset_pycom_module()
 
@@ -160,7 +163,7 @@ def close(self):
 
 
 def main(args):
-    parser = argparse.ArgumentParser(description='Sends internal commands to pu the Pycom module in programming mode')
+    parser = argparse.ArgumentParser(description='Sends internal commands to put the Pycom module in programming mode')
     parser.add_argument('-p', '--port', metavar='PORT', help='the serial port used to communicate with the PIC')
     parser.add_argument('--enter', action='store_true', help='enter programming mode')
     parser.add_argument('--exit', action='store_true', help='exit programming mode')

Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@`
`9`	`9`	`["e", "0x1C1000", "0x40000"],`
`10`	`10`	`["w", "0x1000", "bootloader.bin"],`
`11`	`11`	`["w", "0x8000", "partitions.bin"],`
`12`		`- ["w", "0x10000", "fipy_868.bin"]`
	`12`	`+ ["w", "0x10000", "fipy.bin"]`
`13`	`13`	`]`