• AVR
• микроконтр
• Система
• Архитектура
• ATmega128
• 7/16-битный

Сравнение микроконтроллеров семейства MSP430 с конкурентоспособными микроконтроллерами

Резюме

В данном примере применения приведены результаты сравнения микроконтроллеров семейства MSP430 с микроконтроллерами других производителей. Для разработки кода различных простейших операций и выполнения его в режиме симулятора была использована платформа разработчика Embedded Workbench™ компании IAR Systems. Для выяснения различных параметров микроконтроллеров эти различные часто используемые приложения были выполнены на каждом микроконтроллере. Для всех рассмотренных применений были посчитаны суммарные размер кода программы и количество командных циклов, требуемых для выполнения. На рисунке 1 и рисунке 2 приведены диаграммы сравнения размеров кодов программ и количество командных циклов для каждого исследованного микроконтроллера.

Рисунок 1. Диаграмма сравнения суммарных размера кодов программ

Рисунок 2. Диаграмма сравнения суммарного количества командных циклов

В таблице 1 приведены коэффициенты деления частоты задающего генератора для формирования сигналов синхронизации вычислительного ядра исследованных микроконтроллеров. Полное время выполнения любого кода можно рассчитать как произведение количества командных циклов и коэффициента деления.

Таблица 1. Коэффициенты деления частоты задающего генератора для формирования сигналов синхронизации вычислительного ядра

В таблице 2 показаны суммарные размер кода и количество командных циклов, приведенные к соответствующим суммарным размеру кода и количеству циклов микроконтроллера MSP430.

Таблица. 2. Приведенные результаты

Таблица 3 содержит размеры кодов программ (в байтах) и количества командных циклов исследованных прикладных программ для каждого микроконтроллера.

Таблица 3. Размер кодов и количество командных циклов

Влияние аппаратного умножителя и полной оптимизации компилятора

Для того, чтобы показать влияние аппаратного умножителя и полной оптимизации компилятора MSP430, было произведено сравнение кодов применений для MSP430F135 и MSP430F149. MSP430F149 содержит аппаратный умножитель, а MSP430F135 - нет. Для создания и выполнения исследуемых приложений был использован последний С компилятор версии 3.10A компании IAR для микроконтроллеров семейства MSP430. В таблице 4 приведены результаты тестов.

Таблица 4. Влияние аппаратного умножителя и полной оптимизации компилятора

Приложение

Тестовые прикладные задачи

Для сравнения параметров различных микроконтроллеров для каждого из них в режиме симуляции были выполнены приведенные ниже тестовые прикладные задачи. Исходные тексты программ этих прикладных задач приведен ниже.

8-bit_math.c - исходный файл, содержащий три математических функции. Одна функция выполняет сложение двух 8- битных чисел, одна выполняет умножение и одна - деление. Вызов этих функций осуществляется из функции "main()".

16-bit_math.c - исходный файл, содержащий три математических функции. Одна функция выполняет сложение двух 16- битных чисел, одна выполняет умножение и одна - деление. Вызов этих функций осуществляется из функции "main()".

32-bit_math.c - исходный файл, содержащий три математических функции. Одна функция выполняет сложение двух 32- битных чисел, одна выполняет умножение и одна - деление. Вызов этих функций осуществляется из функции "main()".

floating_point_math.c - исходный файл, содержащий три математических функции. Одна функция выполняет сложение двух чисел с плавающей запятой, одна выполняет умножение и одна - деление. Вызов этих функций осуществляется из функции "main()".

8-bit_switch_case.c - исходный файл с одной функцией, содержащей инструкцию коммутатора, имеющего 16 вариантов выбора. В зависимости от 8- битного значения выбирается один из вариантов выбора. Функция "main()" вызывает функцию "switch" с выбранным входным параметром.

16-bit_switch_case.c - исходный файл с одной функцией, содержащей инструкцию коммутатора, имеющего 16 вариантов выбора. В зависимости от 16- битного значения выбирается один из вариантов выбора. Функция "main()" вызывает функцию "switch" с выбранным входным параметром.

8-bit_2-dim_matrix.c - исходный файл, содержащий 3 двумерных массива 8- битных значений, один из которых инициализирован. Функция "main()" копирует первый массив во второй, а потом второй - в третий.

16-bit_2-dim_matrix.c - исходный файл, содержащий 3 двумерных массива 16- битных значений, один из которых инициализирован. Функция "main()" копирует первый массив во второй, а потом второй - в третий.

fir_filter.c - исходный файл, содержащий код, который вычисляет ответ на выходе фильтра 17- ого от имитированного входного воздействия АЦП.

matrix_multiplication.c - исходный файл, содержащий код, который перемножает матрицу 3x4 и матрицу 4x5.

Компилятор

Для формирования тестовых прикладных задач использовался "С" компилятор, встроенный в интегрированную среду разработки (IDE) Embedded Workbench компании IAR Systems. Демонстрационные версии IDE для всех микроконтроллеров были получены на сайте компании IAR Systems по адресу http://www.iar.com. В таблице 5 приведены версии программы, использованные для разработки прикладных задач для каждого конкретного микроконтроллера. Для каждого прикладного решения был посчитан размер программы. Все прикладные задачи были сформированы при установленном значении оптимизатора компилятора "none". Это было сделано для того, чтобы исключить влияние оптимизатора компилятора на результаты тестов. Например, при включенном оптимизаторе компилятор для микроконтроллеров семейства 8051 был способен вычислить результаты для некоторых математических функций во время компиляции. Алгоритм оптимизации был настолько сложен, что способен был определить, что входные значения математических не изменяются. Это позволило компилятору вычислить математическую функцию и заменить ее результатом вычисления.

Все прикладные задачи были выполнены в режиме симуляции. При этом регистрировалось количество команд, требуемых для выполнения каждой прикладной задачи.

Таблица 5. Использованные версии "С" компилятора

Исходные тексты тестовых прикладных задач

Ниже приведены исходные тексты на "С" тестовых прикладных задач, использованных для тестирования, описанного в данном документе.

8-bit Math.c

/*******************************************************************************
*
* Имя: 8-bit Math
* Назначение: тестовая прикладная задача 8- битных математических функций.
*
*******************************************************************************/
typedef unsigned char UInt8;
UInt8 add(UInt8 a, UInt8 b)
{
	return (a + b);
}
UInt8 mul(UInt8 a, UInt8 b)
{
	return (a * b);
}
UInt8 div(UInt8 a, UInt8 b)
{
	return (a / b);
}
void main(void)
{
	volatile UInt8 result[4];
	result[0] = 12;
	result[1] = 3;
	result[2] = add(result[0], result[1]);
	result[1] = mul(result[0], result[2]);
	result[3] = div(result[1], result[2]);
	return;
}

8-bit 2-dim Matrix.c

/*******************************************************************************
*
* Имя: 8-bit 2-dim Matrix
* Назначение: тестовая прикладная программа копирования 8- битных значений.
*
*******************************************************************************/
typedef unsigned char UInt8;
const UInt8 m1[16][4] = {
	{0x12, 0x56, 0x90, 0x34},
	{0x78, 0x12, 0x56, 0x90},
	{0x34, 0x78, 0x12, 0x56},
	{0x90, 0x34, 0x78, 0x12},
	{0x12, 0x56, 0x90, 0x34},
	{0x78, 0x12, 0x56, 0x90},
	{0x34, 0x78, 0x12, 0x56},
	{0x90, 0x34, 0x78, 0x12},
	{0x12, 0x56, 0x90, 0x34},
	{0x78, 0x12, 0x56, 0x90},
	{0x34, 0x78, 0x12, 0x56},
	{0x90, 0x34, 0x78, 0x12},
	{0x12, 0x56, 0x90, 0x34},
	{0x78, 0x12, 0x56, 0x90},
	{0x34, 0x78, 0x12, 0x56},
	{0x90, 0x34, 0x78, 0x12}
};
void main (void)
{
	int i, j;
	volatile UInt8 m2[16][4], m3[16][4];
	for(i = 0; i < 16; i++)
	{
		for(j=0; j < 4; j++)
		{
			m2[i][j] = m1[i][j];
			m3[i][j] = m2[i][j];
		}
	}
	return;
}

8-bit Switch Case.c

/*******************************************************************************
*
* Имя: 8-bit Switch Case
* Назначение: Тестовая прикладная задача, осуществляющая коммутацию по
* полученному 8- битному значению.
*
*******************************************************************************/
typedef unsigned char UInt8;
UInt8 switch_case(UInt8 a)
{
	UInt8 output;
	switch (a)
	{
		case 0x01:
		output = 0x01;
		break;
		case 0x02:
		output = 0x02;
		break;
		case 0x03:
		output = 0x03;
		break;
		case 0x04:
		output = 0x04;
		break;
		case 0x05:
		output = 0x05;
		break;
		case 0x06:
		output = 0x06;
		break;
		case 0x07:
		output = 0x07;
		break;
		case 0x08:
		output = 0x08;
		break;
		case 0x09:
		output = 0x09;
		break;
		case 0x0a:
		output = 0x0a;
		break;
		case 0x0b:
		output = 0x0b;
		break;
		case 0x0c:
		output = 0x0c;
		break;
		case 0x0d:
		output = 0x0d;
		break;
		case 0x0e:
		output = 0x0e;
		break;
		case 0x0f:
		output = 0x0f;
		break;
		case 0x10:
		output = 0x10;
		break;
		} /* конец коммутации*/
	return (output);
}
void main(void)
{
	volatile UInt8 result;
	result = switch_case(0x10);
	return;
}

16-bit Math.c

/*******************************************************************************
*
* Имя: 16-bit Math
* Назначение: Тестовая прикладная задача, осуществляющая вычисление 
* 16- битных математических функций.
*
*******************************************************************************/
typedef unsigned short UInt16;
UInt16 add(UInt16 a, UInt16 b)
{
	return (a + b);
}
UInt16 mul(UInt16 a, UInt16 b)
{
	return (a * b);
}
UInt16 div(UInt16 a, UInt16 b)
{
	return (a / b);
}
void main(void)
{
	volatile UInt16 result[4];
	result[0] = 231;
	result[1] = 12;
	result[2] = add(result[0], result[1]);
	result[1] = mul(result[0], result[2]);
	result[3] = div(result[1], result[2]);
	return;
}

16-bit 2-dim Matrix.c

/*******************************************************************************
*
* Имя: 16-bit 2-dim Matrix
* Назначение: Тестовая прикладная задача копирования 16- битных значений.
*
*******************************************************************************/
typedef unsigned short UInt16;
const UInt16 m1[16][4] = {
	{0x1234, 0x5678, 0x9012, 0x3456},
	{0x7890, 0x1234, 0x5678, 0x9012},
	{0x3456, 0x7890, 0x1234, 0x5678},
	{0x9012, 0x3456, 0x7890, 0x1234},
	{0x1234, 0x5678, 0x9012, 0x3456},
	{0x7890, 0x1234, 0x5678, 0x9012},
	{0x3456, 0x7890, 0x1234, 0x5678},
	{0x9012, 0x3456, 0x7890, 0x1234},
	{0x1234, 0x5678, 0x9012, 0x3456},
	{0x7890, 0x1234, 0x5678, 0x9012},
	{0x3456, 0x7890, 0x1234, 0x5678},
	{0x9012, 0x3456, 0x7890, 0x1234},
	{0x1234, 0x5678, 0x9012, 0x3456},
	{0x7890, 0x1234, 0x5678, 0x9012},
	{0x3456, 0x7890, 0x1234, 0x5678},
	{0x9012, 0x3456, 0x7890, 0x1234}
};
void main(void)
{
	int i, j;
	volatile UInt16 m2[16][4], m3[16][4];
	for(i = 0; i < 16; i++)
	{
		for(j = 0; j < 4; j++)
		{
		m2[i][j] = m1[i][j];
		m3[i][j] = m2[i][j];
		}
	}
	return;
}

16-bit Switch Case.c

/*******************************************************************************
*
* Имя: 16-bit Switch Case
* Назначение: Тестовая прикладная задача, осуществляющая коммутацию 
* по полученному 16- битному значению.
*
*******************************************************************************/
typedef unsigned short UInt16;
UInt16 switch_case(UInt16 a)
{
	UInt16 output;
	switch (a)
	{
		case 0x0001:
		output = 0x0001;
		break;
		case 0x0002:
		output = 0x0002;
		break;
		case 0x0003:
		output = 0x0003;
		break;
		case 0x0004:
		output = 0x0004;
		break;
		case 0x0005:
		output = 0x0005;
		break;
		case 0x0006:
		output = 0x0006;
		break;
		case 0x0007:
		output = 0x0007;
		break;
		case 0x0008:
		output = 0x0008;
		break;
		case 0x0009:
		output = 0x0009;
		break;
		case 0x000a:
		output = 0x000a;
		break;
		case 0x000b:
		output = 0x000b;
		break;
		case 0x000c:
		output = 0x000c;
		break;
		case 0x000d:
		output = 0x000d;
		break;
		case 0x000e:
		output = 0x000e;
		break;
		case 0x000f:
		output = 0x000f;
		break;
		case 0x0010:
		output = 0x0010;
		break;
	} /* конец коммутации*/
	return (output);
}
void main(void)
{
	volatile UInt16 result;
	result = switch_case(0x0010);
	return;
}

32-bit Math.c

/*******************************************************************************
*
* Имя: 32-bit Math
* Назначение: Тестовая прикладная задача вычисления
* 32- битных математических функций.
*
*******************************************************************************/
#include 
typedef unsigned long UInt32;
UInt32 add(UInt32 a, UInt32 b)
{
	return (a + b);
}
UInt32 mul(UInt32 a, UInt32 b)
{
	return (a * b);
}
UInt32 div(UInt32 a, UInt32 b)
{
	return (a / b);
}
void main(void)
{
	volatile UInt32 result[4];
	result[0] = 43125;
	result[1] = 14567;
	result[2] = add(result[0], result[1]);
	result[1] = mul(result[0], result[2]);
	result[3] = div(result[1], result[2]);
	return;
}

Floating-point Math.c

/*******************************************************************************
*
* Имя : Floating-point Math
* Назначение: Тестовая прикладная задача выполнения математических функций с плавающей запятой.
*
*******************************************************************************/
float add(float a, float b)
{
	return (a + b);
}
float mul(float a, float b)
{
	return (a * b);
}
float div(float a, float b)
{
	return (a / b);
}
void main(void)
{
	volatile float result[4];
	result[0] = 54.567;
	result[1] = 14346.67;
	result[2] = add(result[0], result[1]);
	result[1] = mul(result[0], result[2]);
	result[3] = div(result[1], result[2]);
	return;
}

FIR Filter.c

/*******************************************************************************
*
* Имя : FIR Filter
* Назначение: Тестовая прикладная задача фильтра с КИХ. Входным значением для
* фильтра является массив из 51 16-битного значения. Фильтр имеет 17-ый порядок
*
*******************************************************************************/
#ifdef MSP430
#include "msp430x13x.h"
#endif
#include 
#define FIR_LENGTH 17
const float COEFF[FIR_LENGTH] =
{
	-0.000091552734,
	0.000305175781,
	0.004608154297,
	0.003356933594,
	-0.025939941406,
	-0.044006347656,
	0.063079833984,
	0.290313720703,
	0.416748046875,
	0.290313720703,
	0.063079833984,
	-0.044006347656,
	-0.025939941406,
	0.003356933594,
	0.004608154297,
	0.000305175781,
	-0.000091552734
};
/* Текущий массив симулирует входные значения от АЦП */
const unsigned int INPUT[] =
{
	0x0400, 0x0800, 0x0C00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000,
	0x2400, 0x2000, 0x1C00, 0x1800, 0x1400, 0x1000, 0x0C00, 0x0800,
	0x0400, 0x0400, 0x0800, 0x0C00, 0x1000, 0x1400, 0x1800, 0x1C00,
	0x2000, 0x2400, 0x2000, 0x1C00, 0x1800, 0x1400, 0x1000, 0x0C00,
	0x0800, 0x0400, 0x0400, 0x0800, 0x0C00, 0x1000, 0x1400, 0x1800,
	0x1C00, 0x2000, 0x2400, 0x2000, 0x1C00, 0x1800, 0x1400, 0x1000,
	0x0C00, 0x0800, 0x0400
};
void main(void)
{
	int i, y; /* Счетчик циклов*/
	volatile float OUTPUT[36];
	#ifdef MSP430
	WDTCTL = WDTPW + WDTHOLD; /* Остановка сторожевого таймера */
	#endif
	for(y = 0; y < 36; y++)
	{
		for(i = 0; i < FIR_LENGTH/2; i++)
		{
			OUTPUT[y] = COEFF[i] * ( INPUT[y + 16 - i] + INPUT[y + i] );
		};
		OUTPUT[y] = OUTPUT[y] + ( INPUT[y + 16 - i] * COEFF[i] );
	}
	return;
}

Matrix Multiplication.c

/*******************************************************************************
*
* Имя: Matrix Multiplication
* Назначение: Тестовая прикладная программа перемножения матриц 3x4 и 4x5.
* матрицы содержат 16- битные значения.
*
*******************************************************************************/
typedef unsigned short UInt16;
const UInt16 m1[3][4] = {
	{0x01, 0x02, 0x03, 0x04},
	{0x05, 0x06, 0x07, 0x08},
	{0x09, 0x0A, 0x0B, 0x0C}
};
const UInt16 m2[4][5] = {
	{0x01, 0x02, 0x03, 0x04, 0x05},
	{0x06, 0x07, 0x08, 0x09, 0x0A},
	{0x0B, 0x0C, 0x0D, 0x0E, 0x0F},
	{0x10, 0x11, 0x12, 0x13, 0x14}
};
void main(void)
{
	int m, n, p;
	volatile UInt16 m3[3][5];
	for(m = 0; m < 3; m++)
	{
		for(p = 0; p < 5; p++)
		{
			m3[m][p] = 0;
			for(n = 0; n < 4; n++)
			{
				m3[m][p] += m1[m][n] * m2[n][p];
			}
		}
	}
	return;
}
/*******************************************************************************
*******************************************************************************/