STM32F103C8T6 ARM STM32 Minimum System Development Board Module For Arduino

ลง  Bootloader (DFU) Maple ให้ทุกบอร์ดก่อนจัดส่ง

คือสามารถใช้งานได้เลย

Arduino STM32 – USB Serial and DFU

http://www.rogerclark.net/arduino-stm32-usb-serial-and-dfu/

STM32F103C8T6.

These features make the STM32F103xx medium-density performance line microcontroller family suitable for a wide range of applications such as motor drives, application control, medical and handheld equipment, PC and gaming peripherals, GPS platforms, industrial applications, PLCs, inverters, printers, scanners, alarm systems, video intercoms, and HVACs.

Key Features

• ARM^® 32-bit Cortex^® -M3 CPU Core
  • 72 MHz maximum frequency,1.25 DMIPS/MHz (Dhrystone 2.1) performance at 0 wait state memory access
  • Single-cycle multiplication and hardware division
• Memories
  • 64 Kbytes of Flash memory
  • 20 Kbytes of SRAM
• Clock, reset and supply management
  • 2.0 to 3.6 V application supply and I/Os
  • POR, PDR, and programmable voltage detector (PVD)
  • 4-to-16 MHz crystal oscillator
  • Internal 8 MHz factory-trimmed RC
  • Internal 40 kHz RC
  • PLL for CPU clock
  • 32 kHz oscillator for RTC with calibration
• Low-power
  • Sleep, Stop and Standby modes
  • VBAT supply for RTC and backup registers
• 2 x 12-bit(4096), 1 μs A/D converters (up to 16 channels)
  • Conversion range: 0 to 3.6 V
  • Dual-sample and hold capability
  • Temperature sensor
• DMA
  • 7-channel DMA controller
  • Peripherals supported: timers, ADC, SPIs, I² Cs and USARTs
• Up to 80 fast I/O ports
  • 26/37/51/80 I/Os, all mappable on 16 external interrupt vectors and almost all 5 V-tolerant
• Debug mode
  • Serial wire debug (SWD)
• 7 timers
  • Three 16-bit timers, each with up to 4 IC/OC/PWM or pulse counter and quadrature (incremental) encoder input
  • 16-bit, motor control PWM timer with dead-time generation and emergency stop
  • 2 watchdog timers (Independent and Window)
  • SysTick timer 24-bit downcounter
• Up to 9 communication interfaces
  • Up to 2 x I² C interfaces (SMBus/PMBus)
  • Up to 3 USARTs (ISO 7816 interface, LIN, IrDA capability, modem control)
  • Up to 2 SPIs (18 Mbit/s)
  • CAN interface (2.0B Active)
  • USB 2.0 full-speed interface
• CRC calculation unit, 96-bit unique ID
• Packages are ECOPACK^®

8. On-board Microu USB interface, you can give the board power supply and USB communication.
9. Size:5.3cm x 2.2cm.

link ข้อมูลเกีี่ยวกับ STM32duino

1. ขั้นตอน bootloader เอง https://geektimes.ru/post/277928/

2. เว็บบอร์ด http://www.stm32duino.com/

3. software ที่ต้องใช้ร่วมกับ IDE ของ arduino https://github.com/rogerclarkmelbourne/Arduino_STM32

4. code ตัวอย่าง http://grauonline.de/wordpress/?page_id=1004

https://github.com/rogerclarkmelbourne/Arduino_STM32/wiki/Programming-an-STM32F103XXX-with-a-generic-%22ST-Link-V2%22-programmer-from-Linux

https://github.com/rogerclarkmelbourne/STM32duino-bootloader

Uploading via USB to Serial to STM32F103 boards 

https://www.youtube.com/watch?v=G_RF0a0hrak

/*
  Blink  STM32F103C8T6 pin PC13

 */


// 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);
  //pinMode(PA2, OUTPUT);
  //pinMode(PA0, OUTPUT);
}

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

//----------- TEST I2C LCD 1602A----------------

// STM32F103C8T6 TEST LCD 1602A(I2C)

//Compatible with the Arduino IDE 1.0

//Library version:1.1

#include  

#include

#define LEDPIN   PC13

// PCF8574T  set the LCD address to 0x27 for a 16 chars and 2 line display

// #define I2C_LCD_ADDRESSS   0x27   

// PCF8574AT set the LCD address to 0x3F for a 16 chars and 2 line display 

#define I2C_LCD_ADDRESSS   0x3F  

LiquidCrystal_I2C lcd(I2C_LCD_ADDRESSS,20,4);  

//----------------------------

//STM32F103C8T6

// SCL  =  PB6

// SDA  =  PB7

//----------------------------

void setup()

{

  pinMode(LEDPIN, OUTPUT);      

  lcd.init();                      // initialize the lcd 

  lcd.backlight();

  lcd.home (); // ไปที่ตัวอักษรที่ 0 แถวที่ 1

  lcd.setCursor(1,0); // ไปทตัวอักษรที่ 1 แถวที่ 1

  lcd.print("STM32F103C8T6");

  lcd.setCursor(2,1); // ไปที่ตัวอักษรที่ 2 แถวที่ 2

 //  lcd.print("mcucity.com"); 

  lcd.print("ARM Contex-M3");  

}

void loop()

{

  digitalWrite(LEDPIN, HIGH);   // turn the LED ON (PC13) (HIGH is the voltage level)

  delay(500);                   // wait for 500mS

  digitalWrite(LEDPIN, LOW);    // turn the LED OFF by making the voltage LOW

  delay(500);                   // wait for 500mS

}

//------------------ END --------------------------------

*
http://wiki.stm32duino.com/index.php?title=API

API

Differences compared to Arduino API

Data types

• int: On the Arduino Uno (and other ATMega based boards) an int stores a 16-bit (2-bytes) value while on STM32 based boards an int stores a 32-bit (4-bytes) value.
• double: On the Uno and other ATMEGA based boards double occupies 32-bit (4-bytes), same as float while on STM32 based boards a double occupies 64-bit (8-bytes).

PWM

Arduino boards support 8-bit PWM, which means that calls to analogWrite() take values between 0 (always off) and 255 (always on).

STM32 boards support 16-bit PWM so values can range from 0 (always off) and 65535 (always on).

For backward compatibility, in STM32duino, analogWrite() still takes values between 0 (always off) and 255 (always on); the new pwmWrite() function provides instead support to the higher resolution 0 (always off) and 65535 (always on).

ADC

Arduino boards support 10-bit ADC, which means that calls to analogRead() will return values between 0 and 1023. The Maple supports 12-bit ADC, so the same call will instead return values between 0 and 4095.

Important information about global constructor methods

Classes, including libraries, must not called pinMode() or digitalWrite() or digitalRead() etc, or any similar function in a global constructor. Do not store references to pins in global constructors

This is because the mapping of the pins is dynamic, and is not guaranteed to be initialized for global constructor code.

Libraries often do not function because they attempt to call pinMode in their constructor.

Serial & USB Serial

Serial USB is enabled for all F103 boards when uploading using the bootloader, it is also available when uploading by ST-Link (SWD) In these cases:

• Serial.print("Hello world"); will print via Serial USB (CDC).
• Serial1 prints to hardware USART 1
• Serial2 prints to hardware USART 2
• etc

When uploading via "Serial" (external USB to Serial adaptor connected to PA9 and PA10 (USART1) on the STM32):

• Serial.print("Hello world"); will print to hardware USART1 (the one the code was uploaded using)
• Serial1 prints to hardware USART 2
• etc

Note. Some boards, e.g. Nucleo F103RB have special serial mapping, because these boards need to have hardware modification to make Serial usable.

The Serial USART mapping is defined in file "variants//board.cpp".

Pin access

Pin Modes

• OUTPUT: Basic digital output: when the pin is HIGH, the voltage is held at +3.3v (Vcc) and when it is LOW, it is pulled down to ground.

• OUTPUT_OPEN_DRAIN: In open drain mode, the pin indicates “low” by accepting current flow to ground and “high” by providing increased impedance.

• INPUT: Basic digital input.

• INPUT_ANALOG: This is a special mode for when the pin will be used for analog (not digital) reads.

• INPUT_PULLUP: The state of the pin in this mode is reported the same way as with INPUT, but the pin voltage is gently “pulled up” towards +3.3v.

• INPUT_PULLDOWN: The state of the pin in this mode is reported the same way as with INPUT, but the pin voltage is gently “pulled down” towards 0v.

• INPUT_FLOATING: Synonym for INPUT.

• PWM: This is a special mode for when the pin will be used for PWM output (a special case of digital output).

• PWM_OPEN_DRAIN: Like PWM, except that instead of alternating cycles of LOW and HIGH, the voltage on the pin consists of alternating cycles of LOW and floating (disconnected).

Reading from & Writing to pins

You can use the standard analogWrite, digitalWrite, analogRead & digitalRead from Arduino, but they can be slow, there are some faster alternatives. These are by directly going to the GPIO ports, which are 16bits wide (so 16 pins per port)

gpio_write_bit

This is a function you can call, that doesn't take the pinnumber, but the GPIOPort, and which pin of the port you want to access.
It's a lot faster than the digitalWrite function
gpio_write_bit(GPIOB, 0, LOW);

Direct access to the registers

here are the registeres with which you can read/write the state of the pins

BSRR

Sets & Resets pins. It's a register that's 32 bits wide, the first 16 bits will set a pin to "1" when value 1 is written to it, the next 16 bits will set a pin to 0 when a value is written to it. Set pin 0 of port A high
GPIOA->regs->BSRR = 1;
Reset pin 0 of Port A to low
GPIOA->regs->BSRR = 1<<16;

BRR

Resets pins. It's a register that's 16 bits wide, basically matches the second half of the BSRR register. Reset pin 0 of Port A
GPIOA->regs->BRR = 1;

ODR

Output data register, when writing to it, sets the value of ALL the pins to what you wrote to the register: Set pin 0 of port A high, all the others low
GPIOA->regs->ODR = 1;

IDR

Input data register, returns the value of ALL the pins related to the specified port: Check if pin n (n=0..15) of Port A is high
if(GPIOA->regs->IDR & (1<

Storing data in flash memory

Declare variables as const to put them into flash memory.

This old method (below) is deprecated

The __FLASH__ macro to store variables into the flash memory, instead of the RAM,
example:
uint32 array[] __FLASH__ = {0, 1, 2};

*