{"id":9053,"date":"2014-12-23T12:18:44","date_gmt":"2014-12-23T17:18:44","guid":{"rendered":"http:\/\/embedded-lab.com\/blog\/?p=9053"},"modified":"2023-04-20T23:05:04","modified_gmt":"2023-04-21T03:05:04","slug":"stm32-programming-tips-and-tricks","status":"publish","type":"post","link":"https:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/","title":{"rendered":"STM32 Programming Tips and Tricks"},"content":{"rendered":"<p>I remember that once in the beginning I said that I don\u2019t want to buy a programmer\/debugger hardware for learning a new MCU like the STM32 and also STM32s already come with built-in bootloader to facilitate programming via USART just like Arduino. Still the second is true. Well what about the first? To my own surprise I actually acquired a number of STM32-related stuffs since the time I started playing and exploring them. I actually bought both ST-Link 1 and 2 programmer-debuggers and several STM32 boards from Waveshare Electronics (<a href=\"http:\/\/www.wvshare.com\/\">http:\/\/www.wvshare.com<\/a>). I believe learning new stuffs is more valuable than anything else.<\/p>\n<h3><strong>ST-Link\u00a0<\/strong>Programmer\/Debugger<\/h3>\n<p><span style=\"font-size: 0.95em;line-height: 1.6em\">ST-Link 1 (AKA ST-Link) and ST-Link v2 are both basically the same programmer\/debugger hardware with some minor exceptions. ST-Link 2 has 5V tolerance for JTAG interface, it has a bicolour status LED and it also has a separate programming interface for STM8 micros unlike ST-Link 1. There is also an ISOL version of ST-Link2 that galvanically isolates it from its target using optoelectronics.<\/span><\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/stlinkgreycablewhite\/\" rel=\"attachment wp-att-9055\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-large wp-image-9055\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/stlinkgreycablewhite-1024x632.jpg\" alt=\"stlinkgreycablewhite\" width=\"860\" height=\"530\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/stlinkgreycablewhite-1024x632.jpg 1024w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/stlinkgreycablewhite-550x339.jpg 550w\" sizes=\"auto, (max-width: 860px) 100vw, 860px\" \/><\/a><\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/st-linkv2_3\/\" rel=\"attachment wp-att-9054\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-full wp-image-9054\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/ST-LINKV2_3.png\" alt=\"ST-LINKV2_3\" width=\"534\" height=\"462\" \/><\/a><\/p>\n<p><!--more--><\/p>\n<p>I\u2019m not going to recite all the feature chatters of ST-Link programmers here. All I\u2019ll say is if you want a device that can save your time and efforts from all the procedure involved with serial bootloader, do pro-level works with STM8\/STM32 and debug your codes then you should consider having a ST-Link programmer-debugger. It doesn\u2019t matter much which version it is. For more info on ST-Link programmer-debuggers refer to these links:<\/p>\n<p><a href=\"http:\/\/www.st.com\/web\/catalog\/tools\/FM146\/CL1984\/SC724\/SS1677\/PF251168?sc=internet\/evalboard\/product\/251168.jsp\">http:\/\/www.st.com\/web\/catalog\/tools\/FM146\/CL1984\/SC724\/SS1677\/PF251168?sc=internet\/evalboard\/product\/251168.jsp<\/a><\/p>\n<p><a href=\"http:\/\/www.st.com\/web\/catalog\/tools\/FM146\/CL1984\/SC720\/SS1454\/PF219866\">http:\/\/www.st.com\/web\/catalog\/tools\/FM146\/CL1984\/SC720\/SS1454\/PF219866<\/a><br \/>\nThere cheap and compact clone variants of ST-Link programmers too but I won\u2019t recommend them simply because they don\u2019t have easy plug-in JTAG interface cable, they have poor documentation and they are not genuine. By the way I\u2019m not telling not to buy those. I leave it to the reader. In my experience buying a genuine programmer is always a long-run benefit while keeping a clone alongside the genuine one is like bonus.<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/2744-2\/\" rel=\"attachment wp-att-9056\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-full wp-image-9056\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/2744.2.jpg\" alt=\"2744.2\" width=\"617\" height=\"397\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/2744.2.jpg 617w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/2744.2-550x353.jpg 550w\" sizes=\"auto, (max-width: 617px) 100vw, 617px\" \/><\/a><\/p>\n<p>Hardware driver installations are not complicated and I\u2019m thus skipping this part too. Anyone familiar with Windows environment will figure out everything related to software and driver installation. JTAG\/SWD (Serial Wire Debug) interface terminal is available in most STM32 development boards and can be located by a distinct 20 pin black header that looks like a PC\u2019s IDE cable connector. ST-Link connects with a STM32 via JTAG\/SWD interface. Just be sure that both ends of the header connect according to the notches.<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/397903258_308\/\" rel=\"attachment wp-att-9057\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-full wp-image-9057\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/397903258_308.jpg\" alt=\"397903258_308\" width=\"472\" height=\"269\" \/><\/a><\/p>\n<p>Waveshare Electronics make a variety of STM32 development boards. Their boards are as much as robust as that of MikroElektronika\u2019s. A salient feature of their boards unlike other ARM development board available in the market is the modular plug-in system for connecting external hardware like nRF24L01 modules, TFT displays, flash memories, RTC, etc. In terms of board layout, vivid labelling and user-friendly orientation, I guess Waveshare\u2019s boards are just awesome. I personally use and recommend Waveshare products for their outstanding quality.<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/jtag\/\" rel=\"attachment wp-att-9058\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-full wp-image-9058\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/jtag.jpg\" alt=\"jtag\" width=\"651\" height=\"537\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/jtag.jpg 651w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/jtag-550x453.jpg 550w\" sizes=\"auto, (max-width: 651px) 100vw, 651px\" \/><\/a><\/p>\n<p>The software interface for both ST-Link 1 and 2 is <b><i>STM32 St-Link Utility<\/i><\/b>. This software is for STM32 micros only. STM8 micros need another software to use these programmers. Since we are currently dealing with STM32 micros, we\u2019ll be discussing about <b><i>STM32 St-Link Utility <\/i><\/b>only.<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/gui1\/\" rel=\"attachment wp-att-9062\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-large wp-image-9062\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/gui1-1024x546.png\" alt=\"gui1\" width=\"860\" height=\"458\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/gui1-1024x546.png 1024w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/gui1-550x293.png 550w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/gui1.png 1359w\" sizes=\"auto, (max-width: 860px) 100vw, 860px\" \/><\/a><\/p>\n<p>The GUI is pretty straight forward. Just like any programmer GUI it has iconic buttons for various tasks. However unlike most other programmer GUI we\u2019ll need to connect to the programmer hardware manually using the connect button (plug like icon).<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/gui-2\/\" rel=\"attachment wp-att-9061\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-large wp-image-9061\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/gui-2-1024x547.png\" alt=\"gui 2\" width=\"860\" height=\"459\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/gui-2-1024x547.png 1024w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/gui-2-550x294.png 550w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/gui-2.png 1359w\" sizes=\"auto, (max-width: 860px) 100vw, 860px\" \/><\/a><\/p>\n<p>Once connected the programmer hardware will communicate with the target micro and find out details about it. These details include flash memory size, page protection settings, fuses, device series\/family and other stuffs. When there\u2019s a successful connection, the LED in ST-Link hardware starts flashing randomly. There\u2019s also a disconnect button to terminate the communication between target MCU and ST-Link.<\/p>\n<p>Just like any other programmer GUI we can browse for bin\/hex files to be imported to or exported from the target MCU, set fuse settings and erase its memories. Thus there is nothing exceptionally different. A cool feature of ST-Link programmers is to be able to debug a code step-by-step.<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/gui3\/\" rel=\"attachment wp-att-9059\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-full wp-image-9059\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/gui3.png\" alt=\"gui3\" width=\"471\" height=\"176\" \/><\/a><\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/20140822_203340\/\" rel=\"attachment wp-att-9063\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-large wp-image-9063\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_203340-1024x534.jpg\" alt=\"20140822_203340\" width=\"860\" height=\"448\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_203340-1024x534.jpg 1024w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_203340-550x287.jpg 550w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_203340.jpg 1369w\" sizes=\"auto, (max-width: 860px) 100vw, 860px\" \/><\/a> <a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/20140822_202345\/\" rel=\"attachment wp-att-9064\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-large wp-image-9064\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_202345-1024x465.jpg\" alt=\"20140822_202345\" width=\"860\" height=\"390\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_202345-1024x465.jpg 1024w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_202345-550x249.jpg 550w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_202345.jpg 1369w\" sizes=\"auto, (max-width: 860px) 100vw, 860px\" \/><\/a><\/p>\n<p>Check out the video links to see how they work:<\/p>\n<p><i>ST-Link 1: <\/i><a href=\"https:\/\/www.youtube.com\/watch?v=tcU1HwI_3Mk\"><i>https:\/\/www.youtube.com\/watch?v=tcU1HwI_3Mk<\/i><\/a><i><\/i><\/p>\n<p><i>ST-Link v2: <\/i><a href=\"https:\/\/www.youtube.com\/watch?v=j5L41eJ0UNc\"><i>https:\/\/www.youtube.com\/watch?v=j5L41eJ0UNc<\/i><\/a><i>.<\/i><br \/>\nPlease be noted that using the programmer doesn\u2019t cause any problem with serial bootloader. If a STM32 chip is set to full erase, the bootloader is still retained. As per ST\u2019s documentations mass-erase doesn\u2019t affect information blocks. Thus there are always two ways of programming a STM32 micro. This is very useful because even if for some reason your ST-Link gets damaged and unable to program, you still have serial bootloader option to get the job done.<\/p>\n<p><span style=\"color: #222222;font-size: 3em;font-weight: bold;line-height: 1em\" data-darkreader-inline-color=\"\">Leaf Maple Boards<\/span><br \/>\nMany people from the Arduino community are using Leaf Maple boards as 32-bit alternatives to 8-bit AVR core based mainstream Arduino boards apart from Arduino Zero and Arduino Due. 32-bit micros as we know are far more powerful than 8-bit ones in every aspect. Leaf Maple boards are designed with STM32F10x series micros, specifically with STM32F103s and have Arduino-like form factor. Thus Arduino shields can be used easily. Maple boards got my attention not because they are based on Arduino-like coding or have Arduino-like features but for the fact that I can use my existing array of Arduino shields to make stuffs with STM32 micros easily and without any new investment on hardware. For instance I have a 2.4 inch TFT touch display shield for Arduino Uno, now I can use that for playing with STM32 too. This helped me to avoid buying and fabricating a new TFT touch display just for STM32s. One thing I like about Arduino platform is the ease it offers in formulating a prototype design. Many of my prototypes are based on Arduino platform and it is there I enjoy it much. With Maple boards the fun gets greater. However I\u2019m not willing to use those boards like Arduinos because Arduino platform is not a professional one. I want them to be able to work without the Arduino framework. To get this done we can use either ST-link programmers or the serial bootloader.<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/20140822_220259\/\" rel=\"attachment wp-att-9066\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-large wp-image-9066\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_220259-1024x543.jpg\" alt=\"20140822_220259\" width=\"860\" height=\"456\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_220259-1024x543.jpg 1024w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_220259-550x291.jpg 550w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_220259.jpg 1369w\" sizes=\"auto, (max-width: 860px) 100vw, 860px\" \/><\/a><\/p>\n<p>There are several key differences between Maple boards and typical STM32 development boards and these are:<\/p>\n<ul>\n<li>Absence of standard 20 pin JTAG\/SWD headers in Maple boards.<\/li>\n<li>Pin orientation and naming convention.<\/li>\n<li>Absence of boot jumpers in Maple boards<\/li>\n<li>Board size, layout and form-factor.<\/li>\n<li>Maple is based on STM32F10x series micros. There\u2019s no support for other STM32 micros.<\/li>\n<li>Maple comes with its own USB bootloader that can\u2019t be used without DFU enumeration process.<\/li>\n<\/ul>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/im120411012_3\/\" rel=\"attachment wp-att-9068\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-full wp-image-9068\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/im120411012_3.jpg\" alt=\"im120411012_3\" width=\"733\" height=\"562\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/im120411012_3.jpg 733w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/im120411012_3-550x421.jpg 550w\" sizes=\"auto, (max-width: 733px) 100vw, 733px\" \/><\/a><\/p>\n<p>From our previous knowledge on STM32\u2019s serial booloader we know that we only have to change <b><i>Boot 0 <\/i><\/b>pin state in order to enter serial bootloader mode. Maple boards have one extra button apart from reset button. Usually this button is named either as <b><i>BUT <\/i><\/b>or<b><i> BOOT<\/i> <\/b>as per Leaf Maple\u2019s design. This button is attached to the <b><i>Boot 0<\/i><\/b> pin of STM32. First connect the <b>TX1, RX1 <\/b>and<b> power<\/b> pins of your Maple board with a USB-serial converter. Remember that STM32s operate with 3.3V power and so avoid using a USB-serial converter that operates above 3.3V. According to Leaf Maple\u2019s documentations <b>TX1 <\/b>and <b>RX1<\/b> pins are located at pins <b>D26<\/b> and <b>D25<\/b> respectively for Maple Mini and at <b>D7<\/b> and <b>D8<\/b> respectively for Maple board. Secondly to enter the serial bootloader mode we\u2019ll have to go according to the sequence below:<\/p>\n<ol>\n<li>Hold the <b><i>Reset<\/i><\/b> button first and then the <b><i>Boot\/BUT<\/i><\/b> button.<\/li>\n<li>Release the <b><i>Reset<\/i><\/b> button first and then the <b><i>Boot\/BUT<\/i><\/b> button.<\/li>\n<li>Run the ST\u2019s <b><i>Flash Loader Demo<\/i><\/b> software.<\/li>\n<li>Provided that the settings of that Flash Loader Demo GUI are set properly, hit the <b><i>Next<\/i><\/b> button and continue as usual.<\/li>\n<\/ol>\n<p>Please be noted that while in serial bootloader mode no LED on a Maple board will be blinking. Only the power LED (if any) will remain turned on. The board will behave as if it is unpowered or dead. This is normal and so there\u2019s no reason to worry.<\/p>\n<p>If you have missed my post on STM32\u2019s serial bootloader mode then check out this link:<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/?p=8764\"><i>http:\/\/embedded-lab.com\/blog\/?p=8764<\/i><\/a><i>.<\/i><\/p>\n<p>To avoid confusion, here are the above described four bootloader steps visually shown:<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/boot-sequence\/\" rel=\"attachment wp-att-9067\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-full wp-image-9067\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/boot-sequence.png\" alt=\"boot sequence\" width=\"463\" height=\"480\" \/><\/a><\/p>\n<p>I have accessed my Maple boards and here are the videos and photos of them at action:<\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/bootload1\/\" rel=\"attachment wp-att-9060\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-full wp-image-9060\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/bootload1.png\" alt=\"bootload1\" width=\"412\" height=\"528\" \/><\/a><\/p>\n<p><a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/20140822_214332\/\" rel=\"attachment wp-att-9069\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-large wp-image-9069\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_214332-1024x764.jpg\" alt=\"20140822_214332\" width=\"860\" height=\"641\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_214332-1024x764.jpg 1024w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_214332-550x410.jpg 550w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_214332.jpg 1369w\" sizes=\"auto, (max-width: 860px) 100vw, 860px\" \/><\/a> <a href=\"http:\/\/embedded-lab.com\/blog\/stm32-programming-tips-and-tricks\/20140822_215444\/\" rel=\"attachment wp-att-9065\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter size-large wp-image-9065\" src=\"http:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_215444-1024x873.jpg\" alt=\"20140822_215444\" width=\"860\" height=\"733\" srcset=\"https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_215444-1024x873.jpg 1024w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_215444-550x469.jpg 550w, https:\/\/embedded-lab.com\/blog\/wp-content\/uploads\/2014\/08\/20140822_215444.jpg 1369w\" sizes=\"auto, (max-width: 860px) 100vw, 860px\" \/><\/a><\/p>\n<p>Video links:<\/p>\n<p><i>Maple Mini: <\/i><a href=\"https:\/\/www.youtube.com\/watch?v=9VwLyCkj95U\"><i>https:\/\/www.youtube.com\/watch?v=9VwLyCkj95U<\/i><\/a><i>.<\/i><\/p>\n<p><i>Maple Board: <\/i><a href=\"https:\/\/www.youtube.com\/watch?v=__gWcS-o_iU\"><i>https:\/\/www.youtube.com\/watch?v=__gWcS-o_iU<\/i><\/a><i>.<\/i><\/p>\n<p><i>\u00a0<\/i><\/p>\n<p>Happy playing with STM32s.<\/p>\n<p>Repository: <a href=\"https:\/\/github.com\/sshahryiar\/STM32-Tutorials\">https:\/\/github.com\/sshahryiar\/STM32-Tutorials<\/a><\/p>\n<p><i>Author: Shawon M. Shahryiar<br \/>\n<\/i><\/p>\n<p><a href=\"https:\/\/www.youtube.com\/c\/sshahryiar\">https:\/\/www.youtube.com\/c\/sshahryiar<\/a><\/p>\n<p><a href=\"https:\/\/github.com\/sshahryiar\">https:\/\/github.com\/sshahryiar<\/a><\/p>\n<p><a href=\"mailto:sshahryiar@gmail.com\"><i>sshahryiar@gmail.com<\/i><\/a><i><\/i><i>\u00a0 \u00a0 \u00a0 \u00a0 <\/i><\/p>\n","protected":false},"excerpt":{"rendered":"<p>I remember that once in the beginning I said that I don\u2019t want to buy a programmer\/debugger hardware for learning a new MCU like the STM32 and also STM32s already come with built-in bootloader to facilitate programming via USART just like Arduino. Still the second is true. Well what about the first? To my own surprise I actually acquired a number of STM32-related stuffs since the time I started playing and exploring them. I actually bought both ST-Link 1 and 2 programmer-debuggers and several STM32 boards from Waveshare Electronics (http:\/\/www.wvshare.com). I believe learning new stuffs is more valuable than anything<\/p>\n","protected":false},"author":5,"featured_media":9054,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[733,1474,1466],"tags":[799,803,1319,850],"class_list":["post-9053","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-stm32","category-stm32-tutorials","category-tutorials","tag-advanced-embedded-systems","tag-arm-microcontrollers","tag-stm32","tag-stmicroelectronics"],"_links":{"self":[{"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/posts\/9053","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/comments?post=9053"}],"version-history":[{"count":10,"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/posts\/9053\/revisions"}],"predecessor-version":[{"id":15158,"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/posts\/9053\/revisions\/15158"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/media\/9054"}],"wp:attachment":[{"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/media?parent=9053"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/categories?post=9053"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/embedded-lab.com\/blog\/wp-json\/wp\/v2\/tags?post=9053"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}