Отладочные платы от Texas Instruments

MSP430G2 Value Line LaunchPad: $9.99

Первая плата, о которой хочу рассказать MSP430G2. С момента выхода она стала уже довольно популярной. Сейчас, к сожалению цена на неё возросла почти в 2 раза и составляет $9.99.

Основные характеристики микроконтроллеров:

MSP430G2553

16-разрядный ЦПУ, макс. частота 16 МГц, 16 кБ Flash, 512B RAM, 16 GPIO, 2 16-битных таймера, I2C, SPI, UART, 8 10-битных АЦП каналов

MSP430G2452

16-разрядный ЦПУ, макс. частота 16 МГц, 8 кБ Flash, 256B RAM, 16 GPIO, 1 16-битный таймер, I2C, SPI, 8 10-битных АЦП каналов

Внешний вид коробки:


Комплектация:
— Сама плата MSP430G2 c установленным микроконтроллером MSP430G2553;
— Микроконтроллер MSP430G2452;
— Кварц 32768 Гц;
— Кабель miniUSB;
— краткая инструкция;
— два 10-пинового PCB разъёма для крепления лаунчпада к своей плате.

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


Пайка кварца особого труда не составляет при условии хорошего паяльника и флюса. Примеров пайки в просторах интернета полно, вот один из них:


Теперь самое интересное, это написать свой первый «Hello World», а именно поморгать светодиодом, находящимся на плате. Самый простой способ через Energia. Всё, что для этого нужно, скачать саму программу, распаковать и запустить файл energia.exe.
В программе достаточно выбрать нашу плату (LaunchPad) и микроконтроллер (MSP430G2553)

и написать простенькую программку:

/*****************************************/
//Эта функция выполняется при запуске МК
void setup() {
//Указываем, что пин светодиода — это выход
pinMode(RED_LED, OUTPUT);
}
//Основная функция, которая будет вызываться каждый раз,
//пока микроконтроллер работает
void loop() {
//Зажигаем светодиод
digitalWrite(RED_LED, HIGH);
//Ждём 1000 мс, т.е. 1 секунду
delay(1000);
//гасим светодиод
digitalWrite(RED_LED, LOW);
//Ждём 1 секунду
delay(1000);
}
/*****************************************/

После чего нажать на изображение стрелочки в левом верхнем углу, дождаться окончания загрузки и наслаждаться моргающим светодиодом.

Есть способ поморгать светодиодом посложнее, но зато пощупать контроллер более детально. Для этого можно использовать среды разработки, предлагаемые Texas Instruments IAR или CCS.
Скачать CSS можно отсюда, а IAR отсюда.
Для загрузки необходимо зарегистрироваться на сайте TI и заполнить анкетку. У каждой из программ есть свои небольшие ограничения, которые при любительском использовании вряд ли будут заметны. Ну а если всё же столкнётесь с ними, то всегда на помощь придут торренты с необходимым набором лекарственных средств для лечения этого недуга.

Мне больше понравилась IAR, т.к. программа не требовательная к системным ресурсам, как CCS, но в остальном дело вкуса.
Не знаю, нужно ли расписывать подробно процесс программирования в IAR, тем более примеров очень много и все прекрасно гуглятся, приведу лишь пример кода для моргания светодиодом.

/*****************************************/
//Загружаем описание нашего микроконтроллера
#include «io430.h»
//номер пина, к которому подключен красный светодиод
// в лаунчпаде это первый пин, который является нулевым битом
#define LEDPIN BIT0

int main( void ) {
WDTCTL = WDTPW + WDTHOLD; //отключаем сторожевой таймер

//устанавливаем внутренний генератор
//на частоту 1 МГц, можно конечно и 16,
//но для обычного моргания нам одного за глаза хватит.
DCOCTL = CALDCO_1MHZ;
BCSCTL1 = CALBC1_1MHZ;
P1DIR |= LEDPIN; //Говорим, что наш пин — это выход
//Бесконечный цикл
while(1) {
//Меняем бит светодиода на противоположный
P1OUT ^= LEDPIN;
//Задержка в 1 миллион циклов, при скорости процессора 1 Мгц
//получаем 1 секунду
__delay_cycles(1e6);
}
}
/*****************************************/

Ну и получаем результат:


Всё это интересно, но насколько быстро можно чередовать 1 и 0 на выходе? Что бы это узнать, я немного подправил программу:
Для Energia

/*****************************************/
void setup() {
pinMode(RED_LED, OUTPUT);
}

void loop() {
digitalWrite(RED_LED, HIGH);
digitalWrite(RED_LED, LOW);
}
/*****************************************/

И вот результат на выходе:

Время на смену состояния выхода: ~4 мкс
На следующий вызов функции loop: ~1мкс

Для IAR:

/*****************************************/
#include «io430.h»

#define LEDPIN BIT0

int main( void ) {
WDTCTL = WDTPW + WDTHOLD;
//устанавливаем внутренний генератор на максимальную частоту 16 МГц
DCOCTL = CALDCO_16MHZ;
BCSCTL1 = CALBC1_16MHZ;
P1DIR |= LEDPIN;
P1OUT = 0;
while(1) {
//зажигаем светодиод
P1OUT = LEDPIN;
//гасим светодиод
P1OUT = 0;
}
}
/*****************************************/

На выходе получаем:

Время на смену состояния выхода порядка 250 нс и время на переход от конца цикла в начало 250 нс.

Как видно, удобство сильно сказывается на скорости, но в большинстве случаев такая скорость вовсе и не нужна, да и при желании в той же energia можно применять низкоуровневое программирование. Если есть интерес, можно посмотреть, как реализованы все функции, для этого достаточно открыть папку

energia-0101E0009\hardware\msp430\cores\msp430

К примеру, в файле wiring_digital.c можно посмотреть, как реализована функция digitalWrite и сразу станет понятно, куда уходит столько времени на её выполнение.

Можно так же посмотреть, как быстро плата реагирует на нажатие кнопки, для этого напишем в IAR следующую программу:

#include «io430.h»

#define LEDPIN BIT0
#define BUTTON BIT3

int main( void )
{
//Отключаем сторожевой таймер
WDTCTL = WDTPW + WDTHOLD;
//Ставим максимальную частоту процессора
DCOCTL = CALDCO_16MHZ;
BCSCTL1 = CALBC1_16MHZ;
//Указываем, что пин со светодиодом — это выход
P1DIR |= LEDPIN;
//Указываем, что пин с кнопкой — это вход
P1DIR &= ~BUTTON;
//Включаем внутренний резистор подтяжки для кнопки
P1REN |= BUTTON;
//Подтягиваем резистором к плюсу, т.к. наша кнопка сажает пин на землю
P1OUT |= BUTTON;
//Гасим светодиод
P1OUT &= ~LEDPIN;
//Устанавливаем прерывание по заднему фронту, т.к. при нажатии уровень
//изменится с 1 до 0
P1IES |= BUTTON;
//Сбрасываем флаг прерывания
P1IFG &= ~BUTTON;
//Разрешаем прерывание для кнопки
P1IE |= BUTTON;
//Разрешаем глобальные прерывания
__bis_SR_register(__SR_GIE);
//Можно усыпить контроллер до тех пор, пока не нажата кнопка,
//но на его пробуждение понадобится некое время, поэтому пусть ждёт так
//__low_power_mode_4();
//Бесконечный цикли
while(1) {
}
}

//Это функция обработки прерывания по нажатию нашей кнопки
#pragma vector=PORT1_VECTOR
__interrupt void onP1ISR(void) {
//Запрещаем прерывания для кнопки, что бы пока функция не отработала,
//ещё раз она не вызывалась
P1IE &= ~BUTTON;
//Сбрасываем флаг прерывания
P1IFG &= ~BUTTON;
//Зажигаем светодиод
P1OUT |= LEDPIN;
//разрешаем прерывания для кнопки
P1IE |= BUTTON;
}

И результат:

Голубой график — это нажатие кнопки. При нажатии мы сажаем подтянутый резистором верхний уровень на землю. Синий график — это наш светодиод.
Как видно из графиков, время от нажатия кнопки до загорания светодиода — 1,2 мкс.
Если же процессор усыпить (раскомментировав строчку __low_power_mode_4()), получим следующее:

Время реакции увеличилось до 1,6 мкс.
~400нс требуется на пробуждение нашего сони.

В общем плата действительно очень интересная, а вся интересующая информация легко гуглится в том числе и на русском языке.

Информация:
MSP-EXP430G2 User's Guide (En)
MSP430G2553 Datasheet (En)
MSP430G2452 Datasheet (En)
Уроки по MSP430 (Рус)
Подборка с MSP430 (Рус)
Книга «Семейство микроконтроллеров MSP430х2хх» (Рус)

C2000 Piccolo LaunchPad: $17.05


Следующая плата C2000 Piccolo на базе микроконтроллера TMS320F28027.
Данный микроконтроллер оптимизирован для выполнения задач в режиме реального времени.


Основные характеристики:

— 32-разрядный ЦПУ;
— Частота до 60 МГц;
— 20 GPIO;
— 12-битный АЦП 7 каналов;
— 8 каналов ШИМ;
— I2C, SPI, UART
— 3 32-битных таймера;
— 64 KB Flash;
— 12 KB RAM.

Внешний вид коробки:


Внутри сама плата, мини UBS шнурок и инструкция.




В плане программирования, тут дела обстоят посложнее, для IAR ничего нет, в Energia пока окончательно не реализована поддержка этой платы, но они приглашают поучаствовать в тестировании. Так что придётся скачать и установить Code Composer Studio и controlSUITE.
После установки можно посмотреть примеры работы с этой платой, которые лежат в папке:

C:\ti\controlSUITE\development_kits\C2000_LaunchPad\f2802x_examples

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

C:\ti\controlSUITE\development_kits\C2000_LaunchPad\f2802x_common\source

Так как настроек проекта там тьма тьмущая, проще взять готовый из примеров и доработать под себя.
К примеру, поморгаем всеми четырьмя нашими светодиодами:

#include «DSP28x_Project.h»

#include «f2802x_common/include/clk.h»
#include «f2802x_common/include/gpio.h»
#include «f2802x_common/include/pie.h»
#include «f2802x_common/include/pll.h»
#include «f2802x_common/include/wdog.h»

void main()
{
CLK_Handle myClk;
GPIO_Handle myGpio;
PIE_Handle myPie;
CPU_Handle myCpu;
PLL_Handle myPll;
WDOG_Handle myWDog;

//Инициализируем наши переменные
//Функции часов
myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
//Процессор
myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
//Входы/выходы
myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
//прерывания
myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
//Фазовая автоподстройка частоты
myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
//сторожевой таймер
myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

// Отключаем сторожевой таймер
WDOG_disable(myWDog);

//Частота будет браться в внутреннего генератора
CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
// Устанавливаем плл на 60МГц. 10Мг(внетренний генератор) * 12 / 2 = 60
PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);
// Сбрасываем все прерывания
PIE_disable(myPie);
PIE_disableAllInts(myPie);
CPU_disableGlobalInts(myCpu);
CPU_clearIntFlags(myCpu);
// Если программа на флэше, переписываем её в RAM
#ifdef _FLASH
memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

// Настраиваем наши выходы
//Выходы с 0 по 3 будут выполнять свою главную роль — дискретные входы/выходы
GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
GPIO_setMode(myGpio, GPIO_Number_1, GPIO_0_Mode_GeneralPurpose);
GPIO_setMode(myGpio, GPIO_Number_2, GPIO_0_Mode_GeneralPurpose);
GPIO_setMode(myGpio, GPIO_Number_3, GPIO_0_Mode_GeneralPurpose);

//Наши пины — это выходы
GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);
GPIO_setDirection(myGpio, GPIO_Number_1, GPIO_Direction_Output);
GPIO_setDirection(myGpio, GPIO_Number_2, GPIO_Direction_Output);
GPIO_setDirection(myGpio, GPIO_Number_3, GPIO_Direction_Output);

//Бесконечный цикл
while(1) {
//Светодиод загорается от 0 и гаснет от 1, поэтому подаём low, что бы зажечь, и high, что бы погасить
GPIO_setHigh(myGpio, GPIO_Number_0);
GPIO_setHigh(myGpio, GPIO_Number_1);
GPIO_setHigh(myGpio, GPIO_Number_2);
GPIO_setLow(myGpio, GPIO_Number_3);
//Ждём 1млн мксекунд. т.е 1 секунду
DELAY_US(1E6);

GPIO_setHigh(myGpio, GPIO_Number_0);
GPIO_setHigh(myGpio, GPIO_Number_1);
GPIO_setLow(myGpio, GPIO_Number_2);
GPIO_setHigh(myGpio, GPIO_Number_3);

DELAY_US(1E6);

GPIO_setHigh(myGpio, GPIO_Number_0);
GPIO_setLow(myGpio, GPIO_Number_1);
GPIO_setHigh(myGpio, GPIO_Number_2);
GPIO_setHigh(myGpio, GPIO_Number_3);

DELAY_US(1E6);

GPIO_setLow(myGpio, GPIO_Number_0);
GPIO_setHigh(myGpio, GPIO_Number_1);
GPIO_setHigh(myGpio, GPIO_Number_2);
GPIO_setHigh(myGpio, GPIO_Number_3);

DELAY_US(1E6);

}
}

И получаем:


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

C:\ti\controlSUITE\development_kits\C2000_LaunchPad\f2802x_common\source\gpio.c

и посмотрим, что можно выкинуть из функций GPIO_setHigh и GPIO_setLow

…
void GPIO_setHigh(GPIO_Handle gpioHandle, const GPIO_Number_e gpioNumber)
{
GPIO_Obj *gpio = (GPIO_Obj *)gpioHandle;

ENABLE_PROTECTED_REGISTER_WRITE_MODE;

if(gpioNumber < GPIO_Number_32)
{
gpio->GPASET = (uint32_t)1 << gpioNumber;
}
else
{
gpio->GPBSET = (uint32_t)1 << (gpioNumber — GPIO_Number_32);
}

DISABLE_PROTECTED_REGISTER_WRITE_MODE;

return;
} // end of GPIO_setHigh() function

void GPIO_setLow(GPIO_Handle gpioHandle, const GPIO_Number_e gpioNumber)
{
GPIO_Obj *gpio = (GPIO_Obj *)gpioHandle;

ENABLE_PROTECTED_REGISTER_WRITE_MODE;

if(gpioNumber < GPIO_Number_32)
{
gpio->GPACLEAR = (uint32_t)1 << gpioNumber;
}
else
{
gpio->GPBCLEAR = (uint32_t)1 << (gpioNumber — GPIO_Number_32);
}

DISABLE_PROTECTED_REGISTER_WRITE_MODE;

return;
} // end of GPIO_setLow() function
...

После чистки, получаем следующее:

#include «DSP28x_Project.h»

#include «f2802x_common/include/clk.h»
#include «f2802x_common/include/gpio.h»
#include «f2802x_common/include/pie.h»
#include «f2802x_common/include/pll.h»
#include «f2802x_common/include/wdog.h»

void main()
{
CLK_Handle myClk;
GPIO_Handle myGpio;
PIE_Handle myPie;
CPU_Handle myCpu;
PLL_Handle myPll;
WDOG_Handle myWDog;

//Инициализируем наши переменные
//Функции часов
myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
//Процессор
myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
//Входы/выходы
myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
//прерывания
myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
//Фазовая автоподстройка частоты
myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
//сторожевой таймер
myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

// Отключаем сторожевой таймер
WDOG_disable(myWDog);

//Частота будет браться в внутреннего генератора
CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
// Устанавливаем плл на 60МГц. 10Мг(внутренний генератор) * 12 / 2 = 60
PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);
// Сбрасываем все прерывания
PIE_disable(myPie);
PIE_disableAllInts(myPie);
CPU_disableGlobalInts(myCpu);
CPU_clearIntFlags(myCpu);
// Если программа на флэше, переписываем её в RAM
#ifdef _FLASH
memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

GPIO_Obj *gpio = (GPIO_Obj *)myGpio;

//разрешаем управление портами
EALLOW;
//Все порты делаю входами/выходами, что б не болтались без дела
gpio->GPAMUX1 = (uint16_t)0;
gpio->GPAMUX2 = (uint16_t)0;
gpio->GPBMUX1 = (uint16_t)0;

//Все порты делаю выходами
gpio->GPADIR = (uint16_t)0xFFFF;
gpio->GPBDIR = (uint16_t)0xFFFF;

//Сбросим все выходы
gpio->GPADAT = (uint16_t)0;
gpio->GPBDAT = (uint16_t)0;
//Конец работы с портами
EDIS;

//Бесконечный цикл
while(1) {
//разрешаем управление портами, без него порты будут работать криво,
//поэтому перед управлением разрешили, а после закрыли
EALLOW;
//устанавливаю 1 в GPIO 0
gpio->GPASET = (uint32_t)1;
//Завершаю управление портами
EDIS;
//Начинаю управление портами
EALLOW;
//Сбрасываю GPIO 0 в ноль
gpio->GPACLEAR = (uint32_t)1;
//Завершаю управление портами
EDIS;
}
}

Как видно, время на смену состояния 500нс. А вот переход из конца цикла в начало около 600нс.
Можно снизить время смены состояния до 30нс, если убрать EALLOW и EDIS, но при частом использовании он может работать нестабильно.
Для примера, я изменил код:

…
while(1) {
gpio->GPASET = (uint32_t)1;
gpio->GPACLEAR = (uint32_t)1;
gpio->GPASET = (uint32_t)1;
gpio->GPACLEAR = (uint32_t)1;

}
...

И вот, что получил:


Ну и как же не посмотреть на время реакции от начала нажатия на кнопку, до зажигания светодиода
Вот код:

#include «DSP28x_Project.h»

#include «f2802x_common/include/clk.h»
#include «f2802x_common/include/gpio.h»
#include «f2802x_common/include/pie.h»
#include «f2802x_common/include/pll.h»
#include «f2802x_common/include/wdog.h»

interrupt void buttonISR(void);
GPIO_Handle myGpio;
PIE_Handle myPie;
GPIO_Obj *gpio;

void main()
{
CLK_Handle myClk;
CPU_Handle myCpu;
PLL_Handle myPll;
WDOG_Handle myWDog;

//Инициализируем наши переменные
//Функции часов
myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
//Процессор
myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
//Входы/выходы
myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
//прерывания
myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
//Фазовая автоподстройка частоты
myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
//сторожевой таймер
myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

// Отключаем сторожевой таймер
WDOG_disable(myWDog);

gpio = (GPIO_Obj *)myGpio;

//Частота будет браться в внутреннего генератора
CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
// Устанавливаем плл на 60МГц. 10Мг(внетренний генератор) * 12 / 2 = 60
PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);
// Сбрасываем все прерывания
PIE_disable(myPie);
PIE_disableAllInts(myPie);
CPU_disableGlobalInts(myCpu);
CPU_clearIntFlags(myCpu);

// Если программа на флэше, переписываем её в RAM
#ifdef _FLASH
memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

EALLOW;
//Все порты делаю входами/выходами, что б не болтались без дела
gpio->GPAMUX1 = (uint16_t)0;
gpio->GPAMUX2 = (uint16_t)0;
gpio->GPBMUX1 = (uint16_t)0;

//Все порты делаю выходами
gpio->GPADIR = (uint16_t)0xFFFF;
gpio->GPBDIR = (uint16_t)0xFFFF;

//Сбросим все выходы
gpio->GPADAT = (uint16_t)0;
gpio->GPBDAT = (uint16_t)0;

//Конец работы с портами
EDIS;

// Настраиваем наши выходы
//Выход 0 будет выполнять свою главную роль — дискретные входы/выходы
GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
//Наш пин 12 тоже будет выполнять обычную функция ввода/вывода
GPIO_setMode(myGpio, GPIO_Number_12, GPIO_12_Mode_GeneralPurpose);

//Отключаем подтяжку, т.к. по схеме наша кнопка даёт положительный уровень
GPIO_setPullUp(myGpio, GPIO_Number_12, GPIO_PullUp_Disable);
//Привязываем нажатие кнопки к прерыванию CPU_ExtIntNumber_1
GPIO_setExtInt(myGpio, GPIO_Number_12, CPU_ExtIntNumber_1);

//Наш пин 0 — это выход
GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);

//Наш пин 12 (кнопка) — это вход
GPIO_setDirection(myGpio, GPIO_Number_12, GPIO_Direction_Input);

//Гасим светодиод
GPIO_setLow(myGpio, GPIO_Number_0);

//Включаем прерывания
PIE_enable(myPie);
//Указываем нашу функцию-обработчик прерываний
PIE_registerPieIntHandler(myPie, PIE_GroupNumber_1, PIE_SubGroupNumber_4, (intVec_t)&buttonISR);

//Указываем, что прерывание должно срабатывать по переднему фронту
PIE_setExtIntPolarity(myPie, CPU_ExtIntNumber_1, PIE_ExtIntPolarity_RisingEdge);

//Разрешаем прерывания нашей кнопки
PIE_enableExtInt(myPie, CPU_ExtIntNumber_1);
CPU_enableInt(myCpu, CPU_IntNumber_1);
//Разрешаем глобальные прерывания
CPU_enableGlobalInts(myCpu);

//Разрешаем писать в регистры
ENABLE_PROTECTED_REGISTER_WRITE_MODE;

//Бесконечный цикл
while(1) {

}
}

//Наше прерывания по нажатию кнопки
interrupt void buttonISR(void)
{
//Подаём 1 на выход
gpio->GPASET = (uint32_t)1;
//Сбрасываем флаг прерываний
PIE_clearInt(myPie, PIE_GroupNumber_1);
}

И сам результат:

Голубой график — это наша кнопка, синий график — выход. Как Видно, с момента нажатия на кнопку до подачи на выход единицы проходит около 2,5 мкс.
Конечно моргание светодиодом не является основным назначением этой платы, она заточена немного под другие задачи, но для общего представления думаю будет достаточно.
К сожалению нормальной информации на русском я не нашёл, поэтому для изучения рекомендую использовать примеры, входящие в комплект controlSUITE ну и даташит.
Основная информация:
— Datasheet на TMS320F28027 (En)
— C2000 LaunchPad (описание, схема платы и т.п.) (En)
— Прочая документация (En)

Stellaris LM4F120 LaunchPad Evaluation Board: $12.99 $9.99 $7.99

Следующая плата на базе микроконтроллера Cortex ™-M4F LM4F120H5QR. Этот микроконтроллер имеет свой USB интерфейс, который выведен на плате отдельным разъёмом, так же на плате установлены две пользовательские кнопки и RGB светодиод.

Внешний вид коробки:



В комплекте:

— Stellaris LaunchPad Демонстрационная плата
— USB Micro-B USB-кабель
— Руководство по эксплуатации

В руководстве как обычно идёт описание программы, зашитой в микроконтроллер и ссылки на матчасть.

Основные характеристики:

— Микроконтроллер: 32-битный Cortex ™-M4F LM4F120H5QR;
— Скорость до 80 МГц;
— 256 КБ Flash/ 32 КБ SRAM / 2 КБ EEPROM
— 2 12-битных АЦП;
— 6 64-битных и 6 32-битных таймеров;
— 8 UART;
— 4 SSI;
— 4 I2C;
— CAN 2.0;
— USB 2.0.

Для программирования Texas Instruments предлагает бесплатно скачать на выбор:
— Code Composer Studio;
— Keil (ограничение кода до 32 КБ);
— IAR (ограничение кода до 32 КБ или 30 дней);
— Sourcery CodeBench (30-дневный триал);
— Energia.
Как и с MSP430, самым простым способом запрограммировать железку, воспользоваться средой разработки Energia.
Так как на плате установлен RGB светодиод, фактически 3 светодиода (красный, синий и зелёный), почему бы не поморгать ими всеми:

void setup() {
// Указываем, что наши пины со светодиодами — это выход
pinMode(RED_LED, OUTPUT);
pinMode(GREEN_LED, OUTPUT);
pinMode(BLUE_LED, OUTPUT);
}

void loop() {
//Зажигаем красный светодиод
digitalWrite(RED_LED, HIGH);
//Ждём 200мс
delay(200);
//Гасим красный светодиод
digitalWrite(RED_LED, LOW);
//Ждём секунду
delay(1000);
//Проделываем тоже самое с зелёным светодиодом
digitalWrite(GREEN_LED, HIGH);
delay(200);
digitalWrite(GREEN_LED, LOW);
delay(1000);
//И синем
digitalWrite(BLUE_LED, HIGH);
delay(200);
digitalWrite(BLUE_LED, LOW);
delay(1000);
}

Для остальных сред разработки нужно посетить страницу «Stellaris® LM4F120 LaunchPad Evaluation Board Software» и скачать StellarisWare под свою среду.
После загрузки и установки, можно посмотреть примеры, которые находятся в папке:

C:\StellarisWare\boards\ek-lm4f120xl

Для моргания светодиодом я взял за основу «project0» из папки с примерами и вот, что получилось:

#include «inc/hw_types.h»
#include «inc/hw_memmap.h»
#include «driverlib/sysctl.h»
#include «driverlib/gpio.h»

//задаём псевдонимы для RED_LED — это пин 1, синий — 2, зелёный — 3
#define RED_LED GPIO_PIN_1
#define BLUE_LED GPIO_PIN_2
#define GREEN_LED GPIO_PIN_3

int main(void) {
//Устанавливаем системные часы на 16МГц
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);

//Включаем канал F, на котором установлены светодиоды
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//Указываем, что пины RED_LED|BLUE_LED|GREEN_LED — это выходы
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED);

//
//Бесконечный цикл
//
while(1) {
//Зажигаем красный светодиод
GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, RED_LED);
//Эта функция делает задержку в 3 цикла, в итоге получаем 0,3 сек.
SysCtlDelay(1e5);
//Гасим все светодиоды
GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, 0);
//Ждём ~1сек.
SysCtlDelay(5e6);
//Всё тоже самое проделываем с зелёным и синем светодиодом
GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, GREEN_LED);
SysCtlDelay(1e5);
GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, 0);
SysCtlDelay(5e6);
GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, BLUE_LED);
SysCtlDelay(1e5);
GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, 0);
SysCtlDelay(5e6);
}
}

В итоге получаем следующее:

Ну а теперь посмотрим, на максимальную скорость. Первым делом изучим файл «gpio.c», который находится в папке

C:\StellarisWare\driverlib

Там же лежат исходные коды всех наших функций, упрощающих жизнь.

Исходный код функции GPIOPinWrite

…
void
GPIOPinWrite(unsigned long ulPort, unsigned char ucPins, unsigned char ucVal)
{
//
// Check the arguments.
//
ASSERT(GPIOBaseValid(ulPort));

//
// Write the pins.
//
HWREG(ulPort + (GPIO_O_DATA + (ucPins << 2))) = ucVal;
}
...

Подкорректируем наш код и получаем:

#include «inc/lm4f120h5qr.h»
#include «inc/hw_types.h»
#include «inc/hw_memmap.h»
#include «driverlib/sysctl.h»
#include «driverlib/gpio.h»

int main(void) {
//Устанавливаем внутренний генератор на максимальную частоту 80МГц
SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);

// Включаем порт F
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//Указываем, что наш пин 2 — это выход
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);

//
// Бесконечный цикл
//
while(1) {
//Передаём 1 на выход 2
HWREG(GPIO_PORTF_BASE + (GPIO_PIN_2 << 2)) = GPIO_PIN_2;
//Передаём 0 на выход 2
HWREG(GPIO_PORTF_BASE + (GPIO_PIN_2 << 2)) = 0;
}
}

Зашиваем программу в контроллер, подключаем осциллограф и видим следующее:

Время на переключение состояния ~23 нс, на переход из конца цикла в начало ~40 нс.

Проверка времени реакции на нажатие кнопки.
Опять же лезем в наши примеры, знакомимся с реализацией тех или иных функций и выдёргиваем нужные себе.
У меня получилось следующее:

#include «inc/hw_types.h»
#include «inc/hw_gpio.h»
#include «inc/hw_ints.h»
#include «inc/hw_memmap.h»
#include «driverlib/sysctl.h»
#include «driverlib/gpio.h»
#include «driverlib/rom.h»
#include «driverlib/interrupt.h»

void __GPIOF_ISR(void);

int main(void) {
ROM_FPUEnable();
ROM_FPULazyStackingEnable();
//Устанавливаем внутренний генератор на максимальную частоту 80МГц
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);

// Включаем порт F
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//Делаем пин 1 выходом
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
//Делаем пин 0 входом
ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0);
//Разблокируем регистр PF0, что бы его можно было использовать в качестве входа
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01;
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0;
//Подключаем подтяжку к плюсу
ROM_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0,
GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
//Прерывание срабатывает по заднему фронту
ROM_GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_FALLING_EDGE);
//Включаем прерывания
ROM_GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_0);

//Включаем глобальные прерывания
ROM_IntMasterEnable();
ROM_IntEnable(INT_GPIOF);
//
// Бесконечный цикл
//
while(1) {
}
}

//Наш обработчик прерывания
void __GPIOF_ISR(void) {
//Подаём на выход 1
HWREG(GPIO_PORTF_BASE + (GPIO_PIN_1 << 2)) = GPIO_PIN_1;
unsigned long ulStatus;
//Получаем статус текущего прерывания
ulStatus = ROM_GPIOPinIntStatus(GPIO_PORTF_BASE, true);
//Сбрасываем флаг прерывания
ROM_GPIOPinIntClear(GPIO_PORTF_BASE, ulStatus);
}

И ещё, главное не забыть подправить файл «startup_ewarm.c», объявив вначале нашу функцию

…
extern void __GPIOF_ISR(void);
...

и указать её в списках обработчиков прерываний:

…
IntDefaultHandler, // FLASH Control
__GPIOF_ISR, // GPIO Port F
IntDefaultHandler, // GPIO Port G
...

После загрузки в контроллер получаем следующее:

Голубой график — это кнопка, синий — выход контроллера. На графиках видно, что время реакции ~380нс.

Плата действительно очень интересная, тем более, что на момент написания обзора цена её упала до 7.99$, что дешевле, чем MSP430 launchpad. Похоже Texas Instruments хотят снять её с продажи и распродают остатки, в пользу Tiva™ C Series TM4C123G LaunchPad.

Информация:

— Stellaris® LM4F120 LaunchPad User Manual (En);
— Начало программирования в Code Composer Studio;
— Начало программирования в IAR;
— Stellaris® LM4F120H5QR DATA SHEET (En);
— Прочая документация.

Tiva™ C Series TM4C123G LaunchPad Evaluation Kit: $12.99

Следующая плата появилась совсем недавно и пришла на смену Stellaris.

Коробка:


Новые платы теперь упаковываются в более мелкие коробки.

Внешне Тива не отличается от Стелариса, платы сделаны абсолютно идентично.

Снизу платы нанесены названия пинов, что конечно очень удобно.


Комплект:

— Tiva C Series отладочная плата;
— USB Micro-B USB-кабель;
— Руководство по быстрому старту.

Основные характеристики:

— Микроконтроллер: 32-битный ARM Cortex-M4 TM4C123GH6PM;
— Скорость до 80 МГц;
— 256 КБ Flash/ 32 КБ SRAM / 2 КБ EEPROM
— 2 12-битных АЦП;
— 6 64-битных и 6 32-битных таймеров;
— 8 UART;
— 4 SSI;
— 4 I2C;
— CAN 2.0;
— USB 2.0.

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

Время смены состояния ~23 нс, время перехода из конца цикла в начало ~40 нс (как и у стеллариса).
Теперь залью программу для проверки времени реакции на нажатие кнопки и результат оказался следующим:

Время реакции на нажатие кнопки ~380нс (опять же как и у стеллариса).

В общем пока особо не понял, в чём отличие тивы от стеллариса, но Texas Instruments пишут, что тива — новое и улучшенное продолжение стеллариса.

В CCS, после установки ControlSuite появились интересные примеры с тивой:

Можно сделать эмулятор мышки, клавиатуры или последовательного порта через USB.

Информация:

— Tiva™ C Series EK-TM4C123GXL LaunchPad User's Guide (En);
— Tiva™ TM4C123GH6PM Microcontroller DATA SHEET (En);
— Начало программирования в Code Composer Studio;
— Начало программирования в Keil™ RealView®;
— Начало программирования в Sourcery CodeBench™;
— Прочая документация.

Hercules RM42x LaunchPad Evaluation Kit: $19.99


Ну и напоследок расскажу о совсем новой плате Hercules RM42x LaunchPad.
Texas Instruments совсем недавно начал выпуск новых плат Hercules TMS570LS04x/03x Launchpad и Hercules RM42X Launchpad на базе двухъядерных микроконтроллеров TMS570LS0432 и RM42L432 соответственно.
Платы абсолютно одинаковые, в том числе и цена, разные только микроконтроллеры, у TMS570LS0432 частота до 80 МГц, а RM42L432 до 100 Мгц.

Основные характеристики:
Hercules TMS570LS04x/03x Launchpad

— Микроконтроллер: TMS570LS0432 (Dual ARM Cortex – R4);
— Встроенная самопроверка для ЦП и RAM;
— Контроль часов и напряжения;
— Характеристики МК: 80MHz
384kB Flash со встроенными средствами обнаружения и коррекции ошибок (ECC);
32kB RAM с ECC;
16kB flash c ECC для эмуляции EEPROM;
16 12-битных АЦП;
19-пиновый программируемый High-End Timer (N2HET);
SPI;
LIN/SCI (UART);
GIO пины;

Hercules RM42X Launchpad

— Микроконтроллер: RM42L432 (Dual ARM Cortex – R4);
— Встроенная самопроверка для ЦП и RAM;
— Контроль часов и напряжения;
— Характеристики МК: 100MHz
384kB Flash со встроенными средствами обнаружения и коррекции ошибок (ECC);
32kB RAM с ECC;
16kB flash c ECC для эмуляции EEPROM;
16 12-битных АЦП;
19-пиновый программируемый High-End Timer (N2HET);
SPI;
LIN/SCI (UART);
GIO пины;

В общем я взял побаловаться Hercules RM42X Launchpad.

Коробка по размерам такая же как и у Tiva.
Внешний вид коробки:




Комплект:

— Hercules RM42x отладочная плата;
— USB Micro-B USB-кабель;
— Руководство по быстрому старту.

Снизу на плате есть резиновые ножки, что конечно же очень удобно при её использовании на столе. Так же рядом со всеми пинами нанесены надписи, указывающие на их функции.


По умолчанию в микроконтроллер зашита программа, которая работает в паре с Windows приложением Hercules Safety MCU Demos

Данный проект предназначен для демонстрации следующих возможностей:
— система самодиагностики и обнаружения ошибок

— работа встроенного датчика освещённости

— моргание двумя светодиодами


Для программирования Texas Instruments предлагает скачать Code Composer Studio и HALCoGen

К сожалению плата пришли на днях и я ещё глубоко в ней не ковырялся, поэтому с морганием светодиодами проблема. Но если кому то это интересно, как разберусь, вставлю тесты.

Информация:

— RM42L432 DataSheet;
— Схема Hercules LaunchPad;
— Страница на wiki
— Прочая документация.