1. Embedded System, EE500, Dept. of Electrical
Engineering, University at Buffalo
Final Project Report
Haowei Jiang
5016 6365
Fei Wei
5016 4316
12/7/2015
2. Introduction
Nowadays, Embedded system is playing a more and more significant rule in modern world,
with its small size, low cost, low power and high speed, it can be utilized in many different
scenarios. For example, the lab works we finished in this semester, the labs showed that
embedded systems can control the LCD, transmit data to other chips or computers via CAN
and UART buses, it can be scheduled with the timer interrupts and can make commands to
the Microcontroller by the out-interrupts.
As described before, we have done several implements in lab and got really interested in
embedded system, especially the microcontroller LPC1768. One of the most important
implement of embedded system is digital signal processing, that is why we would like to make
program to realize some basic digital signal processing algorithm on the LPC1768 develop
board like Fast Fourier Transformation. After the calculation we planned to display the FFT
spectrum on the LCD and refresh it periodically.
In this report, it presents a program to play real-time music through loudspeaker whose
signal transmitted via USB connection and shows the FFT spectrum of that period of music, in
which the sample rate is 32KHz and the FFT array length is about forty. The reason we choose
this number is that the LCD is 240*360, we choose to display the spectrum horizontally, so the
width is only 240 and the width of every column is 6, so the points could not be larger than 40.
And the half of FFT result is useless cause the result larger than Nyquist frequency is merely
copy of the spectrum before that. Using the Reader Algorithms on LCD board. It shows that
the music playing and display functions play well but not that perfectly. And in the discussion
chapter we will talk about the problems in detail and analysis the reason.
Solution
Here are some basic design ideas implemented in our final project and we will discuss them
in detail. Roughly there are four parts in our project named Initialization, Play Music, Fast Fourier
Transform Algorithm and LCD display respectively. And the peripherals we used in the experiment
are GPIO, Timer0, Timer1, GLCD, USB connection, LED.and related interrupts.
Initialization
Initializing is the very first step in every program. The chip resources will be use in the program
are Timer0, Timer1, AD Converter, DA Converter and USB. So we need to initialize all the resources.
SystemInit() could initialized the system clock, GLCD_Init() initialized LCD screen, USB_Init()
initialize the USB, after that we need to set the registers of LPC_PINCON, LPC_GPOI2, LPC_SC,
LPC_DAC and LPC_ADC. We need to initialize some other parts which we would use in our design.
Use a switch sentence where the PCLK is used to match the system frequency. Typically, the PCLK
for all the peripherals is 1/4 of the System Frequency (32 kHz), which is 8 kHz. That is the
initialization of the program.
3. Play Music
The function of play music is mainly contained in Timer0 Service Function.
As described before, we initialize the system clock by calling function SystemInit(), since that
we could use the ADC peripheral and Timers. Then we initialize and enable the Timer0 with
function NVIC_EnableIRQ(TIMER0_IRQn). When the timer counter matches to the number we set,
the system goes into interrupt. In the interrupt service function TIMER0_IRQHandler(void), the
process flow is: 1. Check the value of DataRun, if it is 1 which means there is data for receive the
value is read to val from DataBuf[DataOut] , if the sound is not mute, 10 bits of the value will be
write into LPC_DAC->DACR, which is a register connected to the Loud Speaker. And after the
process, LPC_TIM0->IR which is the interrupt register will be set to 1, which means it will be ready
to process next interrupt form Timer0.
Fast Fourier Transform Algorithm
We defined a struct which represent a complex (since the music signal is a serial of data).
Based on the definition of the struct we defined a struct array as input and output (after FFT, we
get complex value) and we apply the look-up table method to create a sin and cos value table
sin_tab() & cos_tab() instead of time-consuming direct calculation, this could improve the overall
operating speed.
In FFT, each point (usually N=2n
) contains its frequency and Amplitude information. If the
Amplitude in Signal is A, then amplitude in FFT points is 2*A/N, except the 1st point – Direct Current
component, that is A/N. At the #n point, its frequency should be (n-1)*Fs/N where Fs is the
sampling frequency. Typically, the Fs in wav. File music is 44 kHz. Consider the resolution, if
Fs=1024Hz, N=1024, we get 1 Hz resolution = Fs/N. What’s more, with the symmetric property of
FFT, we only need to plot the half part of the calculation.
After that, we use the Reader algorithms, assuming the FFT number is N:
Firstly, we do the indexed calculation, to reverse the sequence of the natural sequence
Secondly, calculate the numbers of butterfly level m, total is log2N and distance between each
unit.
Then, by using double for-loop to calculate butterfly unit with both same and different
coefficients then apply the formula and do the next unit until the end of the loop.
Last, store the result in s[i] (complex struct array).
LCD Display
Totally we have three functions worked in our program, named display_0(), display_1() and
display_2() respectively. And when the user presses the button INT0, the display will change by a
switch-case function.
4. Fig.1 Display_0()
Fig.2 Press INT0 to call Display_1()
The display_0() and display_1() are simply designed for display some sentences, display_2()
contains is important so we will talk it in detail.
The function of LCD Display is mainly contained in Timer1 interrupt service function
TIMER1_TRQHandler(void). In the initialization process, the counter length of Timer1 is set as
pclk/DATA_FREQ*DIS_TIME-1. Which means after the Audio function is called after DIS_TIME
times, the Display function will be called.
We know the size of the LCD screen is 240 x 360 (X-Y). For instance, if there are 1024 ≈ 1000
numbers of points, the Y coordinate of each point is #point * 360/1000 =0.36 * #point, while in x
direction, the amplitude should be normalized first by max(Amp), so the x value of Amp(#point) *
5. 240/ max(Amp).
To plot the spectrum, we call CRIS_draw_line() function where the input are the start point
and end point coordinate to map the data into bar shape showing on LCD board ( have to initialize
first with GLCD_Init() ). And the display function has a higher priority than the audio function which
is set in the priority of Timer0/Timer1.
Fig.3 the waveform on display_2()
Briefly, we use Timer1 interrupt, the same mechanism as Timer0 above different reference
time in case there was a conflict. So when the system goes into Timer1 interrupt, we runs the
display program.
Discussion
Finally, we come to the last chapter, the discussions. In this chapter, we will discuss the
findings, understandings and challenges. With the experience of this final project we learnt a lot
and have many new findings. Especially in the area of debugging. And we will discuss them in detail.
Experiment Result
Firstly, we would like to introduce the result of our design, after we start the board, the
program runs well with spectrum display meanwhile the music is playing through loudspeaker.
However, the music is not perfectly played in real-time since we apply the Timer1 interrupt, which
contains FFT calculation and display process, so there it comes the delay. And there is another
problem exists that the program seems to be not that robust that after refresh several times, the
screen display seems come to a mass. And we tried to fix it and the debug process will be
introduced with detail in the following section.
Debugging
As described in the previous section, there are some problem exist in the program.
The first problem is that there is a delay while the FFT function is running, we tried to shorten
the length of FFT sample array. It helped but the improvement is not that significant, perhaps the
6. bottleneck is the calculation speed of the LPC1768 microcontroller.
Fig.4 disordered display on LCD
The second problem we faced is the program disorder. Every time when we start the board,
the program can work well for only couple of seconds, and after the LCD screen refreshed several
times, the display on LCD disordered. For solve this problem, we tried to find some solutions.
At first, we thought maybe two Timers may interference with each other, so we changed the
priority of two timers, but it did not work. Also, we tried to use only one timer, but not only the
problem still existed, there seems to be a delay that the sound was lost.
Then, we thought maybe the display function would come disordered when be called in the
function, so we modified the program and add the display codes directly into the Timer1 interrupt
function, however, it did not work either.
We also modified the program to let there be a while loop in the main function, and set a
variable as counter to display, while it is displaying the Timer0 interrupt and sample the audio signal
from USB. But we failed again.
After that we want to find out what cause such a result. So we dug deep in the codes, and
found that may be the register of LPC_GPIO0 disordered. Usually, when the interrupt is called all
the registers values should be saved in stack. But it seems that there were some conflicts. We tried
to save the value of GPIO registers manually, but it still did not work. But we want to emphasize
that once I set a value in GPIO register randomly, the display on screen would disorder at once.
After try all these methods, the imperfection of the program exists. Optimization: To gain a better
resolution, we could increase the FFT number at the cost of delay time.
Conclusion
Finally, although we cannot claim that our project is perfectly done, during debugging we got
a deeper understanding about the resources of embedded system, for example, the USB
connection, Inner interrupt, Timer/Counter, and the display on LCD. With the experience of
7. implement digital signal processing on microcontroller, we realized how important the processing
speed is. And the essentiality to find the balance between cost and performance. Once we want to
implement some more complexed algorithm, we need more calculation capacity. When we were
trying to find what cause the disorder of LCD, we read some very basic level system library functions
which could directly set the values of some registers, which helped us a lot to understand the
operating process in embedded systems. Overall, we learned a lot in the final project.
And thanks to Professor Praveen Meduri and the TAs, Rajarshi Basak, Zahed Hossain and
Xuejuan Yang.
8. Appendix: Code
#include "LPC17xx.h" /* LPC17xx definitions */
#include "type.h"
#include "string.h"
#include "usb.h"
#include "usbcfg.h"
#include "usbhw.h"
#include "usbcore.h"
#include "usbaudio.h"
#include "math.h"
#include "fft.h"
#include "GLCD.h" /* GLCD function prototypes */
#include "CRIS_UTILS.h"
uint8_t Mute; /* Mute State */
uint32_t Volume; /* Volume Level */
#if USB_DMA
uint32_t *InfoBuf = (uint32_t *)(DMA_BUF_ADR);
short *DataBuf = (short *)(DMA_BUF_ADR + 4*P_C);
#else
uint32_t InfoBuf[P_C];
short DataBuf[B_S]; /* Data Buffer */
#endif
#define FFT_N 40
#define DIS_TIME 4000
uint16_t DataOut; /* Data Out Index */
uint16_t DataIn; /* Data In Index */
uint8_t DataRun; /* Data Stream Run State */
uint16_t PotVal; /* Potenciometer Value */
uint32_t VUM; /* VU Meter */
uint32_t Tick; /* Time Tick */
long val_temp;
uint32_t RegBuf[4];
9. uint16_t FFTcount; /* FFT count */
static uint16_t counter;
struct compx s[FFT_N]; /* FFT points */
static char valdisp[22];
char hex_chars[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
void display(void);
void Hex_Str (unsigned char hex, char *str);
/*
* Get Potenciometer Value
*/
void get_potval (void) {
uint32_t val;
LPC_ADC->ADCR |= 0x01000000; /* Start A/D Conversion */
do {
val = LPC_ADC->ADGDR; /* Read A/D Data Register */
} while ((val & 0x80000000) == 0); /* Wait for end of A/D Conversion */
LPC_ADC->ADCR &= ~0x01000000; /* Stop A/D Conversion */
PotVal = ((val >> 8) & 0xF8) + /* Extract Potenciometer Value */
((val >> 7) & 0x08);
}
/**************************************************************************
* Timer Counter 0 Interrupt Service Routine
* executed each 31.25us (32kHz frequency)
*************************************************************************/
void TIMER0_IRQHandler(void)
{
long val;
uint32_t cnt;
if (DataRun) { /* Data Stream is running */
val = DataBuf[DataOut]; /* Get Audio Sample */
cnt = (DataIn - DataOut) & (B_S - 1); /* Buffer Data Count */
if (cnt == (B_S - P_C*P_S)) { /* Too much Data in Buffer */
DataOut++; /* Skip one Sample */
}
if (cnt > (P_C*P_S)) { /* Still enough Data in Buffer */
DataOut++; /* Update Data Out Index */
10. }
DataOut &= B_S - 1; /* Adjust Buffer Out Index */
if (val < 0) VUM -= val; /* Accumulate Neg Value */
else VUM += val; /* Accumulate Pos Value */
val *= Volume; /* Apply Volume Level */
val >>= 16; /* Adjust Value */
val += 0x8000; /* Add Bias */
val &= 0xFFFF; /* Mask Value */
} else {
val = 0x8000; /* DAC Middle Point */
}
if (Mute) {
val = 0x8000; /* DAC Middle Point */
}
LPC_DAC->DACR = val & 0xFFC0; /* Set Speaker Output */
val_temp = val&0xffc0;
////////////////////////////////////////////////////////////////////////
if(FFTcount<FFT_N)
{
val_temp=val&0xFFC0;
val_temp=val_temp>>6;
strcpy(valdisp,"H: L: @32kHz");
Hex_Str((unsigned char)(val_temp&0x00ff), &valdisp[9]);
Hex_Str((unsigned char)(val_temp>>8), &valdisp[2]);
s[FFTcount].real= (float)(val_temp)/1024*240;
s[FFTcount].imag=0;
FFTcount++;
}
////////////////////////////////////////////////////////////////////////
if ((Tick++ & 0x03FF) == 0) { /* On every 1024th Tick */
get_potval(); /* Get Potenciometer Value */
if (VolCur == 0x8000) { /* Check for Minimum Level */
Volume = 0; /* No Sound */
} else {
11. Volume = VolCur * PotVal; /* Chained Volume Level */
}
val = VUM >> 20; /* Scale Accumulated Value */
VUM = 0; /* Clear VUM */
if (val > 7) val = 7; /* Limit Value */
}
counter++;
LPC_TIM0->IR = 1; /* Clear Interrupt Flag */
// NVIC_EnableIRQ(TIMER1_IRQn);
}
/**************************************************************************
***
* Timer Counter 1 Interrupt Service Routine
* executed each 31.25us (32kHz frequency)
***************************************************************************
***/
void TIMER1_IRQHandler(void)
{
int i;
//NVIC_DisableIRQ(TIMER0_IRQn);
GLCD_SetBackColor(Black);
GLCD_SetTextColor(Green);
GLCD_DisplayString(0, 0, " ");
GLCD_DisplayString(0, 0, (uint8_t*)valdisp);
FFT(s);
for(i=0;i<FFT_N;i++)
{
GLCD_SetTextColor(Black);
CRIS_draw_line(8*i, 239, 8*i , 19); //plot on LCD
CRIS_draw_line(8*i+1, 239, 8*i+1 , 19); //plot on LCD
CRIS_draw_line(8*i+2, 239, 8*i+2 , 19); //plot on LCD
GLCD_SetTextColor(Green);
CRIS_draw_line(8*i , 239, 8*i , 239-floor(s[i].real)); //plot on LCD
CRIS_draw_line(8*i+1, 239, 8*i+1 , 239-floor(s[i].real)); //plot on LCD
