Dump RAM Projects

This site is about dumping my ram content. My electronic and programming projects and things that get in the way.

[dumpram-blog]

STM32F4 Temperature Sensor and FreeRTOS

These last few days temperatures outside were low so I decided to measure them without getting out too often :). I used STM32F4, its internal temperature sensor and HC05 bluetooth module and received data on Android with my ABTerminal. Additionally I used FreeRTOS just to make it more interesting. The project can be found on GitHub profile dumpram or just go to Repository section on this blog. I used Keil uVision4. Here is how I did it.

Measurment often implies work with ADC peripheral. It is pretty easy to get it working using Standard Peripheral Drivers.  Serial communication tutorial can be found on this link. First initialize ADC. You need to enable clock on suiting peripheral bus. For ADC1 bus is APB2. Other properties are given in this snippet: 

ADC_CommonInitStruct.ADC_Mode = ADC_Mode_Independent; ADC_CommonInitStruct.ADC_Prescaler = ADC_Prescaler_Div8; ADC_CommonInitStruct.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled; ADC_CommonInitStruct.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles; ADC_CommonInit(&ADC_CommonInitStruct); ADC_InitStruct.ADC_Resolution = ADC_Resolution_12b; ADC_InitStruct.ADC_ScanConvMode = DISABLE; ADC_InitStruct.ADC_ContinuousConvMode = ENABLE; ADC_InitStruct.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None; ADC_InitStruct.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1; ADC_InitStruct.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStruct.ADC_NbrOfConversion = 1; ADC_Init(ADC1, &ADC_InitStruct);

Furthermore, for configuring temperature sensor use this code:

/* Connect ADC1 to temperature sensor */ ADC_RegularChannelConfig(ADC1, ADC_Channel_TempSensor, 1, ADC_SampleTime_144Cycles); /* Enable internal temperature senosor */ ADC_TempSensorVrefintCmd(ENABLE);

After initialization you can get temperature from ADC with following function. I think, I found magic numbers in code in STM32F4 datasheet.

/** * Function gets current temperature value. * @return current temperature value */ double get_temperature() { double tempValue; ADC_SoftwareStartConv(ADC1); //adc starts conversion while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET) { //waiting conversion to end } //these next calculations i found somewhere in stm32f4 //manual tempValue = ADC_GetConversionValue(ADC1); tempValue *= 3300; tempValue /= 0xfff; //this gets mV tempValue /= 1000.0; //this gets V tempValue -= 0.760; // subtract referent voltage tempValue /= .0025; // divided by step tempValue -= 11.0; // some kind of magic number return tempValue; }

Ok, this was pretty easy and should work after little debugging. Next step is to make interesting and introduce FreeRTOS. If you don't know what FreeRTOS. FreeRTOS is open source Real Time Operating System and it is very popular in embedded domain. But why do we need FreeRTOS? Ok for this particular project its use is little streched but that's why this project is ideal for first implementation(it is not very complicated). Download FreeRTOS source from here. Exract files from archive. You'll need files from folder FreeRTOS/Source. In "FreeRTOS/Source" folder there is folder "portable". From "portable" use only files for your device. In this case STM32F4. You should choose "port.c" and "portmacro.h" from "FreeRTOS/Source/RVDS/ARM_CM4F". Also you should use files from "MemMang" in "portable". This are files that manage heap memory in FreeRTOS. You need just one of them. I used heap_2.c. After adding all source files in project and including header in build path you should write "FreeRTOSConfig.h" header file. If you are starting with FreeRTOS and you don't know how, you can use config files from project which are included in examples in FreeRTOS downloaded archive. Find example for CortexM4 and it will suit STM32F4. You can delete macros defined for specific project in that file. At this point building project is easy. Before I point out more problems. Let's see the source "main.c".

#include "usart.h" #include "temp.h" #include "FreeRTOS.h" #include "task.h" #include "queue.h" #define NUM_OF_SAMPLES 100 xQueueHandle tempQueue; void delay() { int i = 8000000; while(i--); } void calcAverageTemperature() { int i; double avrTemp = 0; init_ADC(); while(1) { for (i = 0; i < NUM_OF_SAMPLES; i++) { avrTemp = (avrTemp + get_temperature())/2; xQueueSendToBack(tempQueue, &avrTemp, 0); } } } void sendTemperature() { double avrTemp; char temp[10]; init_USART1(9600); while(1) { USART_puts(BLUETOOTH_TERMINAL, "Current temperature is: "); xQueueReceive(tempQueue, &avrTemp, 0); sprintf(temp, "%f", avrTemp); USART_puts(BLUETOOTH_TERMINAL, temp); USART_puts(BLUETOOTH_TERMINAL, "\n"); delay(); } } int main(){ tempQueue = xQueueCreate(1, sizeof(double)); xTaskCreate(sendTemperature, "temp_send", 128, NULL, 1, NULL); xTaskCreate(calcAverageTemperature, "temp_calc", 128, NULL, 1, NULL); vTaskStartScheduler(); }

In main function there is nothing special. Just creating tasks that FreeRTOS will execute. Also tempQueue is created for sending temperature value from task that's calculating average value of 100 samples because values vary between few measurements. There is function that's calculating average temperature and function which is sending data to bluetooth terminal. This way task which sends data is seperated from task calculating and getting data from sensor. This way code isn't monolithic and it is easier to debug. After getting 100 samples from ADC calcAverageTemperature task is putting value in Queue(FIFO principle - FirstInFirstOut). Furthermore, sendTemperature task is receiving value from queue and sends it to terminal.

Final summation

I spend two hours debugging this code. Because tasks were not executing. Why? Let's go back to FreeRTOSConfig header file. Make sure you define next things:

#define xPortPendSVHandler PendSV_Handler #define vPortSVCHandler SVC_Handler #define xPortSysTickHandler SysTick_Handler

This will ensure that only FreeRTOS SVHandlers are invoked and not the dummy ones in STM32F4 startup file. OK, this was pretty much it. Stay tuned for updates. Come here if you deer.

[dumpram-blog]

Repository Updated

I opened Repository section on blog. All codes for all projects are available on links there. Work is still in progress for some of them. Projects can be found on my newly opened GitHub profile dumpram. 

Beta version of my Android Bluetooth Terminal is available on GitHub. In repository you can also download apk file and install it on your Android device. 

I developed ABTerminal for purposes of testing Bluetooth module such as HC05, HC06, etc. It can be used for debugging purposes in embedded systems. Additionaly, code that I developed I use for connecting microcontrollers to my phone. It enables me to control speed of DC motors(PWM), relays, LEDs and receiving data from sensors. Some of it I'll post here soon.

[dumpram-blog]

STM32F4 Audio Via Cirrus CS43L22

Playing audio with STM32F4 seems pretty nice. But it is pretty difficult and takes a lot of time to get a beep from it. However, there are many MP3Player projects on internet which you can download and compile easily. I tried to make sound on my own. I'll describe procedure of setting up Cirrus CS43L22. To understand any of this you should be familiar with I2C, I2S, SPI protocols and you should know basics about using Standard Peripheral Drivers for STM32F4, some of that basic stuff was covered on this link.

First of all, you should take a look at reference manual for CS43L22 on this link. STM32F4 is connected to Cirrus with I2C port for configuration and I2S for audio data transmission. 

GPIO pins, clocks, etc.

I2C uses 2 signals: SCL, SDA. For purposes of controlling Cirrus I used I2C1. You can take a quick look at this link and you'll see that pins for I2C1 are: 

SCL: GPIOB6

SDA: GPIOB9

Confuguration of I2C is simple. Enable clock for GPIO, I2C, initialize GPIO and initialize and enable I2C. This code should do something like that:

void init_I2C() { I2C_InitTypeDef I2C_InitStruct; GPIO_InitTypeDef GPIO_InitStruct; /** Enable clocks **/ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE); /** Configure GPIO for I2C **/ GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStruct.GPIO_OType = GPIO_OType_OD; GPIO_InitStruct.GPIO_Pin = I2C_SCL | I2C_SDA; GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_I2C1); GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_I2C1); /* initialize the I2C_ClockSpeed member */ I2C_InitStruct.I2C_ClockSpeed = 100000; /* Initialize the I2C_Mode member */ I2C_InitStruct.I2C_Mode = I2C_Mode_I2C; /* Initialize the I2C_DutyCycle member */ I2C_InitStruct.I2C_DutyCycle = I2C_DutyCycle_2; /* Initialize the I2C_OwnAddress1 member */ I2C_InitStruct.I2C_OwnAddress1 = 33; /* Initialize the I2C_Ack member */ I2C_InitStruct.I2C_Ack = I2C_Ack_Enable; /* Initialize the I2C_AcknowledgedAddress member */ I2C_InitStruct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; I2C_Init(I2C1, &I2C_InitStruct); I2C_Cmd(I2C1, ENABLE); }

Additionally, we need to configure reset pin for Cirrus and this particular pin is connected to GPIOD pin 4. Use configuration from code below.

void init_AudioReset() { GPIO_InitTypeDef GPIO_InitStruct; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE); GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStruct.GPIO_OType = GPIO_OType_PP; GPIO_InitStruct.GPIO_Pin = AUDIO_RST; //4 GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_DOWN; GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOD, &GPIO_InitStruct); }

And finally I2S needs to be configured. I had a lot of trouble with these especially with configuring clocks. I think there is an error in Standard Peripheral Driver documentation of stm32f4xx_spi.h file. In part where they describe how to use driver there's line:

RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI3, ENABLE) for SPI3

Of course I just copied it code and there was no sound until I corrected it to:

RCC_APB1PeriphResetClock(RCC_APB1Periph_SPI3, ENABLE);

I2S interface is on SPI3 bus and it connected to Cirrus chip. Pins used for I2S are: 

MCLK (Master Clock) : GPIOC 7

SCLK (Serial Clock) : GPIOC 10

SD (Serial Data) : GPIOC 12

WS (Word Select) : GPIOA 4

Again configure GPIOs, enable clocks and I2S. Here's the code:

void init_I2S() { I2S_InitTypeDef I2S_InitStruct; GPIO_InitTypeDef GPIO_InitStruct; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE); /* Initialize the I2S_Mode member */ I2S_InitStruct.I2S_Mode = I2S_Mode_MasterTx; /* Initialize the I2S_Standard member */ I2S_InitStruct.I2S_Standard = I2S_Standard_Phillips; /* Initialize the I2S_DataFormat member */ I2S_InitStruct.I2S_DataFormat = I2S_DataFormat_16b; /* Initialize the I2S_MCLKOutput member */ I2S_InitStruct.I2S_MCLKOutput = I2S_MCLKOutput_Enable; /* Initialize the I2S_AudioFreq member */ I2S_InitStruct.I2S_AudioFreq = I2S_AudioFreq_48k; /* Initialize the I2S_CPOL member */ I2S_InitStruct.I2S_CPOL = I2S_CPOL_Low; RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE); RCC_PLLI2SCmd(ENABLE); GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStruct.GPIO_OType = GPIO_OType_PP; GPIO_InitStruct.GPIO_Pin = I2S_SCLK | I2S_SD | I2S_MCLK; GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.GPIO_Pin = I2S_WS; GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_PinAFConfig(GPIOA, GPIO_PinSource4, GPIO_AF_SPI3); GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_SPI3); GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_SPI3); GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_SPI3); I2S_Init(SPI3, &I2S_InitStruct); I2S_Cmd(SPI3, ENABLE); }

Finally after configuring peripheral buses, configuration of Cirrus needs to be done. If you look at datasheet of codec you'll see that address for writing is 0x94. First you need to send to codec is initialisation sequence after which configuration is done. While sending data first byte you send is register address and then you send data to set in register. There are many registers but the most important ones are on addresses:

0x02 : Power Control Register 1

0x04 : Power Control Register 2

0x05 : Clocking Control Register

0x06 : Interface Register

0x22 : Headphone volume

Here is code for writing on I2C and setting registers on codec:

void sendBytesAudioI2C(char *bytes, int num) { int i; while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY)); I2C_GenerateSTART(I2C1, ENABLE); while(!I2C_GetFlagStatus(I2C1, I2C_FLAG_SB)); I2C_Send7bitAddress(I2C1, AUDIO_I2C_ADDRESS, I2C_Direction_Transmitter); while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)); for (i = 0; i < num; i++) { I2C_SendData(I2C1, bytes[i]); while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)); } I2C_GenerateSTOP(I2C1, ENABLE); }

After you configured all of this. You should hear something after sending data to codec via I2S. Next step is to actually play song in WAV, PCM format. I'm still in process of learning here, updates will be posted soon.

[dumpram-blog]

Downloading large files in MVC

Here is something useful for anyone who is developing web applications in MVC. Probably not the prettiest but nice way to handle request for downloading large file. It is crucial to implement buffering.

public ActionResult Download() { String FilePath = ""; //file path on server String FileName = ""; //file name byte[] DataBuffer = new byte[1024]; //buffer int DataRead; System.IO.Stream InputStream = new System.IO.FileStream(FilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.Read); /** Creating HTTP header **/ HttpContext.Response.ContentType = "application/octet"; HttpContext.Response.AddHeader("Content-Disposition", "attachment;filename=" + FileName); HttpContext.Response.BufferOutput = false; System.IO.Stream OutputStream = HttpContext.Response.OutputStream; try { while ((DataRead = InputStream.Read(DataBuffer, 0, DataBuffer.Length)) > 0) { OutputStream.Write(DataBuffer, 0, DataRead); } } catch (Exception e) { } return View(); //in view you can display information about success or error }

There are more complicated solutions. For example you can create class which extends FileResult or similiar class but it is very tricky and it is much slower. More information on this link.

[dumpram-blog]

Charging And Balancing LiPo Batteries

A lot of devices today are powered by LiPo Batteries. Lithium polymer(LiPo) batteries are in fact Lithium ion(LiOn) batteries with strengthened casing. Electrical characteristics are similiar. Exact voltage ratings you can always found in datasheets but standard voltage ratings for LiPo cell are: 

Maximum voltage - 4.2V

Minimum voltage - 3.0V

Nominal voltage - 3.7V

Therefore, you should charge LiPo cell at maximum voltage 4.2V(must never go up). Also, you should never empty your cell below 3.0V. It is pretty easy to charge LiPo cell you need is AC to DC transformer. I use also DC to DC transformer LM2596 to tune voltage for charging to 4.2V. You can find this DC to DC Step down converter on eBay for about 5$. Also you can use USB output on your computer instead of AC to DC transformer but your charging current will be reduced and time of charging prolonged. I use this DC to DC converter:

Charging current markings

On LiPo batteries you can find markings such as 1C, 2C, 5C etc. They indicate maximum or recommended charging current for your battery or cell. For example(let's assume that capacity of battery is 1200 mAh):

1C - 1 * capacity of battery per hour= 1 * 1200 mAh / h = 1200 mA

5C - 5 * 1200 mAh / h = 6000 mA = 6 A

Charging multicell batteries

When you have batteries with more than one cell. Voltage ratings are different. Therefore, the way you charge them is different. If you have 2 cells your nominal voltage is 7.4V, but you charge batteries at 8.4V. Batteries have markings which indicate number of cells. For example:

2S - two cells: nominal voltage = (2 * 3.7) V, max voltage = (2 * 4.2) V

3S - three cells: nominal voltage = 11.1 V, max voltage = 12.6 V

Problem while charging multicell batteries is insuring that every cell is charged equaly. This is called balancing. LiPo chargers that are available commercially can balance batteries. If you don't have LiPo charger you can always charge cells seperately to same voltage. 

My charger and balancer

Here I'm charging 1 cell. Balancer is still in development. I charged at nearly 1C which is recommended for most LiPo batteries. So charging current for one cell for battery on picture is 0.6 A. Battery in picture is Turnigy nano-tech 2S airsoft pack 1200 mAh. I'll post my progress with balancer soon.

[dumpram-blog]

Connecting STM32F4 & Android Phone Via Bluetooth

I established connection between STM32F4 and Android Phone using HC06 bluetooth module which can easily be found on eBay. For this project I developed Bluetooth terminal app for Android which enables communication between devices. Program for this project was written in Keil uVision5 IDE and only Standard Peripheral Drivers were used.

First step

Decide which USART you will use. STM32F4 has 6 USART ports, every port has 4 pins. These pins are RX, TX, CTS and RTS. For this project I used only 2 pins RX and TX. CTS and RTS are used for synchronization but they are not important here. This picture below shows all pins and their designations and secondary functions. I used USART1. GPIOB pins 6 and 7.

Second step

Write initalization function for USART1. The example of function is below.

/** * Function initialises USART1 with given baudrate. * @param baudrate given baudrate * */ void init_USART1(int baudrate) { /* GPIO structure for initialisation */ GPIO_InitTypeDef GPIO_InitStruct; /* USART structure for initalisation */ USART_InitTypeDef USART_InitStruct; /* NVIC structure for initalisation */ NVIC_InitTypeDef NVIC_InitStruct; /* For USART1 enable clock on APB2 bus*/ RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); /* For GPIOB enable clock on AHB1 bus */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE); /* Forming GPIO structure */ GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; //pin 6(TX), pin7(RX) GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStruct.GPIO_OType = GPIO_OType_PP; GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP; /* Initalization of GPIO */ GPIO_Init(GPIOB, &GPIO_InitStruct); /* Give USART1 control over GPIOB pins 6 and 7*/ GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_USART1); GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_USART1); /* Forming USART initalisation structure */ USART_InitStruct.USART_BaudRate = baudrate; USART_InitStruct.USART_WordLength = USART_WordLength_8b; USART_InitStruct.USART_StopBits = USART_StopBits_1; USART_InitStruct.USART_Parity = USART_Parity_No; USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStruct.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; /* Initialisation of USART1 */ USART_Init(USART1, &USART_InitStruct); /* Enabling interrupt for USART1 */ USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); /* Forming NVIC structure */ NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn; NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0; NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE; /* NVIC initialisation */ NVIC_Init(&NVIC_InitStruct); /* Enabling USART1 */ USART_Cmd(USART1, ENABLE); }

Third step

Write function that sends bytes to USART. This can be done like this:

void USART_puts(char* bytes) { while(*bytes) { //waits until USART1 is ready while(!(USART1->SR & 0x40)); USART_SendData(USART1, *bytes); bytes++; } }

Fourth step

Write interrupt handler function. It is defined that interrupt function for USART1 has prototype:

void USART1_IRQHandler(void);

This is example of interrupt function which will echo data received. This way in terminal you will see data you send to STM32F4.

void USART1_IRQHandler(void) { //checks if interrupt is set by USART1 if(USART_GetITStatus(USART1, USART_IT_RXNE)) { char byteReceived = USART1->DR; USART_puts(&byteReceived); } }

Fifth step

Writing main function shouldn't be problem because it only initialises USART and stays in infinite loop. Here is the code:

int main() { init_USART1(9600); while(1) { //waits forever } }

Bluetooth modules HC06 or HC05

After all this coding you may ask yourself: "OK, where in code I specify bluetooth module or something similiar?". Bluetooth is not mentioned because module and MCU communicate via USART interface. If you don't have bluetooth module or android phone you can test this code with Silabs CP2102 or similiar module for serial communication with USB interface. On other hand, if you want bluetooth communication with your android phone download android bluetooth terminal and connect HC06 bluetooth module to your STM32F4. Make sure that you connect HC06's RX to STM's TX and HC06's TX to STM's RX. HC06 can be powered with 3.3V - 5V. You can download HC05 & HC06 datasheets on this link. Below you can see the picture of HC06 with development board. 

[dumpram-blog]

Starting blog

I’m starting this blog to share experience and knowledge about electronics and embedded systems. I will document my projects. This way anybody who encounters same problem as I did designing circuits or developing software can benefit from my previous success or failure.