STM32F103ZET6 board comes with 3.2 inch graphical LCD which features an ILI9320 controller. Equipped LCD is capable of displaying 252144 colors when driven in 18-bit mode. We are gonna drive it in 16-bit mode, so we are limiting it to 65K colors.

LCD driver is based on existing code found on internet which was originally developed for STM3210E board. Only minor modifications were needed like assigning right control pins.

STM32F103ZET6 board was designed so that LCD was connected to Flexible Static Memory Controller (FSMC) of STM32. FSCM allows connecting most of external parallel memory types like ROM, SRAM, NOR Flash, NAND Flash. ILI9320 driven LCD is connected in 16-bit mode to FSMC Bank1 4^th subpage and is seen as SRAM memory, so once configured controlling LCD becomes same as writing to SRAM. LCD memory starts from address 0x6C000000

#define LCD_BASE ((u32)(0x60000000 | 0x0C000000))#define LCD ((LCD_TypeDef *) LCD_BASE)

LCD is controlled by using index register which points to selected register and with next operation we can write to its memory. So for this there is a simple structure used:

what allows writing to register with simple routine:

voidLCD_WriteReg(u8 LCD_Reg, u16 LCD_RegValue){//Write 16-bit Index, then Write RegLCD->LCD_REG = LCD_Reg;LCD->LCD_RAM = LCD_RegValue;}

There are 152 registers used to control LCD and most of these has to be initialized before accessing LCD. As I mentioned it is already done in LCD library no need to wary for now. In attached project you’ll find a working example of LCD which simply displays a bitmap image stored in MCU SRAM.

By pressing one of four buttons you can cycle through other functions like drawing simple shapes, displaying text and drawing sine wave. Hopefully you’ll find this useful. STM32F103ZET6GLCD

[via: http://www.scienceprog.com/]

Couple years ago I have purchased LPC2148 development board called BlueBoard form ngxtexhnologes. It is quite powerful board with ATM7TDMI series microcontroller which is considered an old guy comparing to Cortex ones. But still these are widely used and are powerful.

Development board has some handy features installed. 12MHz crustal allowing to run processor at full 60Mhz speed. Couple RS232 ports, VGA connector, PS/2 connector for keyboard or mouse, 20-pin JTAG, SD/MMC slot, USB B-type, 8 LEDs driven with serial-in parallel-out shift register, 2×16 LCD, buzzer, audio jack with amplifier, two programmable buttons and 256Kb of I2C interfaced EEPROM. Microcontroller itself has 512KB of internal flash and 32+8KB of RAM. All ports are accessible and any external hardware can be disconnected with jumpers. This is great board for prototyping and end application.

I decided to put up a simple project. And yes, you guessed – LEDs again. Blueboard website provides with code examples. Most of drivers are already written this makes our life much easier. Only minor modifications will be needed as their code is based on (or related to TNKernel real-time kernel). For now I just want to get rid of RTOS based code and make simple application.

Our project will be based on same tools as we used for STM32F103ZET6 development board. So no additional preparation is needed – just open Eclipse (CodeSourcery must be installed too). The only thing you will need is different firmware flasher as LPC2148 is NXP product. For this there is great program called Flash magic that uploads compiled code by using build in bootloader.

Project setup is nothing more than collection of files collected from different sources. These include linker scripts, start-up codes, makefile. You can find board drivers on NGX website within example code.

[You can download project package here that strobes all 8 LEDs here:LPC2148LED]

Lets see how these LEDs are controlled. As we mentioned above, LEDs are connected through serial to parallel shift register which is controlled via SPI interface:

For this we are going to need drive SPI peripheral of microcontroller and also drive register itself so we could access individual LEDs. For this we must include spi.h library that was already in example package. Originally there were separate source files for 74HC595N register and led. But this seems unnecessary while register and leds comes along, so I simply merged those libraries in to led.h and made a little cleanup to get rid of few rtos based functions.

After preparation we can write simple application that gives strobe effect on LEDs:

#include "type.h"#include "hardware.h"S32 main(void){HardwareInit();test_leds();while(1){leds_on();delay(10000);turn_off_all_leds();delay(190000);}return 1;}

Here you can a HardwareInit() function from hardware.c, which simply takes care of setting up a PLL multiplier where 12MHz crystal frequency are multiplied to 60MHz that clocks MCU core. SPI peripheral is initialized here too.

Hope you find this information useful.

[via: http://www.scienceprog.com/]

In previous example we implemented a simple demo program that reads buttons by constantly checking their status in main program loop. Obviously this isn’t efficient and convenient way to do that. Imagine your program has to do lots of tasks and in between you also need to check button status – mission becomes impossible unless you use interrupts. In this part we briefly introduce to STM32F10x interrupt system and write example code where LEDs and buttons are serviced within interrupts.

ARM Cortex-M3 microcontrollers have advanced interrupt system that is pretty easy manageable. All interrupts are controlled inside Nested Vectored Interrupt Controller (NVIC) which is close to Cortex core to ensure low latency and robust performance. Main features of NVIC include:

• Interrupt preemption – automatic support for nested interrupts where higher level exception may interrupt lower level that is currently processed. NVIC takes care of saving context to stack. As everything is done in hardware there is no need for assembler wrappers like we do in other MCUS. All is needed is to ensure that you won’t run out of stack memory and set right interrupt priorities;

• Tail chaining – it’s a mechanism allowing to reduce latency if exception occurs during or just after current ISR routine. In this case MCU doesn’t have to do full unstacking that allows to enter another pending exception as soon as possible.

• Late arrivals – feature allowing to overtake current lower priority interrupt which is in stacking process.

These features are handled automatically and you don’t have to care much about this – just enjoy faster ISR response.

STM Cortex-M3 interrupt system

During microcontroller initialization (when start-up code is run) all exception/interrupt vectors usually are stored in very beginning of flash memory starting from address 0×00000004. Address 0×00000000 is used to store initial stack pointer value.

As you can see in table, first 15 interrupts are generated within cortex core while other down the list are interrupts generated by peripherals like pins, timers, ADC, DMA, etc. STM32F103ZET6 NVIC is able to handle up to 60 maskable interrupt channels plus 16 lines of core interrupts. Each interrupt (except first three: Reset, NMI, Hard fault) can have 16 priority levels set with 4 bits in 8-bit priority level register. The lover number means higher priority. The higher priority may preempt lower priority automatically. Priority bits may be split in to two groups called Preemptive priority and sub-priority. This doesn’t change much, but helps to organize priorities so that same preemptive level priorities could be arranged in to sub-priorities in order to decide which should be handled first. Anyway all this is done with same 4- bits what leads to total number of 16.

The whole procedure of enabling interrupts consists of following steps:

1. Select interrupt channel in NVIC module;
2. Set preemptive priority;
3. Set sub-priority;
4. Enable interrupt for particular line.

Then you have to take care of interrupt service routine where your code will be performed when interrupt occurs.

EXTI and pin mapping

External interrupts from microcontroller pins aren’t traced directly to NVIC as you’d expect. STM32 provides flexible mechanism that allows mapping different pins to same channel. This gives lots of freedom to decide on which pin to generate interrupt on which channel. So external interrupts are manged through External Interrupt/event Controller (EXTI). EXTI can be set to rise event on rising, falling or both edges. There are 19 lines in EXTI that are associated with mapped pins and other sources. 16 lines are dedicated to port pins each line for separate pin number like this:

Other three lines are dedicated to RTC alarm interrupt, power voltage detect (PVD) and USB wakeup event. Then these lines are traced to NVIC controller in following manner:

• EXTI0 to EXTI4 are traced directly to NVIC as separate channels;
• EXTI5 to EXTI9 are grouped to single NVIC channel (EXTI5_9);
• EXTI10 to EXTI15 are grouped to single NVIC channel (EXTI10_15);
• RTC alarm, PVD and USB wakeup are also traced as single separate channels in NVIC.

Some practical examples

Having this information we can start building our code. In our development board buttons are connected as follows:

Each of them accidentally (or maybe not) falls in to positions where each of them can be mapped to different EXTI lines that allows to have dedicated NVIC channels. This way we will be able to write separate separate handlers for each button:

• EXTI0 line for WAKEUP button (EXTI0_IRQHandler);
• EXTI3 line for USER2 button (EXTI3_IRQHandler);
• EXTI9 line for USER1 button (EXTI9_5_IRQHandler;
• EXTI13 line for TAMPER button (EXTI15_10_IRQHandler;

We are going to write simple routine where each button will toggle related LED. To set up buttons for generating interrupts we write following ButtonInitEXTI() function:

void ButtonsInitEXTI(void){//enable AFIO clockRCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);EXTI_InitTypeDef EXTI_InitStructure;//NVIC structure to set up NVIC controllerNVIC_InitTypeDef NVIC_InitStructure;//GPIO structure used to initialize Button pins//Connect EXTI Lines to Button PinsGPIO_EXTILineConfig(BWAKEUPPORTSOURCE, BWAKEUPPINSOURCE);GPIO_EXTILineConfig(BTAMPERPORTSOURCE, BTAMPERPINSOURCE);GPIO_EXTILineConfig(BUSER1PORTSOURCE, BUSER1PINSOURCE);GPIO_EXTILineConfig(BUSER2PORTSOURCE, BUSER2PINSOURCE);//select EXTI line0EXTI_InitStructure.EXTI_Line = EXTI_Line0;//select interrupt modeEXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//generate interrupt on rising edgeEXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;//enable EXTI lineEXTI_InitStructure.EXTI_LineCmd = ENABLE;//send values to registersEXTI_Init(&EXTI_InitStructure);//select EXTI line13EXTI_InitStructure.EXTI_Line = EXTI_Line13;EXTI_Init(&EXTI_InitStructure);EXTI_InitStructure.EXTI_Line = EXTI_Line3;EXTI_Init(&EXTI_InitStructure);EXTI_InitStructure.EXTI_Line = EXTI_Line8;EXTI_Init(&EXTI_InitStructure);//disable AFIO clockRCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,DISABLE);//configure NVIC//select NVIC channel to configureNVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;//set priority to lowestNVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;//set subpriority to lowestNVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;//enable IRQ channelNVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;//update NVIC registersNVIC_Init(&NVIC_InitStructure);//select NVIC channel to configureNVIC_InitStructure.NVIC_IRQChannel = EXTI3_IRQn;NVIC_Init(&NVIC_InitStructure);NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;NVIC_Init(&NVIC_InitStructure);NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;NVIC_Init(&NVIC_InitStructure);}

It may seem a bit complicated but in deed this is simple when you know what you’re doing. Just a quick overview of what’s done. First of all when modifying/using some peripheral don’t forget to enable bus clock for or otherwise you’ll end up wandering why it’s not working when settings seems to be OK. So are going to be used as alternate functions this is why we need to enable AFIO bus clock. Then we simply map button pins to adequate EXTI lines with GPIO_EXTILineConfig() function which sets proper bits in AFIO->EXTICR registers. Then we select Interrupt mode for EXTI lines (there can be software events also). Generate interrupts on falling edge and with these settings enable current EXTI line. This has to be done with each line.

Once EXTi lines are configured we can disable AFIO bus clock and proceed to NVIC settings. Here we are setting priorities and sub-priorities for each channel and enabling each of them one by one. This is it. Now we can implement interrupt handlers that we are gonna place in separate source file (stm32f10x_it.c). here we implement codes:

void EXTI0_IRQHandler(void){//Check if EXTI_Line0 is assertedif(EXTI_GetITStatus(EXTI_Line0) != RESET){LEDToggle(1);}//we need to clear line pending bit manuallyEXTI_ClearITPendingBit(EXTI_Line0);}

and so on for all channels. Within handler it is good practice to check if current EXTI line is asserted. Then we can do our business like toggle LED. And before leaving EXTI handler it is important t oreset EXTI line as it stays set until manually cleared. If not this line will generate chain interrupts constantly as NVIC takes this as pending interrupt all the time.

Finally we can write our main code which is actually nothing much left:

//STM32F103ZET6 Buttons Test#include "stm32f10x.h"#include "leds.h"#include "buttons.h"#include "stm32f10x_it.h"int main(void){//init ledsLEDsInit();//init buttons t ogenerate interruptsButtonsInitEXTI();//start sys tick timer that also generates interruptsSysTick_Config(15000000);while (1){//your tasks}}

all we need is to implement LED pins, Initialize buttons by calling ButtonsInitEXT() function and thats it. To show another interesting feature of Cortex microcontroller I also enabled SysTick timer which simply generates SysTick interrupts every second.

void SysTick_Handler(void){LEDToggle(5);}

Interrupt handler simply toggles LED5.

[via: http://www.scienceprog.com/]

SMD has entered hobby market long time ago, but there are still many people who afraid to push their projects to SMT level. Once you try it appears to be very easy – even easier than through hole PCB technology. Dave from eevblog have published series of PCB soldering tutorials where he goes through tools needed to make quality soldering, then through hole soldering tips and finally SMD component soldering.

In this video Dave carefully explains what main techniques (individual pin soldering, well based and drag) can be used to successfully solder SMD parts and what odds are awaiting for inexperienced players. If you don’t want to solder with iron, then you’ll see how it is easy to do this with solder paste and hot air gun.

So, take your time and see how it’s easy.

[via: http://www.scienceprog.com/]

FreeRTOS is known as Real Time Operating System. Probably it would be too dare call it real-time-os, rather a real time scheduler where applications can be split in to independent tasks that share full processor resources by switching them rapidly it looks like all tasks are executed in parallel. This feature is called multitasking.

There are lots of debates on using RTOS on AVR microcontrollers as they are arguable too small for running scheduler. The main limitation is small amount of ram and increased power usage. If you are gonna use lots tasks in application, probably you will run out of ram that is used for saving context when switching between tasks. Consider FreeRTOS only if you use larger scale AVRs like Atmega128 or Atmega256. Surely you can find smaller schedulers that are specially designed for smaller microcontrollers even tiny series. In other hand if you master FreeRTOS it can be used with multiple types of microcontrollers like ARM, Cortex, PIC and multiple compilers including IAR, GCC, Keil, Rowley, Attolic. And main reason to keep eye on it – its free.

Probably it would take lots of time and space to go through RTOS theory. Some great information can be found on FreeRTOS website itself. In this series of posts we are going to focus on practical side of using RTOS on AVR microcontroller. We will go through several steps from single task application to more complex solutions.

Things needed to start with FreeRTOS

To start using FreeRTOS we need to download it from http://www.freertos.org/. While writing this post latest version was FreeRTOSV7.0.1. In downloaded package you’ll find freertos source code files, ports to specific microcontrollers and lots of example programs for various microcontrollers and compilers. We are going to use old good Piconomic Atmega128L development board with externalmemory expansion board that adds additional 8K of SRAM. You can chose any Atmega128 development boardas far as it can blink LEDs, read buttons and use USART. Programs will work fine on any of them. As programming environment we are going to use AVRStudio5 which is still quite new and capricious. If you want to learn how to start working with AVRStudio5, check out this short tutorial.

Preparing AVRStudio5 project

First of all we create new project in AVRStudio5. For this we simply File->New Project and select AVR GCC C Executable Project. Enter proper location where your project will be stored.

Click OK. Then select Device “Atmega128” from device list:

Click OK and yo are set up with basic project with main program file that contains some initial code. As FreeRTOS package contains lots of files that we don’t need for our project we are going to copy necessary files to our folder. To make it easier to update FreeRTOS files with upcoming releases we are going to maintain folder structure close to original. To do so in out project tree we are going to create Source folder. To do so just click right mouse button on project folder and select Add->New Folder and type in Source. Now import following files to Source folder from downloaded FreeRTOS package Source folder:

add all files that are in Source directory (including readme.txt). Adding files is simple – just click right mouse button of Source folder and select Add->Existing Item and in file browser select necessary files (multiple select is possible!).

We have added only kernel C files. Now we have to take care of headers. For this we need to create include folder inside Source folder. Then add all files to it from FreeRTOS package include folder.

Now that we’ve taken care of FreeRTOS kernel we need port files. As you may know, port files are to support specific microcontroller hardware. Port files contain information on how to run SysTick timer and how to save and restore context to and from task. Porting is essential part if wee need to support one or another microcontroller. FreeRTOS package already has lots of port options and mos likely you may find one that will support your selected MCU. In other case you’ll have to write port by your own. As we are using Atmega128L microcontroller seems that included Atmega323 port works fine so we are going to use it for now. To include port files properly lest create folder named portable inside Source folder. And then in portable folder we create GCC folder. And in GCC we create folder named ATMega323. Then import porting files port.c and portmacro.h to this folder from FreeRTOS package. Still this isn’t finished with files. We also need memory management file heap_1.c, which takes care of allocating and freeing memory for tasks and queues. To add this file to project create MemMang folder in portable folder and add file from same folder in downloaded package. And lastly FreeRTOS needs FreeRTOSConfig.h configuration file that keeps all freeRTOS related settings. Just import it from FreeRTOS\Demo\AVR_ATMega323_WinAVR.

To make things neat lets create another folder Drivers in project root directory. This will be used to store microcontroller peripheral drivers like USART, I2C, ADC, button, LED and so on.

Before we are going to write some code, project has to be configured. To start configuration just go to menu Project->Properties. First go to Build tab.

This time we are going to configure project as release. Select Configuration as Release. So wee need to generate .hex file (.map, .lss and .eep). These can be selected in Build Artifact group.

In Toolchain tab and Optimization select -Os optimization. And in Directories you will need to include all directories containing .h files in your project(I only managed to get working only with absolute paths). Add GCC_MEGA_AVR in Defined Symbols to tell core that we are going to use GCC for AVR microcontroller.

FreeRTOS Configuration

FreeRTOS has several options that allow to configure applications for various needs. All predefined parameters are placed in FreeRTOSConfig.h file.Depending on what functions are you gonna use some of them may be omitted. AVR microcontroller is too small to use all features of RTOS because of limited RAM. For instance using trace facility probably would be killing. So for our basic example we are using following settings:

#define configUSE_PREEMPTION1#define configUSE_IDLE_HOOK0#define configUSE_TICK_HOOK0#define configCPU_CLOCK_HZ( ( unsigned long ) 7372800 )#define configTICK_RATE_HZ( ( portTickType )1000 )#define configMAX_PRIORITIES( ( unsigned portBASE_TYPE ) 1 )#define configMINIMAL_STACK_SIZE	( ( unsigned short ) 85 )#define configTOTAL_HEAP_SIZE( (size_t ) ( 3500 ) )#define configMAX_TASK_NAME_LEN( 8 )#define configUSE_TRACE_FACILITY	0#define configUSE_16_BIT_TICKS1#define configIDLE_SHOULD_YIELD1#define configQUEUE_REGISTRY_SIZE	0/* Co-routine definitions. */#define configUSE_CO_ROUTINES0#define configMAX_CO_ROUTINE_PRIORITIES ( 2 )/* Set the following definitions to 1 to include the API function, or zeroto exclude the API function. */#define INCLUDE_vTaskPrioritySet0#define INCLUDE_uxTaskPriorityGet0#define INCLUDE_vTaskDelete0#define INCLUDE_vTaskCleanUpResources	0#define INCLUDE_vTaskSuspend0#define INCLUDE_vTaskDelayUntil1#define INCLUDE_vTaskDelay0

We are going to use preemptive kernel engine where kernel timer tick ISR determines which task should run next according to task priorities. Preemptive multitasking is similar to OS like Linux or Windows. Preemptive kernel uses more RAM but is more flexible. Also we aren’t going to use idle hook for now – so disable it too and make idle task yield immediately once it is run. We won’t be changing task priorities during program flow so we disable this functionality too. We are going to use task delay utilities so leave them ON.

Each functionality that isn’t uses frees some amount of memory. For low memory devices is very important to select these carefully.

After all project properties are set, we can start coding our first application. Why not to start with single task – LED blink. To make code modular we will start with writing LED library. So we need to write these routines and put in separate .c and .h files.

LED freeRTOS driver

We created a Drivers folder in our project rood directory. Simply create LED.c and LED.h files by pressing right mouse button on Drivers folder and selecting Add->New Item. AVRStudio5 will generate .c and .h templates where we can start writing our code.

We are going to control one LED connected to pin D6 in our test project. Writing driver is easy. First we need to initialize LED pin as output with simple function:

void vLEDInit(void){// Set LED_O as output pinDDR_LED_O |= (1<<BIT_LED_O);}

and then write LED toggle function that will be called by task.

void vLEDToggle(void){//Toggle LEDPORT_LED_O ^= (1<<BIT_LED_O);}

that’s it.

Creating task

Later we are going to add more tasks so let’s put them all in one separate source file. I created mytasks.c file along with mytasks.h. Lets create simple tasks which will toggle LED every one second. We already have LED toggling driver ready. The only thing left is managing proper delay so LED would toggle every second. FreeRTOS has handy function that allows to set tasks delays when tasks should run. This is called vTaskDelayUntil(). It takes two parameters – previous wake time and ticks to wait. Now its a tricky part of all this. If you look back in FreeRTOSConfig.c file you’ll find a line:

#define configTICK_RATE_HZ( ( portTickType )1000 )

which means that kernel timer ticks every 1ms. In order to get 1s delay we need to wait 1000 ticks. All we need is to set this number as second parameter.

void vLEDFlashTask( void *pvParameters ){vLEDInit();portTickType xLastWakeTime;const portTickType xFrequency = 1000;xLastWakeTime=xTaskGetTickCount();for( ;; ){vLEDToggle();vTaskDelayUntil(&xLastWakeTime,xFrequency);}}

Function xTaskGetTickCount() returns current number of ticks calculated form program start. So we need to pass this number to our delay function as first parameter. We are doing LED initialize before endless for(;;) loop. And task application goes inside endless loop. Here goes our vLEDToggle() function and vTaskDelayUntil() function. vtaskDelayUntil function ensures that task remains in blocked state until delay ends. So this means that blocked task isn’t scheduled until proper event unblocks it (in our case delay exceeds). If we would use idle task hook function for setting MCU to power save mode our application would require less energy as your task is run only every 1s.

Running freeRTOS task

Once task is create consider biggest job is done. Now what is left is to create this task in main routine and start scheduler. Before we start we must decide what priority task should be assigned with. As we are going to use one task (plus idle) we can use idle priority:

#define mainLED_TASK_PRIORITY( tskIDLE_PRIORITY )

To create task we are gonna use one handy function xTaskCreate(). It needs several parameters. First one is task function name that has to be run. Second is a task name that can be freely chosen. Third parameter is stack size. Our application is very simple so minimal stack can be used. For more complex tasks select this parameter carefully. Then follows pointer to parameters that has to be passed to tasks. If there is no parameters to pass use NULL. Following parameter is task priority. And last parameter is used to pass back a handle by reference so task could be addressed. Pass NULL as we aren’t going to use it. Our created task should look as follows:

xTaskCreate( vLEDFlashTask, ( signed char * ) "LED", configMINIMAL_STACK_SIZE, NULL, mainLED_TASK_PRIORITY, NULL );

And lastly we must start scheduler which is our rtos kernel. This is done by calling vTaskStartScheduler().

Compiled project occupies about 6K of Flash memory and uses 3,6K(88.5%) of RAM. So RAM is limiting factor on how many tasks are you gonna run and what complexity they are. If no preemption is required as alternative co-routines can be used as they can share stack.

You can download full project here: M128RTOS[~200K]

[via: http://www.scienceprog.com/]