From dff7a63348e7acf4aa1d87b5bdc079202741fa60 Mon Sep 17 00:00:00 2001 From: Andrew Burge Date: Mon, 28 Jul 2025 11:36:50 +0100 Subject: [PATCH 1/7] Expand the `ota_update` readme; there's a lot of ground covered here. --- pico_w/wifi/ota_update/README.md | 39 ++++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/pico_w/wifi/ota_update/README.md b/pico_w/wifi/ota_update/README.md index 74ca4fc68..81a43584e 100644 --- a/pico_w/wifi/ota_update/README.md +++ b/pico_w/wifi/ota_update/README.md @@ -1,4 +1,29 @@ -This example requires a partition table in flash. This can be loaded by creating a UF2 from the partition table JSON in this folder: +# Overview + +This example uses a python script running on a host machine to _push_ new operating software image to a specified Pico 2 W running this `ota_update` example image. The incoming image is programmed into Pico 2 W flash memory. + +On successful completion of the flash programming, the Pico 2 W will be rebooted and the updated operating image will be selected and executed by the RP2350 bootrom. This process can be repeated as required. + +## More detail + +The Pico 2 W operates as a server which listens on TCP port 4242. The incoming octet stream, pushed by the host, is expected to be a sequence of UF2 blocks which are programmed into Pico 2 W flash using the APIs provided by the RP2350 bootrom. In addition to programming, the received data is 'hashed' using the RP2350 SHA256 hardware, and the hash sent back to host to allow integrity checking. + +The flash must be appropriately partitioned for this example to work; most obviously *two* ` IMAGE_DEF` partitions are required, one for the running software and the other which is updated by the example software. + +Note: This example _also_ demonstrates storage of the CYW43 Wi-fi firmware object using additional flash partition(s) although this firmware is not updated by this example. + +For more information flash partitioning and boot image selection please see section 5 of [RP2350 datasheet](https://datasheets.raspberrypi.com/rp2350/rp2350-datasheet.pdf) + +## How to + +### Flash partitioning + +Before the example can be run, the Flash on the Pico 2 W must be appropriately partitioned. + +Flash partitioning only needs doing only once for this example but, as written below, will completely remove any previous flash contents. + +The required partition data can be loaded by creating a UF2 from the partition table JSON in this folder: + ``` picotool partition create main.json pt.uf2 ``` @@ -8,13 +33,19 @@ picotool load pt.uf2 picotool reboot -u ``` -Once the partition table is loaded, you first need to load the Wi-Fi firmware UF2 (`picow_ota_update_wifi_firmware.uf2`) followed by loading & executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: +Once the partition table is loaded, you first need to load the Wi-Fi firmware UF2 (`picow_ota_update_wifi_firmware.uf2`) followed by loading and executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: ``` picotool load picow_ota_update_wifi_firmware.uf2 picotool load -x picow_ota_update.uf2 ``` -Once running, you can use [python_ota_update.py](python_ota_update.py) to upload new UF2s to it using it's IP address: +### Operation + +Once running, you can use [python_ota_update.py](python_ota_update.py) to upload new UF2s from the host to it using it's IP address. For example: ``` -python python_ota_update.py 192.168.0.103 picow_ota_update.uf2 +python ./python_ota_update.py 192.168.0.103 picow_ota_update.uf2 ``` + +Will update the Pico 2 W at `192.168.0.103` with the specified image. + +Note: This example will send debug output text on the default UART 0, `GPIO 0`. From 6cd1a0526dff8e49a9807377aec64e3318a3bc1a Mon Sep 17 00:00:00 2001 From: Peter Harper <77111776+peterharperuk@users.noreply.github.com> Date: Mon, 28 Jul 2025 13:53:53 +0100 Subject: [PATCH 2/7] Some updates (#686) Still need to include something about Wifi "firmware" updates? --- pico_w/wifi/ota_update/README.md | 47 +++++++++++++++++++++++++------- 1 file changed, 37 insertions(+), 10 deletions(-) diff --git a/pico_w/wifi/ota_update/README.md b/pico_w/wifi/ota_update/README.md index 81a43584e..ffd54bccc 100644 --- a/pico_w/wifi/ota_update/README.md +++ b/pico_w/wifi/ota_update/README.md @@ -1,16 +1,18 @@ # Overview -This example uses a python script running on a host machine to _push_ new operating software image to a specified Pico 2 W running this `ota_update` example image. The incoming image is programmed into Pico 2 W flash memory. +This example demonstrates how to implement an Over The Air (OTA) software update mechanism using facilities provided by the RP2350 bootrom. + + A python script runs on a host machine to _push_ a new operating software image to a Pico 2 W running the `ota_update` example image. The incoming image is received via the LwIP IP stack and programmed into Pico 2 W flash memory. On successful completion of the flash programming, the Pico 2 W will be rebooted and the updated operating image will be selected and executed by the RP2350 bootrom. This process can be repeated as required. ## More detail -The Pico 2 W operates as a server which listens on TCP port 4242. The incoming octet stream, pushed by the host, is expected to be a sequence of UF2 blocks which are programmed into Pico 2 W flash using the APIs provided by the RP2350 bootrom. In addition to programming, the received data is 'hashed' using the RP2350 SHA256 hardware, and the hash sent back to host to allow integrity checking. +The Pico 2 W listens on TCP port 4242. The incoming octet stream, pushed by the host, is expected to be a sequence of UF2 blocks which are programmed into Pico 2 W flash using the APIs provided by the RP2350 bootrom. In addition to programming, the received data is 'hashed' using the RP2350 SHA256 hardware, and the hash sent back to host to allow integrity checking. -The flash must be appropriately partitioned for this example to work; most obviously *two* ` IMAGE_DEF` partitions are required, one for the running software and the other which is updated by the example software. +The flash must be appropriately partitioned for this example to work. Two ` IMAGE_DEF` partitions are required, one for the currently running software and the other which is updated by the `ota_update` example. -Note: This example _also_ demonstrates storage of the CYW43 Wi-fi firmware object using additional flash partition(s) although this firmware is not updated by this example. +Note: This example _also_ demonstrates how the CYW43 Wi-fi firmware can be stored in a separate flash partition(s). This means the Pico 2 W application can be updated separately which reduces the size of the update download. For more information flash partitioning and boot image selection please see section 5 of [RP2350 datasheet](https://datasheets.raspberrypi.com/rp2350/rp2350-datasheet.pdf) @@ -20,7 +22,7 @@ For more information flash partitioning and boot image selection please see sect Before the example can be run, the Flash on the Pico 2 W must be appropriately partitioned. -Flash partitioning only needs doing only once for this example but, as written below, will completely remove any previous flash contents. +Flash partitioning only needs to be done once for this example but, as written below, will completely remove any previous flash contents. The required partition data can be loaded by creating a UF2 from the partition table JSON in this folder: @@ -33,19 +35,44 @@ picotool load pt.uf2 picotool reboot -u ``` -Once the partition table is loaded, you first need to load the Wi-Fi firmware UF2 (`picow_ota_update_wifi_firmware.uf2`) followed by loading and executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: +> [!NOTE] +> `reboot -u` reboots back to bootsel mode so we can send more commands to the device + +Once the partition table is loaded, you then need to load the Wi-Fi firmware UF2 (`picow_ota_update_firmware.uf2`) followed by loading and executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: ``` -picotool load picow_ota_update_wifi_firmware.uf2 +picotool load picow_ota_update_firmware.uf2 picotool load -x picow_ota_update.uf2 ``` +> [!NOTE] +> `load -x` attempts to execute the uf2 after the load + ### Operation -Once running, you can use [python_ota_update.py](python_ota_update.py) to upload new UF2s from the host to it using it's IP address. For example: +This example will send debug output text on the default UART. On startup it displays the current boot partition (from where the firmware is running) and IP address of the Pico 2 W + +``` +Boot partition was 0 +Starting server at 192.168.0.103 on port 4242 +``` + +Once running, you can use [python_ota_update.py](python_ota_update.py) to upload new UF2s from the host to the Pico 2 W using it's IP address. For example: ``` python ./python_ota_update.py 192.168.0.103 picow_ota_update.uf2 ``` +This will update the Pico 2 W at `192.168.0.103` with the specified image. -Will update the Pico 2 W at `192.168.0.103` with the specified image. +``` +Code Target partition is fc6d21b6 fc061003 +Start 1b6000, End 36a000, Size 1b4000 +Done - rebooting for a flash update boot 0 +Chosen CYW43 firmware in partition 2 +Boot partition was 1 +Someone updated into me +Flash update base was 101b6000 +Update info 1 +Update info now 4 +Starting server at 192.168.0.103 on port 4242 +``` -Note: This example will send debug output text on the default UART 0, `GPIO 0`. +The update is downloaded into the free boot partition that's not currently in use, before rebooting the Pico 2 W to take the new software into use. After the restart the boot partition should have changed. From 59fc3f950179cfeae9a0fe728e8521b6410d7855 Mon Sep 17 00:00:00 2001 From: Andrew Burge Date: Mon, 28 Jul 2025 15:04:28 +0100 Subject: [PATCH 3/7] Further improve readme. --- pico_w/wifi/ota_update/README.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/pico_w/wifi/ota_update/README.md b/pico_w/wifi/ota_update/README.md index ffd54bccc..d422c73bf 100644 --- a/pico_w/wifi/ota_update/README.md +++ b/pico_w/wifi/ota_update/README.md @@ -2,13 +2,15 @@ This example demonstrates how to implement an Over The Air (OTA) software update mechanism using facilities provided by the RP2350 bootrom. - A python script runs on a host machine to _push_ a new operating software image to a Pico 2 W running the `ota_update` example image. The incoming image is received via the LwIP IP stack and programmed into Pico 2 W flash memory. +A python script runs on a host machine to _push_ a new (UF2 format) operating software image to a Pico 2 W running the `ota_update` example image. The incoming image is received via the LwIP IP stack and programmed into Pico 2 W flash memory. On successful completion of the flash programming, the Pico 2 W will be rebooted and the updated operating image will be selected and executed by the RP2350 bootrom. This process can be repeated as required. ## More detail -The Pico 2 W listens on TCP port 4242. The incoming octet stream, pushed by the host, is expected to be a sequence of UF2 blocks which are programmed into Pico 2 W flash using the APIs provided by the RP2350 bootrom. In addition to programming, the received data is 'hashed' using the RP2350 SHA256 hardware, and the hash sent back to host to allow integrity checking. +The Pico 2 W listens on TCP port 4242. The host [python_ota_update.py](python_ota_update.py) script transmits the update image in a series of fixed sized chunks. Each chunk contains an integer number of UF2 image blocks. If the update image UF2 block count is not an exact sub-multiple of the number of chunks the script will pad the last chunk as required. + +On receipt of pushed chunks, the ota_update image will program the UF2 block stream into flash using the APIs provided by the RP2350 bootrom. In addition to programming, each chunk is 'hashed', using SHA256, and the calculated hash transmitted to the host as an acknowledgement of the received chunk. The host script compares the local and remotely computed hashes and if data corruption has occurred the update will halt. The flash must be appropriately partitioned for this example to work. Two ` IMAGE_DEF` partitions are required, one for the currently running software and the other which is updated by the `ota_update` example. @@ -35,7 +37,7 @@ picotool load pt.uf2 picotool reboot -u ``` -> [!NOTE] +> **NOTE** > `reboot -u` reboots back to bootsel mode so we can send more commands to the device Once the partition table is loaded, you then need to load the Wi-Fi firmware UF2 (`picow_ota_update_firmware.uf2`) followed by loading and executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: @@ -44,7 +46,7 @@ picotool load picow_ota_update_firmware.uf2 picotool load -x picow_ota_update.uf2 ``` -> [!NOTE] +> **NOTE** > `load -x` attempts to execute the uf2 after the load ### Operation From ea78f2e5bdecd9771c666337ed2a6a4999a2d569 Mon Sep 17 00:00:00 2001 From: Peter Harper Date: Mon, 28 Jul 2025 16:49:50 +0100 Subject: [PATCH 4/7] Fix it's --- pico_w/wifi/ota_update/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pico_w/wifi/ota_update/README.md b/pico_w/wifi/ota_update/README.md index d422c73bf..22eb9332d 100644 --- a/pico_w/wifi/ota_update/README.md +++ b/pico_w/wifi/ota_update/README.md @@ -58,7 +58,7 @@ Boot partition was 0 Starting server at 192.168.0.103 on port 4242 ``` -Once running, you can use [python_ota_update.py](python_ota_update.py) to upload new UF2s from the host to the Pico 2 W using it's IP address. For example: +Once running, you can use [python_ota_update.py](python_ota_update.py) to upload new UF2s from the host to the Pico 2 W using its IP address. For example: ``` python ./python_ota_update.py 192.168.0.103 picow_ota_update.uf2 ``` From ff10acdad0e4eae9399800e84d253a860568892f Mon Sep 17 00:00:00 2001 From: Peter Harper Date: Mon, 28 Jul 2025 16:59:24 +0100 Subject: [PATCH 5/7] Some fixes --- pico_w/wifi/ota_update/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pico_w/wifi/ota_update/README.md b/pico_w/wifi/ota_update/README.md index 22eb9332d..7f660b445 100644 --- a/pico_w/wifi/ota_update/README.md +++ b/pico_w/wifi/ota_update/README.md @@ -2,7 +2,7 @@ This example demonstrates how to implement an Over The Air (OTA) software update mechanism using facilities provided by the RP2350 bootrom. -A python script runs on a host machine to _push_ a new (UF2 format) operating software image to a Pico 2 W running the `ota_update` example image. The incoming image is received via the LwIP IP stack and programmed into Pico 2 W flash memory. +A python script runs on a host machine to _push_ a new (UF2 format) software image to a Pico 2 W running the `ota_update` example image. The incoming image is received via the LwIP IP stack and programmed into Pico 2 W flash memory. On successful completion of the flash programming, the Pico 2 W will be rebooted and the updated operating image will be selected and executed by the RP2350 bootrom. This process can be repeated as required. @@ -40,9 +40,9 @@ picotool reboot -u > **NOTE** > `reboot -u` reboots back to bootsel mode so we can send more commands to the device -Once the partition table is loaded, you then need to load the Wi-Fi firmware UF2 (`picow_ota_update_firmware.uf2`) followed by loading and executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: +Once the partition table is loaded, you then need to load the Wi-Fi firmware UF2 (`picow_ota_update_wifi_firmware.uf2`) followed by loading and executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: ``` -picotool load picow_ota_update_firmware.uf2 +picotool load picow_ota_update_wifi_firmware.uf2 picotool load -x picow_ota_update.uf2 ``` From 0fe635ac9cbb421165cbc812e9665e2385ab683e Mon Sep 17 00:00:00 2001 From: Graham Sanderson Date: Mon, 28 Jul 2025 12:21:47 -0500 Subject: [PATCH 6/7] Update README.md --- pico_w/wifi/ota_update/README.md | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/pico_w/wifi/ota_update/README.md b/pico_w/wifi/ota_update/README.md index 7f660b445..afa6b7b10 100644 --- a/pico_w/wifi/ota_update/README.md +++ b/pico_w/wifi/ota_update/README.md @@ -1,8 +1,10 @@ # Overview -This example demonstrates how to implement an Over The Air (OTA) software update mechanism using facilities provided by the RP2350 bootrom. +This example demonstrates how to implement an Over-The-Air (OTA) software update mechanism using facilities provided by the RP2350 bootrom. -A python script runs on a host machine to _push_ a new (UF2 format) software image to a Pico 2 W running the `ota_update` example image. The incoming image is received via the LwIP IP stack and programmed into Pico 2 W flash memory. +A python script runs on a host machine to _push_ a new (UF2 format) application image to a Pico 2 W running the `ota_update` example application. The incoming application image is received via the LwIP IP stack and programmed into Pico 2 W flash memory. + +Two flash partitions ("A"/"B") are used for application images so that the application can be running from one, while the new application image is being written to the other. The RP2350 bootrom provides support for determining the location in flash memory to write the new version of the application. On successful completion of the flash programming, the Pico 2 W will be rebooted and the updated operating image will be selected and executed by the RP2350 bootrom. This process can be repeated as required. @@ -12,21 +14,19 @@ The Pico 2 W listens on TCP port 4242. The host [python_ota_update.py](python_o On receipt of pushed chunks, the ota_update image will program the UF2 block stream into flash using the APIs provided by the RP2350 bootrom. In addition to programming, each chunk is 'hashed', using SHA256, and the calculated hash transmitted to the host as an acknowledgement of the received chunk. The host script compares the local and remotely computed hashes and if data corruption has occurred the update will halt. -The flash must be appropriately partitioned for this example to work. Two ` IMAGE_DEF` partitions are required, one for the currently running software and the other which is updated by the `ota_update` example. +The flash must be appropriately partitioned for this example to work. Two partitions are required, one for the currently running software and the other to be updated with incoming data. Note: This example _also_ demonstrates how the CYW43 Wi-fi firmware can be stored in a separate flash partition(s). This means the Pico 2 W application can be updated separately which reduces the size of the update download. For more information flash partitioning and boot image selection please see section 5 of [RP2350 datasheet](https://datasheets.raspberrypi.com/rp2350/rp2350-datasheet.pdf) -## How to +# How to -### Flash partitioning +## Flash partitioning Before the example can be run, the Flash on the Pico 2 W must be appropriately partitioned. -Flash partitioning only needs to be done once for this example but, as written below, will completely remove any previous flash contents. - -The required partition data can be loaded by creating a UF2 from the partition table JSON in this folder: +The required partition data can be loaded by creating a UF2 from the supplied partition table JSON in this folder: ``` picotool partition create main.json pt.uf2 @@ -38,18 +38,18 @@ picotool reboot -u ``` > **NOTE** -> `reboot -u` reboots back to bootsel mode so we can send more commands to the device +> `reboot -u` reboots back to bootsel mode so we can send more commands to the device, and additionally the device needs to have rebooted in order for the partition table to take effect. -Once the partition table is loaded, you then need to load the Wi-Fi firmware UF2 (`picow_ota_update_wifi_firmware.uf2`) followed by loading and executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: +WIth the partition table loaded, you then need to load the Wi-Fi firmware UF2 (`picow_ota_update_wifi_firmware.uf2`) followed by loading and executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: ``` picotool load picow_ota_update_wifi_firmware.uf2 picotool load -x picow_ota_update.uf2 ``` > **NOTE** -> `load -x` attempts to execute the uf2 after the load +> The first `load` writes the Wifi Firmware into one of the partitions set aside for that. The second `load -x` loads the main application code into one of the main partitions, then resets the chip to start execution (`-x`) -### Operation +## Operation This example will send debug output text on the default UART. On startup it displays the current boot partition (from where the firmware is running) and IP address of the Pico 2 W @@ -77,4 +77,4 @@ Update info now 4 Starting server at 192.168.0.103 on port 4242 ``` -The update is downloaded into the free boot partition that's not currently in use, before rebooting the Pico 2 W to take the new software into use. After the restart the boot partition should have changed. +The update is downloaded into the main partition that's not currently in use, before rebooting the Pico 2 W to run the new version of the software. This choice of software is made by the RP2350 bootrom based on the version number of the software From 15aae9fb7013dbed31472b835cb0fc3897fb3d7d Mon Sep 17 00:00:00 2001 From: Graham Sanderson Date: Mon, 28 Jul 2025 12:36:19 -0500 Subject: [PATCH 7/7] Update README.md again --- pico_w/wifi/ota_update/README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/pico_w/wifi/ota_update/README.md b/pico_w/wifi/ota_update/README.md index afa6b7b10..72c96f0a7 100644 --- a/pico_w/wifi/ota_update/README.md +++ b/pico_w/wifi/ota_update/README.md @@ -4,19 +4,19 @@ This example demonstrates how to implement an Over-The-Air (OTA) software update A python script runs on a host machine to _push_ a new (UF2 format) application image to a Pico 2 W running the `ota_update` example application. The incoming application image is received via the LwIP IP stack and programmed into Pico 2 W flash memory. -Two flash partitions ("A"/"B") are used for application images so that the application can be running from one, while the new application image is being written to the other. The RP2350 bootrom provides support for determining the location in flash memory to write the new version of the application. +Two flash partitions ("A"/"B") are used for application images so that the application can be running from one, while the new application image is being written to the other. The RP2350 bootrom provides support for determining the location in flash memory of the partition to use for the new version of the application. -On successful completion of the flash programming, the Pico 2 W will be rebooted and the updated operating image will be selected and executed by the RP2350 bootrom. This process can be repeated as required. +On successful completion of the flash programming, the Pico 2 W is rebooted and the updated applicating image is selected and executed by the RP2350 bootrom. This process can be repeated as required. ## More detail The Pico 2 W listens on TCP port 4242. The host [python_ota_update.py](python_ota_update.py) script transmits the update image in a series of fixed sized chunks. Each chunk contains an integer number of UF2 image blocks. If the update image UF2 block count is not an exact sub-multiple of the number of chunks the script will pad the last chunk as required. -On receipt of pushed chunks, the ota_update image will program the UF2 block stream into flash using the APIs provided by the RP2350 bootrom. In addition to programming, each chunk is 'hashed', using SHA256, and the calculated hash transmitted to the host as an acknowledgement of the received chunk. The host script compares the local and remotely computed hashes and if data corruption has occurred the update will halt. +On receipt of pushed chunks, the ota_update image will program the UF2 block stream into flash. In addition to programming, each chunk is 'hashed', using SHA256, and the calculated hash transmitted to the host as an acknowledgement of the received chunk. The host script compares the local and remotely computed hashes and if data corruption has occurred the update will halt. The flash must be appropriately partitioned for this example to work. Two partitions are required, one for the currently running software and the other to be updated with incoming data. -Note: This example _also_ demonstrates how the CYW43 Wi-fi firmware can be stored in a separate flash partition(s). This means the Pico 2 W application can be updated separately which reduces the size of the update download. +Note: This example _also_ demonstrates how the CYW43 Wi-fi firmware can be stored in a separate flash partition(s). This means the Pico 2 W application can be updated separately which reduces the size of the update download, but also requires four partitions. For more information flash partitioning and boot image selection please see section 5 of [RP2350 datasheet](https://datasheets.raspberrypi.com/rp2350/rp2350-datasheet.pdf) @@ -38,16 +38,16 @@ picotool reboot -u ``` > **NOTE** -> `reboot -u` reboots back to bootsel mode so we can send more commands to the device, and additionally the device needs to have rebooted in order for the partition table to take effect. +> `reboot -u` reboots the device (as is required to install the partition table) then returns to BOOTSEL mode so we can send more commands to the device. -WIth the partition table loaded, you then need to load the Wi-Fi firmware UF2 (`picow_ota_update_wifi_firmware.uf2`) followed by loading and executing the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: +With the partition table loaded, you then need to load the Wi-Fi firmware UF2 (`picow_ota_update_wifi_firmware.uf2`) and load and execute the main program (`picow_ota_update.uf2`) - either by dragging and dropping them in order, or using `picotool`: ``` picotool load picow_ota_update_wifi_firmware.uf2 picotool load -x picow_ota_update.uf2 ``` > **NOTE** -> The first `load` writes the Wifi Firmware into one of the partitions set aside for that. The second `load -x` loads the main application code into one of the main partitions, then resets the chip to start execution (`-x`) +> The first `load` writes the Wifi Firmware into one of the partitions set aside for that. The second `load -x` loads the main application code into one of the main partitions, then resets the chip to start execution ## Operation