Maple Mini

This page is a general resource for information specific to the Maple Mini. The Maple Mini is a smaller version of the Maple that fits on a breadboard.

$ git clone git://github.com/leaflabs/maplemini.git

CZ miniSTM32F103V -EK

CZ miniSTM32F103V_-EK

Contents

 [hide] 

• 1 Name
• 2 Specs
  • 2.1 Board features
• 3 Known issues
• 4 Schematic
• 5 Forum link

Name

CZ miniSTM32F103V_-EK

Specs

512kb Flash, 64kB RAM, 2 × 12-bit D/A converters 112 fast I/O ports 2 × I2C 5 USARTs 3 SPIs (18 Mbit/s), 2 with I2S interface multiplexed 32 kHz oscillator for RTC with calibration Supports Compact Flash, SRAM, PSRAM, NOR and NAND memories

Board features

all pin holders / rows already soldered Boot0 and Boot1 jumper jumpers (RX,TX) for the USB-Serial converter 2x USB one with CH340 RS232-USB-converter chip (“Serial1”) 32.768kHz and 8Mhz oscillators on board CR1220 battery holder reset button Two user buttons: PD12, PC0 Two controllable LED; PE5, PE6 power indicator LED; JTAG / SWD 20 -pin standard interface ; 32 foot FSMC TFT LCD screen interface Board size : 101.5 mm x 76.68 mm

additional chips (already soldered) SPI flash W25q16 (on SPI1: CS: PA4, MISO: PA6, MOSI: PA7, SCK: PA5) EEPROM 24C02 (on I2C1: SCL: PB6, SDA: PB7 both with 4.7K pullup) IC Adress: 0x00 ( A0=A1=A2=GND) space holder for 485 IC (PA3, PA0, PA2) and DS18B20 (Data: PB14)

Known issues

• None

Schematic

Media:Cz_ministm32f103v-ek_schematic.pdf

Forum link

http://www.stm32duino.com/viewtopic.php?f=28&t=490

Wio GPS – also called Wio Tracker – is an Arduino compatible board based on Microchip Atmel SAMD21 MCU with GPS, Bluetooth, GSM/GPRS connectivity, as well as several Grove connectors to connect sensors and modules for your IoT project. SeeedStudio sent me a sample for evaluation, so I’ve tested it, and reported my experience below by testing some of the Arduino sketches.

Wio Tracker Unboxing

All I got in the package was Wio GPS tracker v1.1 board. The top includes the Atmel MCU, an RGB LED, a microphone and 3.5mm AUX jack to make phone calls, a user and power button, a micro USB port for power and programming, a small 2-pin connector for a battery, and 6 Grove connectors for digital, serial, I2C and analog modules.

The other side of the board comes with Quectel MC20 module that handles Bluetooth, GPS and GSM, a dual use micro SD card and nano SIM slot, and the GPS, 2G, and Bluetooth antennas. We can also see -/+ footprints close to connect speakers close to the OSHW logo.

Getting Started with Wio GPS Tracker with Arduino IDE

I’ve been following Wio GPS Board Wiki for this part of the review, and as we’ll soon discovered I’ve had a rather mixed experience.

First, you’ll need a micro USB to USB cable to connect the board to Windows/Linux/Mac computer. This is the kernel output I got from Ubuntu 16.04:

After installing Arduino IDE for your operating system, we can add Seeduino boards to the IDE, by going to File->Preferences and pasting the link https://raw.githubusercontent.com/Seeed-Studio/Seeed_Platform/master/package_seeeduino_boards_index.json into Additional Boards Manager URL field, and clicking OK.Now go to Tools->Boards->Boards Manager search for wio, and install Seeduino SAMD by Seeed Studio.

You can also install Adafruit Neopixel by going to to Sketch->Manage Libraries->Include Library, or importing the zip file. After that point, I decided to check whether I could find “Wio Tracker” in the list of boards as indicated in the Wiki, but there was no such board so I selected Wio GPS Board, and selected port /dev/ttyACM0 (Wio GPS Board) port.

Then I went to check for sample sketches, and found some in Examples->Seeed_Wio_GPS_Board for the all key features of the board. So I tried a bunch of them including RGB_LED, Bluetooth, GNSS (GPS), and GSM (Send SMS), and only the Bluetooth sample would work.

By I went back to the Wiki, and found out I add to import Wio Tracker library too, which I did, and I had another very similar sets of samples for MC20_GPS_Traker-master.

I’m not exactly sure we have two separate sets of nearly identical samples, but let’s see if I have more like with samples in MC20_GPS_Tracker-master folder.

Blink.ino is supposed to blink the RGB using blue color:

I could upload the program to the board with the following warning messages:

The RGB LED did not work. So I tried to remove Adafruit Neopixel library, same results. Finally I checked schematics to confirm the RGB LED is indeed connected to D10, and inserted some println debug code to make sure the program is running properly. Everything seems right, but the RGB LED would not blink. I’ve contacted the company, but unsurprinsgly they don’t work during the week-end.

Let’s move on with BT_CLientHandle.ino sketch that should allow us to pair the board with your phone. The code is relatively simple for this task:

I could see QUECTEL-BT with my Android phone, and had no problem to pair the board.

The serial output with pairing, and disconnecting events shows some of the AT commands used:

I also tried to connect a speaker to the AUX port of the board to see if I could use it as Bluetooth speaker, but it did not work, so some more code and a different Bluetooth audio profile (not HF_PROFILE) are likely required. All I could hear was dial-up modem sounds from the speakers. But still, we can tick this Bluetooth test as success.

Time for a GPS test. GNSS_Show_Coordinate.ino sketch is supposed to  output latitude and longitude to the serial console, and again the code to achieve this is still fairly simple:

But all I got in the serial output was the following:

With +CREG: 0,0 shown over and over. We can find the different AT Command sets (and EAGLE schematics) in the resources directory in Github. One of the document reports that AT+CREG? is a read command to retrieve network registration status, and the two numbers referred as <n> and <stat> are set to 0,0 meaning that:

1. Disable network registration unsolicited result code
2. Not registered, ME is not currently searching a new network to register on

I firstly did the test indoors, and although previously I could get a signal indoors with NavSpark mini board, I still went outside in case it was a signal problem, but the result was just the same. So maybe the program is stuck somewhere because I had not inserted a SIM card yet. Since I was not sure whether my operator still supported 2G, I forced my Android phone to use 2G, and the phone did get a signal using “E” instead of the usual 3G, and I could send an SMS and make a phone call over 2G network (I think).

So I took out the SIM card from my phone, and …. I could not insert right away simply because my SIM card was cut out as a micro SIM, but the board requires a nano SIM. Luckily, I purchased nano/micro SIM card adapters a while ago as I knew sooner or later I would have this little first world problem. You can find those for less than $1 on eBay, so even if you don’t need them right now, it might be a good idea to get some.

Once I cut out my SIM card so that it fits into the micro SIM to nano SIM adapter that I will need to use when I put back the SIM card into my smartphone, I inserted  the nano SIM and a micro SD card at the same time, as the picture below shows with the white band right above the 4GB micro SD card being the nano SIM card. I did not know they made those, as I’ve only seen shared slots in the past.

I reran the GPS sample program, and the serial output changes a bit, but still no longitude and latitude info:

+QGNSSC:1 means the GNSS module is powered on so that’s good news I guess.

+CREG: 0,2 means the SIM card is registered, and in home network, but then it will switch to +CREG:0,5 meaning the SIM card is registered and roaming. Not really re-assuring.

They also have a more complex sample called GNSS_Google_KML.ino, that will get coordinate display them in OLED display attached to the board, and save data into a gps.txt into the SD card with raw longitude and latitude data that can be inserted into a Google KML file. A GoogleMapDemo.ino sketch will upload your coordinates to ziladuo.com website. That’s provided it works of course… and considering the simplest sample GNSS would not work. I gave up on GPS/GNSS tests.

Last try was with the GSM function with the send SMS sample (MC20_SMSSend.ino) that will send “Hello MC20!!” message to the phone number of your choice”. Again it’s very easy to program:

But sadly I could not send an SMS, as the function waitForNetworkRegister failed:

I had to end my testing there. I could not remove the nano SIM card with my hands, and I had to use a pair  tweezers to get it out by pushing those the small holes on top of the slot mechanism.

So overall my experience with the board was quite catastrophic with only Bluetooth working,  and GPS, 2G GSM, and even the RGB LED sample all failing. I also often had trouble uploading the code to the board with messages like:

or (even after having close to the serial terminal for a while):

So I often had to re-try and re-try to successfully upload the code to the board. I’m sure there must be an explanation for all the issues I had. I can see they tested it in Windows, but I’m using Ubuntu 16.04, so maybe that could be one reason?

Having said that, if the board actually worked, I really like what SeeedStudio has done, as it looks really easy to program the board with GPS, Bluetooth, or 2G data, SMS, calls, and you can add Grove Sensors to make pretty more advanced IoT projects. The company also provides a more practical sample with their “Wild Adventure Tracker” demo reporting sending GPS coordinates over SMS when a shock occurs. The source code on Github with a video showing the results below.

The company is also working on a 4G version, and I’ll probably have a chance to give it another try once it is released. If you are interested in Wio GPS Tracker board, you can pre-order it for $24.95 including all three antennas.

Guide to installing Arduino on Ubuntu Virtualbox Guest under Windows Host

$ sudo apt-get install arduino

$ sudo apt-get install picocom

$ sudo pip install ino

$ mkdir ~/arduino
$ cd ~/arduino

$ mkdir testproject
$ cd testproject

$ ino init

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#define LED_PIN 13

void setup()
{
    pinMode(LED_PIN, OUTPUT);
}

void loop()
{
    digitalWrite(LED_PIN, HIGH);
    delay(100);
    digitalWrite(LED_PIN, LOW);
    delay(100);
}

$ cd ~/arduino/testproject
$ ino build

$ ino upload -p /dev/ttyS0

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e950f
avrdude: reading input file ".build/uno/firmware.hex"
avrdude: writing flash (1034 bytes):

Writing | ################################################## | 100% 0.67s

avrdude: 1034 bytes of flash written
avrdude: verifying flash memory against .build/uno/firmware.hex:
avrdude: load data flash data from input file .build/uno/firmware.hex:
avrdude: input file .build/uno/firmware.hex contains 1034 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.20s

avrdude: verifying ...
avrdude: 1034 bytes of flash verified

avrdude: safemode: Fuses OK

avrdude done.  Thank you.

~/arduino/testproject$ ino upload -p /dev/ttyS0
/bin/stty: /dev/ttyS0: Permission denied
stty failed

$ ls -al /dev/ttyS0

crw------- 1 root dialout 4, 64 May  7 04:34 /dev/ttyS0

$ sudo usermod -a -G dialout YOUR_USER_NAME
$ sudo chmod 660 /dev/ttyS0

$ cd ~/arduino/testproject
$ ino upload -p /dev/ttyS0

$ echo -e "serial-port = /dev/ttyS0\n" > ~/.inorc

$ ino upload

LoRaWAN Part 1: How to Get 15 km Wireless and 10-Year Battery Life for IoT

Contributed By Digi-Key’s North American Editors

2016-11-22

How I Got My Dragonboard 410C Airborne

I was recently a guest on 96Boards OpenHours to demonstrate how the Aerocore 2 for Dragonboard 410C can be used to quickly and easily build a working quadcopter.   I even powered it up and tested it out indoors live.

If you want to see what happened, check out the YouTube video. The test flight happens at around the 40-minute mark.

Drones are awesome and not that hard to set up.  You can follow along with me if you’re building your own.  Once you’ve got your rig put together, then you can start adding software to the Dragonboard — or Any 96Boards CE SBC — to turn it into a self-piloting, obstacle-avoiding, object-following marvel of automation… or whatever it is you plan to do with it.

To find out more about the Aerocore 2 for Dragonboard 410C, you can read my previous post or watch this promo video.

The Parts

The first step in building your quadcopter is to make sure you have all of the hardware you’ll need.  Here’s what I had on-hand:

• A quadcopter
  • DJI Flame Wheel F450 ARF kit
• A 3S 11.1v LiPO battery
  • Venom Flight Pack 20C (2100mAh)
• A 5+-channel DSMX receiver antenna and radio
  • Spektrum AR6210 receiver with remote receiver
  • Spektrum DX5e radio
  • Special note:  Once you bind the satellite receiver with the radio, you won’t be using the main receiver.
• A Dragonboard 410C or 96Boards equivalent
  • Here it is in the Arrow.com store
• A Gumstix Aerocore 2 for Dragonboard 410C
  • Available from gumstix.com
• A CSI-2 or USB camera
  • There was no CSI camera working on the test rig so a Logitech C920 HD webcam was used instead.
• Some way of mounting the Dragonboard to the drone frame
• Zip ties, screws, risers, etc.
• Xacto knife, screwdrivers, soldering iron, etc.

You know you work somewhere cool when you can assemble a drone from hardware lying around the office.

The Prep

To keep this post brief, I’m going to glaze over the following steps.  They’re fairly straightforward and unrelated and ubiquitous in MAV deployment so there are plenty of instructions available on the web.

1. Assemble your drone kit.
   • Do not attach the rotor blades yet. You really don’t want your drone unexpectedly taking flight in the middle of your office/house/garage.
2. The 12V battery connector and regulator on the Aerocore can handle the main battery’s output but there is no built-in connector on the drone or the battery.  
   • You can solder some jumper wires onto one of the motor power terminals on the base plate of your drone (circled in green here)
3. Make sure you’ve flashed your Dragonboard with Linux. Linaro’s Debian 16.09 was used for this demo.
4. Build QGroundControl.
   • In order to stream video from your MAV you will have to build QGroundControl from source, as it’s not included in the pre-built binaries.
   • Make sure you have libgstreamer1.0, gstreamer1.0-tools and libgstreamer-plugins-base1.0-dev installed.
   • Download and install Qt 5.5.1 from http://download.qt.io/archive/qt/5.5/5.5.1/
   • Clone and build QGC from https://github.com/mavlink/qgroundcontrol
5. On your dragonboard 410C install the necessary packages
   • $ sudo apt–get update && sudo apt–get install python–wxgtk3.0 python–pip python–numpy python–dev libxml2–dev libxslt–dev gstreamer1.0-tools
   • $ sudo pip install pymalink
   • $ sudo pip install mavproxy
6. Bind your satelite DSM receiver with your radio
   • The instructions to do this for the AR6210 are found here:  http://www.horizonhobby.com/pdf/SPMAR6210_Manual.pdf

(UPDATE:  Since the original project was completed, something about the pymavlink pip package has changed and will no longer install dependencies correctly.  therefore, add python-lxml to your apt-get command before installing pymavlink and mavproxy)

Put It All Together

Now the fun stuff can begin!  It’s time to get everything hooked up and ready to fly.

Step 1: Attach your boards

With this thing going up in the air, you won’t want your hardware sliding around at all so it’s good to put some thought into how your boards are mounted.  The chassis I’m using doesn’t have what I’d call a universal mounting system, so I made my own.  The box for an Intel Edison turned out to be just the right size and very sturdy.  I’ve already been using one on the rover in my RTK project to house a Beaglebone Black.

Some zip ties, screws and risers quickly transformed the cardboard box into a mounting bracket for my Dragonboard.  A touch of shameless self-promotion and it’s ready.

Board goes on brackets, Aerocore on board.  I used a bit of electrical tape to hold the receiver in place and was ready to wire it up.

Pro-Tip:

MAVs tend to have alarm buzzers, used to indicate low battery and signal loss.  This is very important when in flight, but when you’re setting everything up it can be really annoying.  Thankfully, the buzzer on the Aerocore 2 has a bypass circuit. After soldering a 2-pin header on the underside of the Aerocore, directly underneath the buzzer, you can use a jumper to deactivate the alarm.  For obvious reasons, I don’t recommend hard-wiring the alarm bypass.  The picture to the right should help you find the two vias to connect.

  Step 2: Connect Wiring

One benefit of using a box as a mounting bracket is that it has proved to be the ideal place to hide excess wiring.  I cut a small opening in the bottom of the box and fed all of my wires in and through.  I got my hands on a webcam and managed to squeeze its base and cable in there too.  I labeled the following image so you can see where the various connections are.

Not having previous experience with MAVs, I had no idea what order to hook the electronic speed control PWMs in.  It took me a while, but I figured it out.  I put together an infographic for the rest of the amateur MAVers so that you don’t have to struggle like I did.

Step 3: Software

The final pre-flight step is to configure your software.  There are three steps:

1. Flash PX4 firmware to the MCU
2. Start data pipeline on the Dragonboard
3. Calibrate on-board sensors

QGroundControl makes programming and configuring your drone a snap.  Open up the program and go to the setup tab ().  Along the left-hand side will be a button labeled “Firmware”. When you click on this button and then connect the Areocore 2 MCU’s “stm console” via USB, QGC will guide you through the flash process.

The rest of the pre-flight work can be done over WiFi on the Dragonboard. Going wire-free will also make calibration a little easier.

Disconnect the USB cable from your Aerocore and connect the battery. Once the MCU and Dragonboard boot, SSH into the Dragonboard and enter the following command:

Where xxx.xxx.xxx.xxx is the IP address of your PC.

Once the MAVlink command interface comes up on the Dragonboard, QGC should be able to connect to your drone. If it does not connect correctly, you may have to add a UDP connection to QGC’s settings.  The setup screen should look simmilar to the following screenshot:

If this is the first time your Aerocore has been configured, the cicles that appear green in this shot will be red and you will not be able to deploy your drone until they all appear green.

Configuring your drone and calibrating the sensors is very straightforward thanks to the self-explanatory interface in QGC.  Click on each item along the left-hand side in turn — apart from “Firmware”, which you have already done — and follow the on-screen instructions.  Once all the lights are green, you’re ready to fly.

The final, and completely optional steps are getting the camera feed from the Dragonboard to QGC, and attaching a Pre-GO GPS module.  

Adding a GPS module is very easy.  Once it’s connected, it will work right away.  Connect it to the 5-pin molex connector next to the DSM satellite receiver connector.  Power down your drone and plug the module in using the included cable, and it’s ready.  I added mine last thing right before the live test flight and it worked with no set-up required.

The video streamer, like the MAVlink proxy, is a single command on the Dragonboard:

With both the proxy and the video feed running on the Dragonboard, your flight screen will look something like this:

If you have added a Pre-GO GPS module, your drone’s location will appear in the navigation map seen here in the inset. You can switch the primary view between the video stream and the navigation map by clicking on the inset in the bottom left-hand corner.

And There You Have It…

You now have yourself a working drone.

Posted by Keith the Gumstix Guru at 4:01 PM

Pixhawk + Ardupilot + 交叉编译工具链 + QGC(AP)

参考资料:
老吴学长教程:http://www.nephen.com/arrange/archive.html
Ardupilot:http://ardupilot.org/copter/index.html
Pixhawk开发者:http://dev.px4.io/

Pixhawk

首先稍微介绍一下Pixhawk,它很贵，是的．国外原装的估计的是700多，国内某宝上有很多公司自己仿照它做的板子也得588.目前据我所知道的某宝上卖的最便宜的Pixhawk是梦创团队做的，由于是手工焊制因此还有待提高其工业水平．不扯淡了，想玩无人机的朋友应该都知道大疆这个公司，目前它的无人机市场占有率很高，详情可以搜一搜相关新闻．大疆也很贵(其实要想玩无人机还是得掏钱啊)，上次我们学校一老师让我们观看一下大疆的一款飞机，好像是”悟”系列的，说是从美国带回来的，20000RMB．~__~.所以对于我们一般的爱好者怎么办的？国外开源之王–Pixhawk是首选．硬件开源(为啥能够轻易仿制)，固件开源(降低二次开发难度)，上位机也开源(扩展高级功能)．基本上能够满足无人机平台各个专业的需求．以前它叫做PX4FMU+PX4IO,其实对应到真正的板子上就是一个是stm32f4的芯片，另一个是stm32f1的芯片，主要是它俩加起来搞在一块板子上就是Pixhawk．PX4FMU负责进行高级的浮点运算等，PX4IO负责低级的定时器输出PWM等，两者共同运行了一个叫做Nuttx的嵌入式实时操作系统．如果是买回来的套件，板子肯定已经上载好了bootloader，如果是自己制作，必须在焊接好之后用Jlink等工具首先将bootloader上载进去，而后再通过交叉编译工具链或者上位机用USB接口连接电脑和板子下固件到板子．基础的板子一般只能飞基础的功能，比如自稳模式，定高模式啦．如果要飞高级模式，比如悬停，留待，自动模式啥的得需要GPS或者光流计等可选的硬件设备．所以，还是得舍得花钱…其实说到开源飞控平台有很多，比如国内做得还可以的匿名团队，有兴趣的小伙伴可以去了解一下．下图是梦创的板子.

Ardupilot

这个是一个固件或者说是软件，相对于一般的用户来说就是固件，因为不去更改它．作为开发者来说就是一个软件平台，必须要进行二次更改或者移植去定制自己的功能．首先要说到APM团队，也是一个无人机开发团队，其实最早是PX4团队在Pixhawk上开发出了固件，然后APM也借助了他们的劳动成果在Pixhawk上加入了自己的一个应用程序ArduCopter，这个程序作为一个进程在Nuttx里面被nsh脚本启动．而后再进行各种运算和控制…可能玩过航模的童鞋知道ArduCopter,这玩意儿支持很多架构，不只多旋翼，还包括固定翼和小车等．因为APM团队早期是在基于Avr芯片的arduino板子上跑的软件APM2.x，后来发现低端的资源配置已经不能满足大量的运算了，正巧来了Pixhawk，因此APM团队仍然在完成移植和新功能的开发工作上面．我们为什么不用PX4的固件转而来学习APM的固件呢？答案是简单一些，功能上它们俩差不多，但是在功能的源码实现上不太一样．我们可以分别从各自的github仓库里面fork并clone代码到本地用编辑工具(如sublime等)打开查看就知道了．至于怎么分析代码架构，请先学好单片机等相关知识以及飞行器的基本原理，最好有很好的高数基础和信号滤波的概念．而后，学好C++,就可以开始你的DIY之旅了．如果英文够好的话直接去官网看开发者教程就可以了．下图可以看到ArduCopter也是支持很多硬件平台的，我们编译的时候键入make px4-v2即可．键入make px4-v2-upload即可上载代码．我的开发平台是ubuntu 16.04 amd64.

交叉编译工具链

熟悉嵌入式开发的筒子们肯定都知道，我们在写好代码编译后是需要借助第三方电路结构(例如Jlink,串口有时候也支持)将程序从PC下载到板子上去．这是主要是由于指令集不一样所以要进行交叉编译，除非板子上已经装好了系统了…具体到开发Pixhawk所用到的编译器就是arm-none-eabi-gcc家族,详情安装方式参考官网APM或者PX4都可以，也可以看我学长的教程,只要搭建好这个环境编译APM或者PX4原生固件都是可以的．建议开发平台为Linux，win上面可能会出很多问题，也不建议在win上装Linux虚拟机,因为我当时就出了问题一直木有解决…最好装个双系统啥的．再说，Linux足够安全(相对概念,具体看设计)，不是吗？下图是我的arm-none-eabi-gcc版本号.

上位机

一款好的飞控开发出来，如果没有易于调参的上位机很是麻烦．Ardupilot里面大大小小的参数百多个，最经典的几个PID参数必须要调的．当然运气好机架和参数恰好对应了就不必这么麻烦了．还有些可选的硬件，在上位机里面修改比取修改源码方便多了．Linux上推荐使用QGC和APMPlanner,QGC和APMPlanner都是基于Qt写出来的上位机，直接支持Linux,Win,Mac．APM Planner而且还可以分析飞控上SD卡的飞行记录数据．而Mission Planner是用.net写出来的，在Linux上的话需要安装mono环境才能跑．对于校准加速度计和磁力计的话MP特别麻烦，转很久可能都转不到某些点．而且这里面的上位机几款都是开源的．有兴趣的都可以研究一下mavlink协议以及图形渲染相关编程技术．下图是APMPlanner的截图．

总结

去年加入的实验室，学stm32f1基础知识，从定时器输出PWM控制电调和定时器输入捕获PWM获取遥控器量，到SPI总线协议收发射频信号，I2C协议获取IMU传感器数据，到基础互补滤波和姿态融合算法，串级PID算法控制PWM输出量．一路走来对飞行器有了基本的认识，今年寒假开始的Pixhawk学习，到近期的电赛结束，算是画上了一个简单的分号吧．感谢各位帮助过我的筒子们，加油吧，学弟学妹们，明年电赛好好干．

//—————————————————————————-
// Name: LPC810_Blink.c
// Purpose: LED Flasher
// pin #8 set for LED
//—————————————————————————-
#include <stdint.h>

//registers used for gpio & systick setup
#define GPIO_NOT (*((volatile unsigned int *)(0xA0002300)))
#define GPIO_DIR (*((volatile unsigned int *)(0xA0002000)))
#define SYSCON_PRESETCTRL (*((volatile unsigned int *)(0x40048004)))
#define SYSCON_SYSAHBCLKCTRL (*((volatile unsigned int *)(0x40048080)))
#define NVIC_ST_CTRL (*((volatile unsigned int *)(0xE000E010)))
#define NVIC_ST_RELOAD (*((volatile unsigned int *)(0xE000E014)))
#define NVIC_ST_CURRENT (*((volatile unsigned int *)(0xE000E018)))
#define SCB_SHP1 (*((volatile unsigned int *)(0xE000ED20)))

//our systick interrupt handler
void SysTick_Handler(void) {
GPIO_NOT = (1<<0); //toggle led pin
}

https://github.com/taisukef/wakeupeverymin/blob/master/main.c
int main(void) {
//enable AHB clock to the GPIO domain
SYSCON_SYSAHBCLKCTRL |= (1<<6);
//reset gpio peripheral control
SYSCON_PRESETCTRL &= ~(1<<10);
SYSCON_PRESETCTRL |= (1<<10);
//make gpio #0 pin an output (physical pin #8)
GPIO_DIR |= (1<<0);

//set systick clock interrupt reload count
NVIC_ST_RELOAD = (1200000UL & 0xFFFFFFUL) – 1;
//set SysTick IRQ to lowest priority
SCB_SHP1 = 0xC0000000;
//reset the counter
NVIC_ST_CURRENT = 0;
//enable the IRQ and go
NVIC_ST_CTRL = 0x07;

//loop forever
while(1)
asm(“wfi”); //wait for interrupt
}

#include <stdio.h>
#include “LPC8xx.h”
#include “mrt.h”

#define LED_LOCATION 2
#define GND_LOCATION 3
#define ISP_LOCATION 1

#define LED_ON() (LPC_GPIO_PORT->SET0 = 1 << LED_LOCATION)
#define LED_OFF() (LPC_GPIO_PORT->CLR0 = 1 << LED_LOCATION)

#define ISPBTN() (!(LPC_GPIO_PORT->PIN0 & (1 << ISP_LOCATION)))

// deep power down
void deepPowerDown(void) {
// if (LPC_PMU->PCON & 0b100)
// return 1; // error
LPC_PMU->PCON = 3;
SCB->SCR |= 0b100;
asm(“wfi”);
}
void deepPowerDownWithWakuUp(int msec, int usewakeuppin) {
LPC_PMU->DPDCTRL = usewakeuppin ? 0b1100 : 0b1110;
LPC_PMU->PCON = 3;
SCB->SCR |= 0b100;
LPC_SYSCON->SYSAHBCLKCTRL |= (1 << 9); // enable WKT
LPC_WKT->CTRL = 0b111;
LPC_WKT->COUNT = msec * 10;
asm(“wfi”);
}

void init() {
LPC_SYSCON->SYSAHBCLKCTRL |= (1 << 7); // enable SWM
// LPC_SYSCON->SYSAHBCLKCTRL |= (1 << 18); // enabel UART

// pin config
LPC_SWM->PINASSIGN0 = 0xffff0004UL; // U0_TXD, U0_RXD
LPC_SWM->PINENABLE0 = 0xffffffbfUL;

LPC_SYSCON->SYSAHBCLKCTRL |= (1 << 6); // enable GPIO
LPC_SYSCON->PRESETCTRL &= ~(1 << 10); // GPIO reset
LPC_SYSCON->PRESETCTRL |= (1 << 10); //

LPC_GPIO_PORT->DIR0 |= 1 << GND_LOCATION;
LPC_GPIO_PORT->CLR0 = 1 << GND_LOCATION;

LPC_GPIO_PORT->DIR0 |= 1 << LED_LOCATION;
LPC_GPIO_PORT->CLR0 = 1 << LED_LOCATION;

mrtInit(__SYSTEM_CLOCK / 1000); // multi-rate timer for 1ms
}
int main() {
init();
mrtDelay(100);
deepPowerDownWithWakuUp(60 * 1000, 0); // wake up after 30sec, disable wake up pin
}

Efficient DC 12V to 5V conversion forlow-power electronics, evaluation of six modules 5

eff = Pin/Pout = (Vin*Iin)/(Vout*Iout)

1. Connect FTDI 232 to the board. 5V to Vcc. Gnd to Gnd. Rx  — Tx(A9), Tx — Rx(A10)
3. Make sure boot 0 is connect to 1.
4. Press the reset button
5. Put the following url http://dan.drown.org/stm32duino/package_STM32duino_index.json to the Additional Board Manager URLs in Arduino Preference.
6. Go to Board Manager under Tools -> Board. Find Stm32F1 and install it.
7. In the Board list, select Generic STM32F103C Series. Change the upload method to Serial. Choose the correct port number.
8. Open the blinky example and change it to
9. /*
   BlinkTurns an LED on for one second, then off for one second, repeatedly.

   Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
   it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
   the correct LED pin independent of which board is used.
   If you want to know what pin the on-board LED is connected to on your Arduino
   model, check the Technical Specs of your board at:
   https://www.arduino.cc/en/Main/Products

   modified 8 May 2014
   by Scott Fitzgerald
   modified 2 Sep 2016
   by Arturo Guadalupi
   modified 8 Sep 2016
   by Colby Newman

   This example code is in the public domain.

   http://www.arduino.cc/en/Tutorial/Blink
   */

   // the setup function runs once when you press reset or power the board
   void setup() {
   // initialize digital pin LED_BUILTIN as an output.
   pinMode(PC13, OUTPUT);
   }

   // the loop function runs over and over again forever
   void loop() {
   digitalWrite(PC13, HIGH); // turn the LED on (HIGH is the voltage level)
   delay(100); // wait for a second
   digitalWrite(PC13, LOW); // turn the LED off by making the voltage LOW
   delay(100); // wait for a second
   }

1. 1. Install stlink.
      

      brew install stlink

   2. check stlink is installed.
   3. set up connection and jump.
   4. use ST Nucleo F103RB to init the board.
   5. platfromio.ini
      [env:stm32f103c8t6]
      platform = ststm32
      framework = mbed
      board = nucleo_f103rb
      upload_protocol = stlink
   6. blink code
   7. http://www.nutdiy.com/2016/05/blink-on-stm32f103c8t6-using-platformio.html
   8. It is also possible to use Arduino. The platfromio.ini will be
      [env:genericSTM32F103R8]
      platform = ststm32
      board = genericSTM32F103C8
      framework = arduino
      upload_protocol = stlink

9. Connect the blue pill with stlink
STLink pin BluePill pin
GND (3 or 4)  GND
3.3V (7 or 8)3.3
SWDIO (2)  DIO
SWCLK(6)  DCLK

The mode in which STM32 starts is determined by pins BOOT0 and BOOT1 :

To get USB Serial working, I did as described in Hardware installation paragraph here and soldered a 1.5k resistor between 3.3V and PA12, while also desoldering R10 from PCB.

https://shortn0tes.blogspot.ca/2017/06/how-to-use-platformio-to-develop-for.html