Embedded Programming

The best way to know about a microcontroller and Instruction set is reading its Datasheet.we will get all the information from the Datasheet , only problem is that its not beginner friendly. I started Reading ATtiny44 Datasheet that I got from the Micorchip's website as it was a part of the assignment this week..

The ATTINY44 runs with the RISC Architecture. RISC or reduced instruction set computer is a computer which only uses simple commands that can be divided into several instructions which achieve low-level operation within a single CLK cycle, as its name proposes “Reduced Instruction Set”. It's performance is optimized with more focus on software. RISC mainly Used in Microcontroller.

The Block Diagram for the ATTINY44, according to the datasheet has four main sections,

• The ALU
• Timer/RAM/Counter/EEPROM
• The Data Registers
• and The Programming interface

The ALU - Arithmetic Logic Unit - operations are divided in some categories like: arithmetic, logical and bit-functions. Status register contains the most recently executed arithmetic instruction.

The main features of the timer - counter are:

The ADC table characteristic are:

In order to choose an ADC, you need to choose multiplexers according to this table.

Port A Configuration:

Port B Configuration:

Programming the ATTINY44 with Arduino

The Arduino Development Environment can be used to program the ATTINY44. It makes life much easier for the everyday maker like me by getting the full support of the Arduino IDE.

To program the ATTINY microcontroller family using Arduino, I will be using ATTinyCore, which is an Arduino core for ATtiny 1634, 828, x313, x4, x41, x5, x61, x7 and x8 series of microntrollers. The installation instructions are given on the github page and I just followed the Instructions for the Boards Manager Installation Method.

Board Manager Link:

The usage is straightforward, it accepts arduino code syntax as it is. Heavy libraries like the servo.h doesn't work, but there are many ways to work around it. To set the fuse for the 20Mhz external oscillator, the bootloader needs to burned before the initial use.

Code:

This code below blinks two LEDs on pin PA3 and PA4.

Command Line Output

Output

HEX Output:

Programming the ATTINY44 with GCC C

AVR microcontrollers can be programmed using GCC C. I'll be using Atmel Studio as the IDE. Most of Neil's code is written in C, which I have been having a hard time understanding. Hopefully after tinkering with Atmel Studio a bit, I'll be able to write my onw C code.

The Usage is not as straight forward as Arduino. First we have to create a project, we'll select a 'GCC C Executable Project' and for device, we'll select 'ATTINY44'

The FABISP needs to be added as an external tool to Atmel Studio if we want to use it to upload our code.

External Tool Settings for FabISP

• Title: USBTiny ISP.
• avrdude.exe
• -c usbtiny -p attiny44 -Uflash:w:"$(ProjectDir)Debug\$(TargetName).hex":i


** (avrdude path variable needs to be added)

Code:

Command Line Output for Build:

Command Line Output for Flashing:

The STM32F103xx medium-density performance line family incorporates the high-performance ARM®Cortex®-M3 32-bit RISC core operating at a 72 MHz frequency, high-speed embedded memories (Flash memory up to 128 Kbytes and SRAM up to 20 Kbytes), and an extensive range of enhanced I/Os and peripherals connected to two APB buses. All devices offer two 12-bit ADCs, three general purpose 16-bit timers plus one PWM timer, as well as standard and advanced communication interfaces: up to two I2Cs and SPIs, three USARTs, an USB and a CAN.

Specifications:

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 or 128 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, 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, I2Cs and USARTs



Up to 80 fast I/O ports

• 26/37/51/80 I/Os, all mappable on 16 external interrupt vectors and almostall 5 V-tolerant



Debug mode

• Serial wire debug (SWD) & JTAG interfaces



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 I2C 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®

The Minimal circuit for the STM32F103C8T6 can be found in the official ST documentation for Getting started with STM32F10xxx hardware development application note.

The footprint for the STM32F103C8T6 we have at the lab is LQFP48 (7mmx7mm) which is not possible to mill with the (1/64) bit we have at the lab. So I went ahead and bought a breakout board for the LQFP48 package and soldered the STM32F103C8T6 onto it. But I didn't realize how hard it would be to get all the peripheral components connected to the breakout board. I ran out of time I allocated to explore the STM32F103C8T6.

I resorted to using an STM32F103C8T6 development board instead of making my breakout board work. It was pretty straightforward from there. It came with all peripheral components on board and Serial/USB and SWIM interface for programming.
All information on these generic STM32F103C8T6 development board, also known as the Blue Pill development board can be found here.

To program the generic blue pill development board I have, I'll be using STM32duino, the arduino Core for STM32.
Installation instructions can be found here.

To use the board manager installation method, the following url needs to be added to the Additional Board Manager URLs,
https://github.com/stm32duino/BoardManagerFiles/raw/master/STM32/package_stm_index.json

Blue Pill ---------------------ST-Link

• 3v3--------------------------------------pin 1
• SWO------------------------------------ pin 7
• SWCLK-----------------------------------pin 9
• GND-------------------------------------GND

Code:

Hex footprint:

Surprisingly, the hex footprint to run this small code is 715 lines long. (32,768 bytes)

Mbed is an online embedded device platform which gives you an embedded operating system, transport, security and cloud services to create Embedded solutions. Although it is designed mostly for IoT applications, the generic chinese blue pill development board can also be programmed using it. I think it is an integrated solution that is easy to work on and easy to deploy. More about what is Mbed and how it works, can be found here.

Adding Hardware for Generic Blue Pill in our console:

After you sign up, You should be able to navigate to your console.Before we can get started with programming, we need to add our device to the hardware list in our console. The generic blue pill development board for the STM32F103C8T6 is not supported officially by mbed. So we have to add it as a Nucleo-F103RB. It uses the same chip but has 128kb flash memory instead of our 64kb board. I found this nifty guide, on how to program our generic board using Mbed.

Using the Online Mbed Compiler

The compiler UI is a bit confusing at first. I would recomend using the many example programs given by Mbed and writing your own code by modifying the templates. First we'll create a new program, and I named it "HelloWorld_blinky" and is based on the 'Display a message on PC using UART' example.
The program project folder will be created along with the 'main.c' file, which we will be editing to write our own code. The example code looks a bit like this, but it didn't work out of the box because the default Serial Tx/Rx pins for the nucleo and the blue pill are different. So after going through the Generic Blue Pill Guide for Mbed, I wrote the following code.

Compiling and optimizing:

The Blue Pill board has 64KB memory, while the nucleo has 128kb. So after we click compile, we have to check on the 'Build Details', and manually ensure the Flash size does not exceed 64kb. For our case, the Flash Size of the build was 27.6kb which was well under 64kb. Once you click compile, the compiled .bin file should automatically downloaded in your browser.

Blue Pill ---------------------ST-Link

• 3v3--------------------------------------pin 1
• SWO------------------------------------ pin 7
• SWCLK-----------------------------------pin 9
• GND-------------------------------------GND

To view the UART output, connect the FTDI module with the blue pill dev. board, make sure the FTDI is in 3.3v mode or you'll destroy the board. The connection should be;

Blue Pill ---------------------FTDI

• 3v3--------------------------------------3.3v
• A3--------------------------------------- TX
• A2----------------------------------------RX
• GND-------------------------------------GND