Category:

Hardware

Nucleo-L496ZG development board

by shedboy71 29th February 2020

written by shedboy71

In this article we look at a piece of hardware we have had for a while, the Nucleo-L496ZG development board.

Overview

This board features a STM32 microcontroller in LQFP144 package, in this case it is a STM32L496ZGTP MCU.
The ST Zio connector, which extends the Arduino Uno V3 connectivity, and the ST morpho headers provide an easy means of expanding the functionality of the Nucleo open development platform with a wide choice of specialized shields.
External SMPS to generate Vcore logic supply (only available on ‘-P’ suffixed boards).
Ethernet compliant with IEEE-802.3-2002 (depending on STM32 support).
USB OTG or full-speed device (depending on STM32 support).
The board features 3 user LEDs.
There are 2 user and reset push-buttons.
32.768 kHz crystal oscillator Board connectors: USB with Micro-AB, SWD, Ethernet RJ45 (depending on STM32 support), ST Zio connector including Arduino Uno V3, ST morpho
Flexible power-supply options: ST-LINK USB VBUS or external sources.
On-board ST-LINK/V2-1 debugger/programmer with USB re-enumeration capability: mass storage, virtual COM port and debug port so this means it does not require any separate probe.

Development

Support of a wide choice of Integrated Development Environments (IDEs) including IAR , Keil , GCC-based IDEs, Arm Mbed and the Arduino IDE with STM32Duino support
Arm Mbed Enabled compliant so you can use the online compiler

Hardware

1 /PCS LOT NUCLEO-L496ZG Nucleo development board STM32L4 series development board 100% new original

Code example

This is a simple example using the Arduino IDE with STM32Duino support added

This example is similar to the default blink example but since there are 3 led’s we will flash them all on and off

[codesyntax lang=”cpp”]

void setup() 
{
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LED_BLUE, OUTPUT);
  pinMode(LED_RED, OUTPUT);
}



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

[/codesyntax]

and because I really like flashy led examples

[codesyntax lang=”cpp”]

void setup() 
{
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LED_BLUE, OUTPUT);
  pinMode(LED_RED, OUTPUT);
}



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

[/codesyntax]

Summary

A solid ARM development board that can be purchased for about $29, lots of development options. Hopefully I will explore a few of these in future articles, I have tried Arduino, MBed and will play about with the STM development tools as well.

Links

https://www.st.com/en/evaluation-tools/nucleo-l496zg.html

29th February 2020 0 comment

A look at the STM32F4DISCOVERY with an Arduino based example

by shedboy71 5th February 2019

written by shedboy71

In this example we look at the STM32F4DISCOVERY and in particular the STM32F407G-DISC1

Lets look at some key features

The STM32F4DISCOVERY kit leverages the capabilities of the STM32F407 high performance microcontrollers, to allow users to easily develop applications featuring audio.

It includes an ST-LINK embedded debug tool, one ST-MEMS digital accelerometer, a digital microphone, one audio DAC with integrated class D speaker driver, LEDs, push-buttons and an USB OTG micro-AB connector.

With the latest board enhancement, the new order code STM32F407G-DISC1 has replaced the old reference STM32F4DISCOVERY.

Key Features

STM32F407VGT6 microcontroller featuring 32-bit ARM^®Cortex^®-M4 with FPU core, 1-Mbyte Flash memory, 192-Kbyte RAM in an LQFP100 package
On-board ST-LINK/V2 on STM32F4DISCOVERY (old reference) or ST-LINK/V2-A on STM32F407G-DISC1 (new order code)
USB ST-LINK with re-enumeration capability and three different interfaces:
- Debug port
- Virtual Com port (with new order code only)
- Mass storage (with new order code only)
Board power supply: through USB bus or from an external 5 V supply voltage
External application power supply: 3 V and 5 V
LIS302DL or LIS3DSH ST MEMS 3-axis accelerometer
MP45DT02 ST-MEMS audio sensor omni-directional digital microphone
CS43L22 audio DAC with integrated class D speaker driver
Eight LEDs:
- LD1 (red/green) for USB communication
- LD2 (red) for 3.3 V power on
- Four user LEDs, LD3 (orange), LD4 (green), LD5 (red) and LD6 (blue)
- 2 USB OTG LEDs LD7 (green) VBUS and LD8 (red) over-current
Two push-buttons (user and reset)
USB OTG FS with micro-AB connector
Extension header for all LQFP100 I/Os for quick connection to prototyping board and easy probing
Comprehensive free software including a variety of examples, part of STM32CubeF4 package or STSW-STM32068 to use legacy standard libraries.

There are 4 coloured LEDs on the STM32F407G-DISC1 development board as stated above, these are locate dunder the microcontroller

PIN	NAME	COLOUR	POSITION
PD13	LD3	ORANGE	UP
PD14	LD5	RED	RIGHT
PD15	LD6	BLUE	DOWN
PD12	LD4	GREEN	LEFT

Parts List

STM32F4DISCOVERY Embeded ST-LINK/V2 STM32 Evaluation Development Board,Free shipping

Code

We used Atom IDE with Platform.IO installed and added support for the STM32 boards. This is an Arduino example (confused). You could add STM32 support to the Arduino IDE by adding stm32duino support but I like the look of Platform IDE so wanted to play about with the IDE

This is a fairly basic example to flash the LEDS off and on repeatedly

[codesyntax lang=”cpp”]

#include <Arduino.h>

void setup() {
  // put your setup code here, to run once:

  // Set the MCU's pin data direction.
  pinMode(PD13, OUTPUT);
  pinMode(PD14, OUTPUT);
  pinMode(PD15, OUTPUT);
  pinMode(PD12, OUTPUT);

  // Set all outputs LOW to have all LED's initially turned off.
  digitalWrite(PD13, LOW);
  digitalWrite(PD14, LOW);
  digitalWrite(PD15, LOW);
  digitalWrite(PD12, LOW);
}

void loop() {
  // put your main code here, to run repeatedly:

  // Turn off the GREEN LED, turn on the ORANGE LED and wait for 1000ms.
  digitalWrite(PD12, HIGH);
  digitalWrite(PD13, HIGH);
  digitalWrite(PD14, HIGH);
  digitalWrite(PD15, HIGH);
  delay(1000);

  digitalWrite(PD12, LOW);
  digitalWrite(PD13, LOW);
  digitalWrite(PD14, LOW);
  digitalWrite(PD15, LOW);
  delay(1000);

  // The code in the "loop()" statement will automatically repeat.
}

[/codesyntax]

Link

https://www.st.com/en/evaluation-tools/stm32f4discovery.html

5th February 2019 0 comment

Hardware

RobotDyn SAMD21 M0-Mini a quick look

by shedboy71 21st October 2017

written by shedboy71

The RobotDyn SAMD21 M0-Mini represents a powerful, 32-bit extension of the Arduino UNO platform, but to small size like Micro or Nano. The board is powered by Atmel’s SAMD21 MCU, featuring a 32-bit ARM Cortex® M0 core. Compatible with Arduino Zero and Arduino M0.

The SAMD21 M0-Mini board expands the family by providing increased performance, enabling a variety of project opportunities for devices, and acts as a great educational tool for learning about 32-bit application development.

The Zero applications span from smart IoT devices, wearable technology, high-tech automation, to crazy robotics. The board is powered by Atmel’s SAMD21 MCU, which features a 32-bit ARM Cortex® M0+ core. One of its most important features is Atmel’s Embedded Debugger (EDBG), which provides a full debug interface without the need for additional hardware, significantly increasing the ease-of-use for software debugging. EDBG also supports a virtual COM port that can be used for device and bootloader programming.

The boards are of course 3.3 volt compatible only – so be wary of this

Sparkfun have a page detailing the ARM microcontroller with a handy comparison to an ATMEGA328 – https://learn.sparkfun.com/tutorials/samd21-minidev-breakout-hookup-guide/samd21-overview

Install Arduino SAMD Boards

First, you need to add support for the board. These tools come packaged along with Arduino’s SAMD board definitions for the Arduino Zero.

To install the Arduino SAMD board definitions, navigate to your board manager (Tools > Board > Boards Manager…), then find an entry for Arduino SAMD Boards (32-bits ARM Cortex-M0+). Select it, and install the latest version.

Installing the Arduino SAMD boards

arduino board install screen

Downloading and installing the tools may take a couple minutes depending on your network speed.

Once installed, Arduino-blue “Installed” text should appear next to the SAMD boards list entry.

In the Arduino IDE I selected Arduino MO and my device was on COM6

Code

Once again the blink sketch is where we go to test everything is working, this was compiled and uploaded and the on board LED flashed as expected

[codesyntax lang=”cpp”]

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

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

[/codesyntax]

Links

Those folks at Sparkfun have a version and here are the schematics and files for making the board – https://github.com/sparkfun/SAMD21_Mini_Breakout

You can pick up the variant I bought which works perfectly for only $12 – a nice price in my opinion for an ARM micro board

AliExpress.com Product – SAMD21 M0-Mini. 32-bit ARM Cortex M0 core. Pins UnSoldered. Compatible with Arduino Zero, Arduino M0. Form Mini.

21st October 2017 0 comment

Hardware

RobotDyn SAMD21 M0 arduino compatible board

by shedboy71 19th October 2017

written by shedboy71

I’ve wanted either than an Arduino Zero or M0 for a while then i saw this board as I was browsing an online store, coming in at under $14 it seemed reasonably priced for an arduino type board with an ARM Cortex M0 microcontroller. Since it can be used with the ARduino IDE and potentially can use shields as well this seems a good option for beginners and hobbyists

Lets look at a bit of the blurb on the board

The RobotDyn SAMD21 M0 represents a powerful, 32-bit extension of the Arduino UNO platform. The board is powered by Atmel’s SAMD21 MCU, featuring a 32-bit ARM Cortex® M0 core.
Compatible with Arduino Zero and Arduino M0.

SAMD21 M0

The SAMD21 M0 board expands the family by providing increased performance, enabling a variety of project opportunities for devices, and acts as a great educational tool for learning about 32-bit application development.
The Zero applications span from smart IoT devices, wearable technology, high-tech automation, to crazy robotics. The board is powered by Atmel’s SAMD21 MCU, which features a 32-bit ARM Cortex® M0+ core. One of its most important features is Atmel’s Embedded Debugger (EDBG), which provides a full debug interface without the need for additional hardware, significantly increasing the ease-of-use for software debugging. EDBG also supports a virtual COM port that can be used for device and bootloader programming.

Features

Model Number:SAMD21-M0
Microcontroller:ATSAMD21G18, 48pins LQFP
Operating Voltage:3.3V
Clock Speed:48 MHz
Input Voltage:6-24V, USB 5V (recommended 7-9V)
Vout:3.3V/800mA
Digital I/O Pins:20
PWM Pins:All but pins 2 and 7
Analog In Pins:6, 12-bit ADC channels
Analog Out Pins:1, 10-bit DAC

Key thing in the specs is that the board I/O pins are rated at 3.3v, so take that into consideration.

You need to add support for this board via the Boards manager

This core is available as a package in the Arduino IDE cores manager. Just open the “Boards Manager” and install the package called:

“Arduino SAMD Boards (32-bit ARM Cortex-M0+)”

the RobotDyn is basically an Arduino/ Genuino M0 clone board (just cheaper)

Code

The standard blink sketch works for testing – you need to select your board as an Arduino M0 in the boards manager

[codesyntax lang=”cpp”]

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

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

[/codesyntax]

Links

http://robotdyn.com/catalog/boards/samd21_m0/

SAMD21 M0. 32-bit ARM Cortex M0 core. Compatible with Arduino Zero, Arduino M0. Form R3.

19th October 2017 0 comment

Hardware

ST NUCLEO Development Board and Easy Module Shield v1 examples

by shedboy71 29th June 2017

written by shedboy71

The Easy Module Shield V1 is a basic shield for the Arduino which has several useful components fitted that can be used for beginners learning, here is a list of these components

A DHT11 temperature and humidity sensor
An LM35 temperature sensor
A piezo buzzer
An RGB LED
A blue LED and a red LED
An IR receiver
A photoresistor
A rotary potentiometer
Two pushbuttons

I wanted to see if these could be used with one of the Nucleo boards, the good news is that using the Mbed compiler I was able to use all of the devices on the board.

Lets look at some examples using this shield

Code

Flash the D12 LED

[codesyntax lang=”cpp”]

#include "mbed.h"

DigitalOut myled(D12);

int main() {
    while(1) {
        myled = 1; // LED is ON
        wait(0.2); // 200 ms
        myled = 0; // LED is OFF
        wait(1.0); // 1 sec
    }
}

[/codesyntax]

RGB LED example

[codesyntax lang=”cpp”]

#include "mbed.h"

DigitalOut redled(D9);
DigitalOut greenled(D10);
DigitalOut blueled(D11);

int main() {
    while(1)
    {
        redled = 1; // LED is ON
        wait(0.2); // 200 ms
        redled = 0; // LED is OFF
        wait(1.0); // 1 sec
        greenled = 1; // LED is ON
        wait(0.2); // 200 ms
        greenled = 0; // LED is OFF
        wait(1.0); // 1 sec
        blueled = 1; // LED is ON
        wait(0.2); // 200 ms
        blueled = 0; // LED is OFF
        wait(1.0); // 1 sec
    }
}

[/codesyntax]

Pot , LED and terminal output example

[codesyntax lang=”cpp”]

#include "mbed.h"

Serial pc(USBTX, USBRX);

AnalogIn analog_value(A0);
 
DigitalOut led(LED1);
 
int main() {
    float meas;
    
    pc.printf("\nPot example\n");
    
    while(1) {
        meas = analog_value.read(); // Converts and read the analog input value (value from 0.0 to 1.0)
        meas = meas * 3300; // Change the value to be in the 0 to 3300 range
        pc.printf("measure = %.0f mV\n", meas);
        if (meas > 2000) { // If the value is greater than 2V then switch the LED on
          led = 1;
        }
        else {
          led = 0;
        }
        wait(0.2); // 200 ms
    }
}

[/codesyntax]

LDR, LED and terminal out example

[codesyntax lang=”cpp”]

#include "mbed.h"

Serial pc(USBTX, USBRX);

AnalogIn analog_value(A1);
 
DigitalOut led(D12);
 
int main() {
    float meas;
    
    pc.printf("\nLDR example\n");
    
    while(1) {
        meas = analog_value.read(); // Converts and read the analog input value (value from 0.0 to 1.0)
        meas = meas * 3300; // Change the value to be in the 0 to 3300 range
        pc.printf("measure = %.0f mV\n", meas);
        if (meas > 2000) { // If the value is greater than 2V then switch the LED on
          led = 1;
        }
        else {
          led = 0;
        }
        wait(0.2); // 200 ms
    }
}

[/codesyntax]

So good news it can be used with a Nucleo

Links

Keyes V1 FR4 Multi-Purpose Shield Learning Module for Arduino – Red – $7.34
from: DealExtreme

ST NUCLEO-F401RE STM32F401RE Development Board for Arduino – White + Multicolored
from: DealExtreme

29th June 2017 0 comment

Hardware

Micro Bit overview

by shedboy71 26th July 2016

written by shedboy71

In the last couple of days I managed to get my hands ona Micro Bit, if you have no idea what i am talking about then this will introduce you to this intriguing board

The Micro Bit measures 4 × 5 cm the device has an ARM Cortex-M0 processor, accelerometer and magnetometer sensors, Bluetooth and USB connectivity, a display consisting of 25 LEDs, two programmable buttons, and can be powered by either USB or an external battery pack. The device inputs and outputs are through five ring connectors that are part of the 23-pin edge connector.

microbit

Hardware

The size of the device is described as half the size of a credit card, measuring 43 x 52 mm and, as of the start of final manufacturing,[18] includes:

Nordic nRF51822 – 16 MHz 32-bit ARM Cortex-M0 microcontroller, 256 KB flash memory, 16 KB static ram, 2.4 GHz Bluetooth low energy wireless networking. The ARM core has the capability to switch between 16 MHz or 32.768 kHz.
NXP/Freescale KL26Z – 48 MHz ARM Cortex-M0+ core microcontroller, that includes a full-speed USB 2.0 On-The-Go (OTG) controller, used as a communication interface between USB and main Nordic microcontroller.
NXP/Freescale MMA8652 – 3-axis accelerometer sensor via I²C-bus.
NXP/Freescale MAG3110 – 3-axis magnetometer sensor via I²C-bus (to act as a compass and metal detector).
MicroUSB connector, battery connector, 23-pin edge connector.
Display consisting of 25 LEDs in a 5×5 array.
Three tactile pushbuttons (two for user, one for reset).

I/O includes three ring connectors (plus one power one ground) which accept crocodile clips or 4 mm banana plugs as well as a 23-pin edge connector with two or three PWM outputs, six to 17 GPIO pins (depending on configuration), six analog inputs, serial I/O, SPI, and I²C.Unlike early prototypes, which had an integral battery, an external battery pack (AAA batteries) can be used to power the device as a standalone or wearable product.

Software

There are four official code editors in the BBC micro:bit web site:

CodeKingdoms, using JavaScript
Microsoft Block Editor, based on Blockly;
Microsoft TouchDevelop;
MicroPython.

The Python programming experience on the Micro Bit is provided by MicroPython. Users are able to write Python scripts in the Micro Bit web editor which are then combined with the MicroPython firmware and uploaded to the device. Users can also access the MicroPython REPL running directly on the device via the USB serial connection, and this allows to interact directly with the Micro Bit’s peripherals.

The Micro Bit was created using the ARM mbed development kits. The run-time system and programming interface utilize the mbed cloud compiler service to compile the user’s code. The compiled code is then flashed onto the device using USB or Bluetooth connections. The device will appear as a USB drive when connected to a computer and code can be flashed using drag and drop

26th July 2016 0 comment

Code Hardware

MINI STM32 V3 board

by shedboy71 4th February 2016

written by shedboy71

In this example we will create a simple flashing led example for the MINI STM32 board, I used this to test out a J-link from segger and also to try out the MikroC Pro for ARM IDE.

Here is a picture of the board, it is commonly found on many internet sites

mini stm32

Here is a schematic for the board, you can see 2 LEDs fitted to PA1 and PA2 these will flash on and off

MINI_STM32-V3.0 schematic

Code

The code example was written in MikroC PRO for ARM, I used a J-link to program the MINI STM32 via the jtag connector. It will actually toggle all the I/O pins low and high

[codesyntax lang=”cpp”]

void main() {
  GPIO_Digital_Output(&GPIOA_BASE, _GPIO_PINMASK_ALL); // Set PORTA as digital output
  GPIO_Digital_Output(&GPIOB_BASE, _GPIO_PINMASK_ALL); // Set PORTB as digital output
  GPIO_Digital_Output(&GPIOC_BASE, _GPIO_PINMASK_ALL); // Set PORTC as digital output
  GPIO_Digital_Output(&GPIOD_BASE, _GPIO_PINMASK_ALL); // Set PORTD as digital output
  GPIO_Digital_Output(&GPIOE_BASE, _GPIO_PINMASK_ALL); // Set PORTE as digital output

  GPIOA_ODR = 0;
  GPIOB_ODR = 0;
  GPIOC_ODR = 0;
  GPIOD_ODR = 0;
  GPIOE_ODR = 0;

  while(1) 
  {
    GPIOA_ODR = 0xff;
    GPIOB_ODR = 0xff;
    GPIOC_ODR = 0xff;
    GPIOD_ODR = 0xff;
    GPIOE_ODR = 0xff;
    Delay_ms(1000);
    GPIOA_ODR = 0;
    GPIOB_ODR = 0;
    GPIOC_ODR = 0;
    GPIOD_ODR = 0;
    GPIOE_ODR = 0;
    Delay_ms(1000);
  }
}

[/codesyntax]

Links

MINI stm32 Core Board Supporting screen 320×240 with Touch Screen

4th February 2016 0 comment

Hardware

STM32 development board and Arduino

by shedboy71 3rd February 2016

written by shedboy71

Being a sucker for a bargain and wanting to get into basic ARM development I’ve bought a couple of STM32 boards in the past, these tend to be low cost and one of the variants is below. Basically this is just the STM32 chip with breakout connectors attached. For ease of use I noticed that you can use the Arduino IDE to develop and upload simple test projects, probably not what the purists would like to see but for me a gentle introduction

The trouble with these low cost breakout boards is that the documentation is non existent but luckily some kind hearted people have been through the pain, here are some useful links. Here is the first one, it is commonly called – STM32 Minimum System Development Board for Arduino. Why Arduino, who knows other than trying to cash in on the popularity, it is possible as we will try and explain to add support to the Arduino IDE but this is never documented with the boards.

STM32Mini-annotated

I recommend you following the instructions at – http://www.rogerclark.net/stm32f103-and-maple-maple-mini-with-arduino-1-5-x-ide/

Newer Arduino IDE versions will need to do the following – http://www.rogerclark.net/work-around-for-arduino-stm32-with-ide-v-1-6-3-or-newer/ , basically you need to go to the Board Manager and install support for the ARduino Due.

Connection –

I connected a Prolific PL2303 USB-to-Serial port adapter to my STM32 like this. AN FTDI or Cp2102 are other common options, as long as there is a usable COM port it shouldn’t make a difference

usb-ttl1

3.3v – Any 3.3v on the board – usually marked 3.3
TX – A10
RX – A9
Gnd – Any Gnd on the board , I used the SWD one. Usually marked up as G on the board
Now at first I recieved an error message – Got NACK from device on command 0x43. Looking at the post at http://www.stm32duino.com/viewtopic.php?f=20&t=747&sid=cd8271c9e0bb7f11cb9c230520a67697&start=10 , I followed the steps below as mentioned in one of the posts

It sounds like the chip has been locked, and will need to be fully erased and unlocked before you can do anything

Try downloading STM’s “Flash loader demonstrator” (its not really a demonstrator its the flash uploader via serial)
http://www.st.com/web/en/catalog/tools/PF257525

This removed the issue for me, this is the code you will need for a simple example, the board mentioned earlier has an LED connected to PC13 we will flash this on and off
Code

[codesyntax lang=”cpp”]

// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin PC13 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(1000); // wait for a second
digitalWrite(PC13, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}

[/codesyntax]

Click on the reset button of the board and upload the sketch via the IDE, in the preferences of the IDE I check Verbose warning. Here is what i saw on a good upload, you should see something similar

[codesyntax lang=”dos”]

http://stm32flash.googlecode.com/

Using Parser : Raw BINARY
Interface serial_w32: 230400 8E1
Version : 0x22
Option 1 : 0x00
Option 2 : 0x00
Device ID : 0x0410 (Medium-density)
- RAM : 20KiB (512b reserved by bootloader)
- Flash : 128KiB (sector size: 4x1024)
- Option RAM : 16b
- System RAM : 2KiB
Write to memory
Erasing memory

Wrote address 0x08000100 (3.91%) 
Wrote address 0x08000200 (7.82%) 
Wrote address 0x08000300 (11.73%) 
Wrote address 0x08000400 (15.64%) 
Wrote address 0x08000500 (19.55%) 
Wrote address 0x08000600 (23.46%) 
Wrote address 0x08000700 (27.37%) 
Wrote address 0x08000800 (31.28%) 
Wrote address 0x08000900 (35.19%) 
Wrote address 0x08000a00 (39.10%) 
Wrote address 0x08000b00 (43.01%) 
Wrote address 0x08000c00 (46.92%) 
Wrote address 0x08000d00 (50.82%) 
Wrote address 0x08000e00 (54.73%) 
Wrote address 0x08000f00 (58.64%) 
Wrote address 0x08001000 (62.55%) 
Wrote address 0x08001100 (66.46%) 
Wrote address 0x08001200 (70.37%) 
Wrote address 0x08001300 (74.28%) 
Wrote address 0x08001400 (78.19%) 
Wrote address 0x08001500 (82.10%) 
Wrote address 0x08001600 (86.01%) 
Wrote address 0x08001700 (89.92%) 
Wrote address 0x08001800 (93.83%) 
Wrote address 0x08001900 (97.74%) 
Wrote address 0x08001994 (100.00%) Done.

Starting execution at address 0x08000000... done.

[/codesyntax]

Overall its a nice low cost board, like a lot of these Chinese type electronic development boards and kits if you can get over the initial challenge of actually getting the board to do anything then its quite useful, its been a while since I got so excites at a simple LED flashing example.

Links
1pcs STM32F103C8T6 ARM STM32 Minimum System Development Board Module For arduino

3rd February 2016 0 comment

Hardware

Nucleo-F334R8 board

by shedboy71 30th January 2016

written by shedboy71

The STM32 Nucleo boards allow anyone to try out new ideas and to quickly create prototypes with any STM32 MCU.

STM32 Nucleo boards can easily be extended with a large number of specialized application hardware add ons (Arduino Uno Rev3 and ST morpho connectors on Nucleo-144 and Nucleo-64, ST Zio connectors on Nucleo-144, Arduino Nano connectors on Nucleo-32). The STM32 Nucleo boards integrate an ST-Link debugger/programmer, so there is no need for a separate probe.

All STM32 Nucleo users have free access to the mbed online resources (compiler, C/C++ SDK, and developer community) at www.mbed.org.

At the moment I am using the NUcleo-F334R8, here are some of the features

nucleo f334r8

Features

STM32 microcontroller with LQFP64 package
Two types of extension resources
Arduino Uno Revision 3 connectivity
STMicroelectronics Morpho extension pin headers for full access to all STM32 I/Os
mbed-enabled (http://mbed.org)
On-board ST-LINK/V2-1 debugger/programmer with SWD connector
selection-mode switch to use the kit as a standalone ST-LINK/V2-1
Flexible board power supply
USB VBUS or external source(3.3 V, 5 V, 7 – 12 V)
Power management access point
Three LEDs
USB communication (LD1), user LED (LD2), power LED (LD3)
Two push buttons: USER and RESET
USB re-enumeration capability: three different interfaces supported on USB
Virtual Com port
Mass storage
Debug port
Supported by wide choice of Integrated Development Environments (IDEs) including IAR™, Keil®, GCC-based IDEs

Here is the pinout

xnucleo64_revc_f334r8_mbed_pinout

30th January 2016 0 comment