Загадочный AES

В процессе обкатки модулей для супер-мега-экстра часов добрался до СС модулей от Texas Instruments. Документации куда больше, чем на nRF серию от Nordic, демоплатки тоже завелись без проблем.

Читаю документацию к SimplyciTI (это такой фирменный сетевой стек для этих чипов, сразу позволяет делать точки доступа, репитеры и прочее). Добираюсь до секурности – ведь никто не должен знать температуру за моим окном или включать-выключать свет в туалете (это одна из моих претензий к noolite)

There are 3 components of the encryption scheme that can be used to maintain security: the 128 bit key, a 32-bit Initialization Vector (IV) and a 32-bit counter. The key and the IV are fixed at build time.

Офигеть. Даже мне, далекому от криптографии, становится смешно. 32 бита “энтропии”, которые меняются по жесткому алгоритму … Ну ладно, что там еще

The scheme encrypts 64-bit blocks using an encryption scheme available in the public domain (XTEA: EXtended Tiny Encryption Algorithm). The 64-bit block is a concatenation of the 32-bit IV and a 32-bit counter. Changing the counter for each encryption guarantees a unique block for each encryption action. The key length used in the encryption is 128 bits.

Читаю дальше …

Because SimpliciTI does not support guaranteed delivery there must be a mechanism to synchronize the counters. Otherwise correct decryption could not occur. The synchronization is done by supplying a counter hint in the frame containing the encrypted payload. The hint is a single byte representing the least significant byte (lsb) of the 4 byte counter value used to encrypt the accompanying payload. It is sent in the clear over the air.

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

И как-то все. В задумчивости сижу, думаю, что не так.

Потом вспоминаю рекламные зазывалки.

The CC1110’s integrated AES-128 co-processor makes it ideal for wireless payment systems, since strong encryption can be done on the chip itself

Ну AES-128 это круто. Странно, что не написали в аппноуте, как до него добраться. Но счас почитаю оставшуюся документацию.

(пропущено несколько часов ползанья по докам и исходникам)

А нигде нету ни слова про AES вообще. Печаль. Может это из-за того, что я скачивал документацию с фирменного сайта TI, а там меня спрашивали, откуда я. Вот может под какие санкции попал. Пошел спрашивать интернет.

И тут открылось обычное. На более-менее приличных сайтах, которые не занимаются тупой перепечаткой, нет ни слова про AES. Вообще.

Вот такой вот AES. То он есть, то его сразу нет …

ЗЫ И именно поэтому я не люблю маркетологов, которые уцепившись за циферку 128, сразу прилепили к ней слева магические (в 2009 году) буквы AES.

Мега-часы. 2. Новые горизонты

Опытно-промышленное тестирование бутерброда из Arduino Leonardo и Arduino Wifi Shield показало, что wifi shield … В общем, очень плохо работает. Может тупо не запуститься или взять и повиснуть прямо на середине работы. А может завестись без каких-либо проблем и проработать сутки под нагрузкой.

В итоге wifi (да и вообще вся сетевая) часть переезжает на raspberry. Там с этим гораздо лучше просто по определению.

Следующее тестирование (в предидущих постах можно прочитать подробнее) показало, что первоначально выбранный контроллер nRF24 оказался тоже не очень хорошим. То ли китайцы чего-то не так распаяли, что ли у меня руки кривые, но дальность действия радиочасти оказалась ниже плинтуса. А я уже раскатал губу про выносные датчики и прочие штуки …

Но не одним nordic’ом полон мир. Тут же на замену был приобретен комплект разработчика на чипе MSP430+СС1100 от Texas Instruments производства нашей ТерраЭлектроники . Что бы дополнительно “замативировать” себя, взял еще СС430-Chronos. Настоящие умные часы, которые можно запрограммировать так, как тебе надо, а не просто менять циферблатики.

IMG_0269

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

Так как я с MSP430 не работал до этого момента, то из launchpad был вынут “крутой” проц и засунут простой.

IMG_0272

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

NRF24LE1 и NRF24LU1. Часть 2

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

Но все оказалось проще.

Во-первых, бравые норвежцы слишком перемудрились и сделали так, что все операции ввода-вывода через USB делаются специальным чипом. В принципе, в этом нет ничего плохого, за исключением того, что они позабыли дать доступ к идентификаторам USB напрямую. В итоге фиг вы чего сделаете без драйверов, и заставить LU1 представляться COM портом не получится.

А во-вторых, “the USB chip that these kits use is obsoleted from the supplier, and doesn’t have a driver for 64-bit Windows 7.”, а так же для всяких OS X и прочего.

И наконец, я решил посмотреть в последний SDK (20 апреля 2012 года) и найти там примеры работы с беспроводной частью. Нашел, скомпилировал (если чего, искать в gazel_examples). Там все просто – на “девайсе” что-то суют в P0, а на “хосте” это что-то вылазит оттуда. Очень удобно – на дивайс посадил щуп от генератора, а на хосте смотришь, когда сигналы перестанут приходить.

Условия у меня очень тяжелые.

Screenshot_2015-01-14-12-54-39

И это еще не все сетки, ибо пока я обжимаю телефон для снятия скриншота, наиболее дохлые исчезают. WiFi адаптер tp-link, который воткнут в “малинку”, имеет миниатюрную антенну, но тем не менее честно сообщает о наличии 38 сетей.

Итак, результаты. Результаты хреновые.
1) В пределах комнаты – на троечку. То есть если “дивайс” находится в центре комнаты, то еще нормально. Но если “дивайс” в одном углу комнаты, а “хост” – в другом, то уже идут потери “пакетов”.
2) В пределах квартиры – уверенная двойка. То есть обычная, не капитальная стенка – уже плохо. Две – не видят друг друга.
3) На открытом пространстве (у меня за окнами лес) – метров 30 берет.

Все вышеперечисленное ставит жирный крест на использовании данных контроллеров для меня. Буду использовать другие 🙂

NRF24LE1 и Raspberry Pi. Часть 1

В принципе, этот пост просто перепись моих исследований, ибо в русскоязычном сегменте сети есть только одна, много раз скопированная статья MaxMS (http://habrahabr.ru/post/210974/). В принципе, я довольно много подчерпнул оттуда.

Итак, у меня есть контроллеры на данном чипсете и есть желание сделать с ними что-либо полезное. Но прежде “деланья” чего-либо полезного, надо этот контроллер запрограммировать. Вместе с контроллером ко мне попал “официальный” программатор, но чего с ним можно делать, я даже не разбирался, потому что неспортивно.

Для начала я определил, какая именно версия nrf у меня.

Screen Shot 2015-01-13 at 12.26.57

Судя по плате (плюс я глазами пересчитал выводы), у меня 32х пиновая версия.

А значит, из этой таблички берем среднее

aadd6daf8ee7e68f19eac9fbc8471494

Теперь как программировать. Из той же статьи наиболее приемлемым для меня оказался вариант с Raspberry Pi. Во-первых, у него везде 3,3 вольта, а во вторых, из него легко получается мобильный комплекс – воткнул wifi и питание и все, комп для прошивки готов.

Результатом стал следующий ужас

IMG_0261

Для памяти
RESET и VDD – на 3,3
GND – на землю
FCSN – 24я ножка CE0
PROG – 18я ножка GPIO24
Остальное согласно SPI на малинке. MISO-MISO, MOSI-MOSI и так далее

Затем выкачиваю с гитхаба https://github.com/derekstavis/nrf24le1-libbcm2835 программатор и собираю его

Первая проверка в виде попытки прочитать nvram выдала одни нули. Сначала я подумал, что либо контроллер дохлый, либо что-то не так подключил или какой-нибудь модуль не догрузил (Raspberry в этом отношении очень капризный), но попытка прочитать программу удалась

# ./nrf24le1 read firmware
[nrf24le1] nrf24le1_init: Initializing nRF24LE1

Initiate programming
Number of bytes to read: 16384, max flash size 16384
[nrf24le1] uhet_read: read addr: 0x0xbeae07dd, pack header: 0x3 0x0 0x0, bytes read: 16384
:2000000002024D41808B004180890142808D0000458084345678901200E4FDFCC3ED9FECA4
:200020009E501D908055E4F0A3746CF090805574FFF5F011F645F070F30DBD00010C80DC7A
:2000400022E490808AF0A3F022FFFFA10BC291914FE4FF914FD2912280E7FF0208EA80E17B
:20006000FFFFFF020CEABB010689828A83E0225002E722BBFE02E32289828A83E49322BB28
:20008000010CE58229F582E5833AF583E0225006E92582F8E622BBFE06E92582F8E222E51A
:2000A0008229F582E5833AF583E49322BB010689828A83F0225002F722BBFE01F322F8BB92
:2000C000010DE58229F582E5833AF583E8F0225006E92582C8F622BBFE05E92582C8F22207
:2000E000C5F0F8A3E028F0C5F0F8E582158270021583E038F022A3F8E0C5F025F0F0E5823D
.....

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

Теперь надо проверить, что прошивка работает. Читаем в test текущую фирмварь

./nrf24le1 read firmware test

Любым редактором ее портим, но по-своему (я просто записал посрединке немного байтиков со значениями 0х01-0х20) и заливаем назад и пофиг, что работать не будет.

./nrf24le1 write firmware test

И тут же читаем назад, но в другой фаил.

./nrf24le1 read firmware test1

А теперь ищем в test1 наши правки. Если они есть – значит “программатор” работает. У меня все заработало. Теперь можно и свою программу написать 🙂

Посмотрел на официальный SDK, покривился, забрал “правленный”, взял пример с дерганьем порта p0.0

#include <stdint.h>
#include <stdio.h>

//подключение необходимых функций:

#include "src/gpio/src/gpio_pin_configure.c"
#include "src/gpio/src/gpio_pin_val_clear.c"
#include "src/gpio/src/gpio_pin_val_set.c"

#include "delay.h"
#include "src/delay/src/delay_us.c"
#include "src/delay/src/delay_s.c"
#include "src/delay/src/delay_ms.c"

void main()
{
// мигаем портом P0_0
gpio_pin_configure(GPIO_PIN_ID_P0_0, // укажем необходимые параметры
GPIO_PIN_CONFIG_OPTION_DIR_OUTPUT |
GPIO_PIN_CONFIG_OPTION_OUTPUT_VAL_CLEAR |
GPIO_PIN_CONFIG_OPTION_PIN_MODE_OUTPUT_BUFFER_NORMAL_DRIVE_STRENGTH);

while(1)
{
gpio_pin_val_set(GPIO_PIN_ID_P0_0); //установка 1
delay_ms(500);
gpio_pin_val_clear(GPIO_PIN_ID_P0_0); //установка 0
delay_ms(500);

}

}

Пытаемся скомпилировать

# sdcc -Iinclude led_main.c
# ls -l
total 312
drwxr-xr-x 2 root root 4096 Jan 30 2014 include
-rw-r--r-- 1 root root 29083 Jan 13 13:14 led_main.asm
-rw-r--r-- 1 root root 850 Jan 13 13:13 led_main.c
-rw-r--r-- 1 root root 2382 Jan 13 13:14 led_main.ihx
-rw-r--r-- 1 root root 248 Jan 13 13:14 led_main.lk
-rw-r--r-- 1 root root 80283 Jan 13 13:14 led_main.lst
-rw-r--r-- 1 root root 26676 Jan 13 13:14 led_main.map
-rw-r--r-- 1 root root 1129 Jan 13 13:14 led_main.mem
-rw-r--r-- 1 root root 14900 Jan 13 13:14 led_main.rel
-rw-r--r-- 1 root root 80283 Jan 13 13:14 led_main.rst
-rw-r--r-- 1 root root 48610 Jan 13 13:14 led_main.sym
-rw-rw-rw- 1 root root 3087 Jan 31 2014 libs.h
drwxr-xr-x 22 root root 4096 Jan 30 2014 src

Судя по содержимому, мне нужно залить lem_main.ihx. Только формат ему поменять. Заодно и выкачиваю hex2bin (http://hex2bin.sourceforge.net)

# ./hex2bin -p 00 led_main.ihx
hex2bin v1.0.12, Copyright (C) 2012 Jacques Pelletier & contributors

Lowest address = 00000000
Highest address = 000003C2
Pad Byte = 0
8-bit Checksum = FB

Ну теперь полученный led_main.bin можно залить в контроллер.

# ./nrf24le1 write firmware led_main.bin

А теперь посмотрим осциллографом на вывод P0.0

500_500

Как видим, все согласно программе: 500мс включено и 500мс выключено.

Как говорится, ура. Обязательная программа для любого микроконтроллера работает как надо.

Но вообще-то у меня немного другая задача: связать два микроконтроллера между собой по радиоканалу и оценить, насколько он работоспособен в условиях обычной многоэтажки, где диапазон 2,4ГГц забит напрочь и намертво WiFi.

Но это тема следующего поста. Или даже через одного 🙂

Развлекалочка. Или контроллер сварочного аппарата

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

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

Для проверки “а пойдет” рисую схему

schema

Светодиодиками буду показывать, какое время импульса выбрано, энкодером выбирать и релюшкой щелкать. После предварительной обкатки набросал печатную плату. Именно набросал, ибо реализовывать буду все равно на макетной, а тут просто прикинул наиболее лучшее взаимное расположение деталей, что бы лишних проводков не тянуть.

pcb_example

Потом посмотрел, как оно будет выглядеть “в реале”

3dmodel

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

overview

Теперь добавляем щепотку “магии”

#include <EEPROM.h>
int pinAch = 2; //Энкодер вывод А включен на interrupt 0 (D2)
int pinBch = 3; // Энкодер вывод Б - D3

int pinled = 5; // Куда включен первый сетодиодик
int ledcount = 8; // Сколько светодиодиков

int pinButton = A5; // куда включена кнопка "пуск"
int pinRelay = A0; // Куда подключено реле

int impulsTime = 50; // Время включения реле по умолчанию (50 мс)
int relayShift = 2; // Время реакции реле
unsigned long bl; // переменная для хранения состояния "мигающего" светодиода
unsigned long dr; // переменная для антидребезга энкодера
int out=0; // мы бабахнули?

void setup() {                
  Serial.begin(9600);

  pinMode(pinAch, INPUT_PULLUP);  
  pinMode(pinBch, INPUT_PULLUP);

  pinMode(pinled, OUTPUT);
  pinMode(pinled+1, OUTPUT);
  pinMode(pinled+2, OUTPUT);
  pinMode(pinled+3, OUTPUT);
  pinMode(pinled+4, OUTPUT);
  pinMode(pinled+5, OUTPUT);
  pinMode(pinled+6, OUTPUT);
  pinMode(pinled+7, OUTPUT);

  pinMode(13, OUTPUT); // светодиодик, впаянный в ардуинку

  pinMode(pinButton, INPUT_PULLUP);
  pinMode(pinRelay, OUTPUT);

  digitalWrite(pinled, HIGH); // все светодидиоды включить для проверки
  digitalWrite(pinled+1, HIGH);
  digitalWrite(pinled+2, HIGH);
  digitalWrite(pinled+3, HIGH);
  digitalWrite(pinled+4, HIGH);
  digitalWrite(pinled+5, HIGH);
  digitalWrite(pinled+6, HIGH);
  digitalWrite(pinled+7, HIGH);

  digitalWrite(pinRelay,LOW); // для безопасности

  dr=millis();
  bl=millis();
  if(EEPROM.read(0)==1)
    {
      impulsTime=EEPROM.read(1);
    }
  attachInterrupt(0, encoderClick, RISING);
}


void loop() {
  // Зажигаем светодиодики в зависимости от уровня impulsTime
  for(int i=pinled;i<(pinled+ledcount);i++)
  {
    int s=(i-pinled+1)*10; // время импульса для зажигания светодиода
    // то есть для 1 светодиода 10, для 2 - 20 и так далее

    if((impulsTime-s)<0 && (impulsTime-s)>-10) // этот светодиодик промежуточный, поэтому пусть мигает.
    {
      if((millis()-bl)<500)
      {
        digitalWrite(i,HIGH);
      }
      else
      {
        digitalWrite(i,LOW);
        if((millis()-bl)>1000)
        {
          bl=millis();
        }
      }
    }
    else
    {
      if(s<=impulsTime)
      {
        digitalWrite(i,HIGH);
      }
      else
      {
        digitalWrite(i,LOW);
      }
    } 
  }
  
  if(digitalRead(pinButton)==LOW && out==0) // оппа, кнопку нажали и еще не бабахали
    {
      delay(100); // ждем 100мс - вдруг рука дрогнула
      if(digitalRead(pinButton)==LOW) // точно нажата?
        {
          digitalWrite(13,HIGH);
          digitalWrite(pinRelay,HIGH);
          out=1;
          delay(impulsTime+relayShift);
          digitalWrite(13,LOW);
          digitalWrite(pinRelay,LOW);
          out=1;
          EEPROM.write(0, 1); // ставим флаг
          EEPROM.write(1, impulsTime);
        }
    }
    
  if(digitalRead(pinButton)==HIGH && out==1) // Кнопку отпустили после бабханья
    {
      delay(100); // ждем 100мс - вдруг рука дрогнула
      if(digitalRead(pinButton)==HIGH) // до сих пор отпущена?
        {
          out=0; // Хорошо, можно еще раз бабахнуть
        }
    }


//  Serial.println(impulsTime);
//  delay(300);
}


// обработка энкодера
void encoderClick(){
  if((millis()-dr)>10) // От предидущего прерывания прошло больше 10мс? если нет, то это дребезг
  {
    dr=millis();
    int valA = digitalRead(pinAch);
    int valB = digitalRead(pinBch);

    if (valA != valB){
      impulsTime--;
    }
    else{
      impulsTime++;
    }

    if(impulsTime < 5) {
      impulsTime=5;
    }

    if(impulsTime > 100) {
      impulsTime=100;
    }
  Serial.println(impulsTime); 
  }
}

И проверяем, насколько полученное устройство соответствует заявленным мной же спецификациям

Импульс в 20 миллисекунд

20ms

В 50

50ms

и 75, что бы не было ровных чисел.

75ms

Теперь осталось только устроить ресурсные испытания релюшке и узнать, сколько времени она выдержит в таком режиме. Но это уже не так интересно, ибо стоимость релюшки около 100 рублей и перепаять ее – дело буквально пяти минут.

Задача выполнена быстро и с перерасходом ресурсов, как и положено для такого класса задач 🙂

Мега-часы. 1. Просто часы, но с WiFi

Занимаясь на выходных разборкой и сортировкой скопившегося имущества, практически внезапно обнаружил давно забытые детали. Ну как забытые … я конечно помнил, что они где-то есть, но уж очень давно не держал их в руках. Ну и плюс ко мне в руки попали платы на 8051 микроконтроллере, со встроенным приемопередатчиком. Просто так баловаться не интересно, поэтому необходимо совместить приятное с полезным.

Скажу сразу, просто еще одни часы делать мне не интересно – один раз я уже делал аж 2 года назад, до сих пор работают у тещи. Внутри ардуинка и sure 3208

20131113_165232

Что у нас из приятного образуется? Во-первых, более большой и цветной индикатор.

В старых часах был одноцветный (только красный) индикатор, в котором была кучка светодиодов, расположенных 32 рядами по 8 штук. В новых будет аналогичная матрица, только умеющая уже 3 цвета и с матрицей светодиодов 64 на 16. Из-за размера светодиодов (в старой 5мм, в новой 3мм) разница в размерах не очень большая.

Во-вторых, использованная в первых часах микросхема DS1307 обладает небольшим уводом времени. Примерно минуту в неделю. Нет, я там приделал кнопки для коррекции времени, но это же несерьезно в 21м-то веке. Ловить всякие радиосигналы точного времени для меня безсмысленно, ибо лень. А вот подцепиться к WiFi и сбегать за точным временем в интернет к специализированному серверу – вот это да, уже стоит подумать.

И наконец, просто часы – это не интересно. Так как основное их место жительство будет кухня, то надо заставить их что-нибудь делать полезное. Курс доллара там показывать и радио играть. Или еще какую полезную работу выполнять. Список полезной работы будет уточняться по мере того, как я буду откапывать запчасти 🙂

Итак, пока часы. Схемы рисовать не буду, потому что 99% всего будет состоять из соединения проводками.

Для начала берем 2 индикатора sure 3216 и соединяем их приложенными к ним же проводами. Потом берем arduino leonardo и wifi shield. Все родное, итальянское, поэтому соединяем все в кучу. Достаем из пакетика мастеркитовский MP1095 и опять же соединяем проводками с ардуинкой. Все подписанное к подписанному (SDA к SDA, SCL к SCL и так далее).

И наконец соединяем полученный бутерброд из 3216 к ардуинке. На пины А0-А3. В нижеприведенном куске кода любой ардуинщик разберется, что куда подключается.

//Analog In 0 as PF7
//Analog In 1 as PF6
//Analog In 2 as PF5
//Analog In 3 as PF4
ht1632c ledMatrix = ht1632c(&PORTF, 7, 6, 5, 4, GEOM_32x16, 2);
ht1632c::ht1632c(const uint8_t data, const uint8_t wr, const uint8_t clk, const uint8_t cs, const uint8_t geometry, const uint8_t number)

И теперь добавляем магию, сиречь программирование. Я не стал сильно раздумывать, поэтому тупо собрал в одну кучу примеры общения с RTC, с NTP, c WiFi и с индикатором.

#include <ht1632c.h>
#include <Wire.h>
#include <RealTimeClockDS1307.h>
#include <SPI.h>
#include <WiFi.h>
#include <WiFiUdp.h>

ht1632c dm = ht1632c(&PORTF, 7, 6, 5, 4, GEOM_32x16, 2);

int status = WL_IDLE_STATUS;

char ssid[20] = "multik";  //  your network SSID (name)
char pass[20] = "MyVerySecretPassword";       // your network password
int timeshift=3; // GMT offset

unsigned int localPort = 2390;      // local port to listen for UDP packets

IPAddress timeServer(129, 6, 15, 28); // time.nist.gov NTP server

const int NTP_PACKET_SIZE = 48; // NTP time stamp is in the first 48 bytes of the message

byte packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets
WiFiUDP Udp;

char clock[4];
int clockset=0; // does need to set clock from NTP?
int clockprocess=0; // we start asking clock server?

void setup() {  
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  // check for the presence of the shield:

  while (WiFi.status() == WL_NO_SHIELD)
    Serial.println("NOWIFI");

  String fv = WiFi.firmwareVersion();
  if ( fv != "1.1.0" )
    Serial.println("FIRM");

  status = WiFi.begin(ssid, pass); // start connecting

  dm.clear();
  dm.setfont(FONT_8x16B);

  RTC.switchTo24h();
}

void loop()
{
  if(clockset==0)
  {
    //Serial.println("Setting clock");
    if(status==WL_CONNECTED) // ok, we online
    {
      //Serial.println("WiFi con");
      if(clockprocess==0)
      {
        Udp.begin(localPort);
        sendNTPpacket(timeServer); // send an NTP packet to a time server
        clockprocess=1;
      }
      else
      {
        if ( Udp.parsePacket() ) 
        {
          //Serial.println("packet received");
          Udp.read(packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer

          //the timestamp starts at byte 40 of the received packet and is four bytes,
          // or two words, long. First, esxtract the two words:

          unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
          unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
          // combine the four bytes (two words) into a long integer
          // this is NTP time (seconds since Jan 1 1900):
          unsigned long secsSince1900 = highWord << 16 | lowWord;
          //Serial.print("Seconds since Jan 1 1900 = " );
          //Serial.println(secsSince1900);

          // now convert NTP time into everyday time:
          // Serial.print("Unix time = ");
          // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
          const unsigned long seventyYears = 2208988800UL;
          // subtract seventy years:
          unsigned long epoch = secsSince1900 - seventyYears;
          // print Unix time:
          //Serial.println(epoch);


          // print the hour, minute and second:
          //Serial.print("The UTC time is ");       // UTC is the time at Greenwich Meridian (GMT)
          //Serial.print((epoch  % 86400L) / 3600); // print the hour (86400 equals secs per day)
          int h=(epoch  % 86400L) / 3600;

          RTC.setHours(h+timeshift);
          //Serial.print(h);Serial.print(':');
          //if ( ((epoch % 3600) / 60) < 10 ) {
          // In the first 10 minutes of each hour, we'll want a leading '0'
          //Serial.print('0');
          //}
          int m=(epoch  % 3600) / 60;

          //Serial.print((epoch  % 3600) / 60); // print the minute (3600 equals secs per minute)
          RTC.setMinutes(m);
          //Serial.print(m);Serial.print(':');
          //if ( (epoch % 60) < 10 ) {
          // In the first 10 seconds of each minute, we'll want a leading '0'
          //Serial.print('0');
          //}
          int s=epoch % 60;
          //Serial.println(s);
          //Serial.println(epoch % 60); // print the second
          RTC.setSeconds(s);
          RTC.setClock();
          clockset=1;
        }
      }
    }
    //    else
    //    {
    //      Serial.println("WiFi NOT con");
    //    }
  }
  else
  {
    // Serial.println("Clock already setted");
  }
  int x=0;
  int clr=GREEN;
  delay(1000);
  RTC.readClock();
  sprintf(clock, "%02d", RTC.getHours()); // RTC.getMinutes(),RTC.getSeconds());

  dm.setfont(FONT_8x16B);
  dm.putchar(x,0,clock[0],GREEN,0,BLACK);
  dm.putchar(x+9,0,clock[1],GREEN,0,BLACK);  

  // first :
  dm.plot(x+18,4,clr);
  dm.plot(x+18,4+1,clr);
  dm.plot(x+18+1,4,clr);
  dm.plot(x+18+1,4+1,clr);
  dm.plot(x+18,4+4,clr);
  dm.plot(x+18,4+1+4,clr);
  dm.plot(x+18+1,4+4,clr);
  dm.plot(x+18+1,4+1+4,clr);

  sprintf(clock, "%02d", RTC.getMinutes()); //,RTC.getSeconds());
  dm.putchar(x+21,0,clock[0],GREEN,0,BLACK);
  dm.putchar(x+30,0,clock[1],GREEN,0,BLACK);
  // second :
  dm.plot(x+39,4,clr);
  dm.plot(x+39,4+1,clr);
  dm.plot(x+39+1,4,clr);
  dm.plot(x+39+1,4+1,clr);
  dm.plot(x+39,4+4,clr);
  dm.plot(x+39,4+1+4,clr);
  dm.plot(x+39+1,4+4,clr);
  dm.plot(x+39+1,4+1+4,clr);

  sprintf(clock, "%02d", RTC.getSeconds());
  dm.putchar(x+42,0,clock[0],GREEN,0,BLACK);
  dm.putchar(x+51,0,clock[1],GREEN,0,BLACK);

  dm.sendframe();
  //Serial.println(clock);

}

// send an NTP request to the time server at the given address
unsigned long sendNTPpacket(IPAddress& address)
{
  //Serial.println("1");
  // set all bytes in the buffer to 0
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialize values needed to form NTP request
  // (see URL above for details on the packets)
  //Serial.println("2");
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12]  = 49;
  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;

  //Serial.println("3");

  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp:
  Udp.beginPacket(address, 123); //NTP requests are to port 123
  //Serial.println("4");
  Udp.write(packetBuffer, NTP_PACKET_SIZE);
  //Serial.println("5");
  Udp.endPacket();
  //Serial.println("6");
}

В итоге получилось вот это

015dbb46cc547788abd94e57ccc08f1ec8fa680f70

И видео

Что получилось в итоге? Часы запускаются и пытаются подключиться к WiFi с заранее заданным SSID и паролем. Как только им это удается, то они запрашивают NTP сервер о точном времени и как только получают ответ, обновляют соответствующие значения в RTC. А пока все это крутится, то часы просто берут уже сохраненное ранее время и показывают его.

Просто и дешево. Но для дальнейшей работы необходимо немного расширить функционал и научиться обрабатывать ошибки. К примеру, если WiFi есть, а интернета в нем нет и так далее. Ну и предусмотреть … скажем так, подключение внешних устройств, в качестве которых будет как минимум одна Raspberry Pi плата. Опять же, фотодиод для замера освещенности надо поставить …

В общем, есть что писать в следующем посте 🙂

Карпутер. 5. Пора программировать!

Что-то давно ничего не писал. Наверное, новогодние праздники помешали. Но алкомарафон закончился, поэтому неплохо бы вернуться к нашему контроллеру.

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

Так как программировать лучше дома, сидя в тепле и уюте, то я ничего сразу паять не буду. И более того. вам не советую. Лучше всего сначала все “обкатать” в контролируемой обстановке, когда возникновение ошибок сведено к минимуму.

Возьмем наш первоначальный алгоритм. Если напряжение поднялось больше 13В, то замкнуть реле ближнего света. Где мы тут можем ошибиться? Да везде – от подбора резисторов для делителя напряжения до распайки реле и неправильного подсоединения. Поэтому сокращаем возможность ошибки до минимума: вместо делителя напряжения бортовой сети воспользуемся обычным переменным резистором, а вместо реле – обычным светодиодиком. Как подключать – я уже писал в предидущем посте. Но если у вас, как и у меня, плата discovery, то там уже есть светодиодики (а значит, вероятность ошибки снижается еще сильнее).

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

01a9541850ca680e486975cc6dcf78e69f85d7241d

Как видно из фотографии, я подключил переменный резистор к GND и 3V, а вывод движка резистора – на PA1. В итоге даже в самом плохом случае, когда я выверну резистор “до упора”, на ножку контроллера попадут безопасные 3 вольта.

Теперь пора описать, где и как писать код. Открываем сгенерированный пару постов назад код и находим в левой панели фаил main.c. В нем ищем кусок кода while(1), как показано на картинке

p1

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

Еще одно отступление – как управлять выводами. У ардуины есть кошмар под названием port mapping (это когда при смене контроллера все назания ножек меняются и программы перестают работать), на stm тоже до недавнего времени такой кошмар был. Именно был, сейчас все проще.

Итак, если вы посмотрите на микроконтроллер, что обнаружите, что ножки нумеруются от PA0 до PF15. Все функции используют следущую нумерацию ножек – Блок от А до F и номер ножки в блоке.

Переведение ножки PC12 в “высокое” состояние

HAL_GPIO_WritePin(GPIOC,GPIO_PIN_12,GPIO_PIN_SET);

А ножку PE15 – в “низкое”

HAL_GPIO_WritePin(GPIOE,GPIO_PIN_15,GPIO_PIN_RESET);

Выдаем на 1й канал ЦАП значение переменной s

HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, s);

И мной написанная (или подправленная) функция для чтения значения АЦП

static int GetADCValue(uint32_t Channel,uint32_t Count)
{
int val = 0;
ADC_ChannelConfTypeDef sConfig;
sConfig.Channel=Channel;
sConfig.Rank=1;
sConfig.SamplingTime=10;
HAL_ADC_ConfigChannel(&hadc,&sConfig);

for(int i = 0; i < Count; i++) { HAL_ADC_Start(&hadc); HAL_ADC_PollForConversion(&hadc,1); val += HAL_ADC_GetValue(&hadc); } return val / Count; }

Как видно из кода, работает только с ADC1 (ссылки hadc).

В посте описать все невозможно, поэтому рекомендую заглянуть в "Firmware", которую скачал STMCube, и посмотреть там примеры.

Итак, вот мой код

if(GetADCValue(2,3)>2048)
{
HAL_GPIO_WritePin(GPIOE,GPIO_PIN_15,GPIO_PIN_SET);
}
else
{
HAL_GPIO_WritePin(GPIOE,GPIO_PIN_15,GPIO_PIN_RESET);
}

В чем его суть? Если значение, которое прочитали из АЦП, больше 2048, то перевести ножку PE15 на высокий уровень. Если меньше, что наоборот, на низкий.

В чем магия? Магия в двух вещах. Первое, это значение АЦП. Оно может быть от 0 до 4095 (3В на ножке). Как им распорядиться, решать вам. А второе - ножка PE15 на плате подключена с зеленому светодиоду.

Компилируем, заливаем (иконка с буковками LOAD во втором ряду) и наслаждаемся своей первой программой.

Сам код (полностью готовый и скомпилированный) можно взять отсюда http://multik.org/carsim/carputer.rar

Что дальше? А дальше пишем, отлаживаем и снова пишем. Пока не будет готово то, что требовалось изначально.

Желаю удачи в написании своих проектов!

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

Карпутер 4. Кормим микроконтроллер

Сегодня пост будет самым зубодробительным для большинства автомобилистов. Придется вспомнить школьную физику за 5й класс и закон Ома оттуда. Но я покажу, где взять помощи 🙂

Итак, перед нами стоит 3 задачи.

1) Накормить микроконтроллер.
2) Дать данные. То есть позволить микроконтроллеру собирать всякую нужную ему информацию.
3) Позволить ему чем-либо управлять.

В чем основная проблема? Проблема как ни странно, в бортовой сети автомобиля. Напряжение в ней гуляет от 9 вольт до 14,5 вольт с возможными выбросами до 60 вольт. Попутно в этом самом “напряжении” есть куча шумов, всплесков и прочей гадости.

А микроконтроллеры очень нежные. Питаются только 5ю вольтами или 3,3мя. И желательно, что бы эти вольты не гуляли туда сюда больше 5%. То же самое и с входами-выходами. Те же самые условия, только еще желательно, что бы ток, проходящий по ним, не превышал единицы миллиампер. В случае необходимости ток может быть поднят до десятка-другого миллиампер, но это уже черевато.

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

Для питания “на быструю руку” давно придуманы готовые схемы. В любом приличном магазине электроники можете произнести слово “L7805” и вам за 10-15 рублей вынесут маленькую черную штучку, которая получает на входе от 8 до 30 вольт, а на выходе выдает стабильные 5 вольт. Вот тут (multik.org/carsim) вам собранная в proteuse схема на поиграться (carsim-power).

car-power1

Сколько бы вы не давали на “вход” напряжения, на выходе всегда будет около 5В. В чем подвох? Подвоха два. Во-первых, на холостом ходу (когда к ней ничего не подключено) эта штука потребляет единицы миллиампер. Для обычных условий эксплуатации это нормально, а вот если делать что-то типа сигналки, когда схема постоянно подключена к аккумулятору, это .. некрасиво. Во-вторых, если вы задумаете “снимать” с стабилизатора 1-1,5 ампера (хинт – это почти готовая зарядка для телефона), то вы внезапно обнаружите, что стабилизатор греется. Почему? Потому что он вынужден куда-то тратить те вольты, которые оказались ненужными. Считайте сами: пусть будет в бортовой сети 13,4 вольта. Телефон хочет 5В и 1А для своего заряда. Значит стабилизатору надо рассеять где-то (13,4-5)*1=8,4 ватта. Это вполне себе нехилая грелка. И именно поэтому у этого стабилизатора есть металлическое ушко, за которое его прикрепляют к радиатору (Кстати, радиатором может быть любая массивная железная часть автомобиля). Но повторюсь, для обычных применений это вполне себе штуковина.

Но если мы заранее задумаемся о снижении напряжения и тока питания, то есть варианты. К примеру LP2950. Он включается точно так же, как и 7805, но во-первых, на холостом ходу ест десятки микроампер, а во-вторых, больше 100 миллиампер с него не снять. Для многих схем этого может хватить.

Но что делать, если по каким-то причинам надо больше 1,5 ампер и радиолюбителей (что бы собрать блок питания) нет под боком? Тогда на выручку придут готовые DC-DC преобразователи. По сути это собранные и оттестированные блоки питания в миниатюрных корпусах. Например NSD15-12S5 (вход 9.4-36В, выход 5В и 3А) или наш МПА15А (вход 9-18В, выход 5В и 3A). На самом деле их куча, стоит только поискать. В чем их плюсы? Ну, они не греются, имеют встроенные фильтры, управление, защиту от КЗ и прочее, что полагается иметь блокам питания. Основной их минус в цене: от тысячи рублей и выше.

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

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

Первый: делитель на резисторах. Просто ставим в цепь два резистора, в точке их соединения забираем данные. Уровень напряжения в точке будет равен входному напряжению * соотношение номиналов резисторов. А ток можно подсчитать по закону Ома – i=u/r Опять же, я понимаю, что это тяжко, поэтому вот очередная схема в протеусе, которая позволит “поиграться” (там же файл carsim-power-res). Ну или набрать в поисковике “калькулятор делителя напряжения”.

carsim-power-res copy

Справа можно увидеть амперметр (показывает миллиамперы) и вольтметр. Наша задача – добиться таких сочетаний резисторов R1 и R2, что бы на микроконтроллер не приходило больше 3В (если ардуино, то 5) и потребление тока было минимальным (а то так повесим с десяток датчиков, сжигающих на резисторах по 10 миллиампер и получим 0,1 ампера, способных посадить аккумулятор в “ноль”). Казалось бы, простая задача? Но давайте снова посмотрим на то, что может происходить в бортовой сети. От 9 до 60 вольт … Если сделать совсем классический вариант, то 99% времени напряжение на ножке контроллера будет составлять доли вольта. Как-то некрасиво.

Поэтому обычно рассчитывают делитель на входное напряжение 0-15В, а всплески (которых может и не быть) убирают отдельным элементом. Есть много схем, но я предпочитаю самую простую в изготовлении: на вход, перед делителем, ставлю защитный диод (он же супрессор, он же TVS). Скажем, китайский SA15 пропускает через себя все, что попадает в диапазон 0-15 вольт. Остальное он убирает и убирает довольно качественно (в смысле после него конденсатор если и нужен, то только для сглаживания). Минус у него только один – если что, то он (диод) превращается в простое короткое замыкание, заставляя сгорать всё что можно перед собой. Для 99% случаев этого достаточно, а для оставшегося 1% существуют предохранители. Схемы я нарисую в следующем посте.

ВАЖНО: нельзя использовать “делители напряжения” для схем, где есть напряжения больше нескольких десятков вольт. Просто небезопасно для здоровья. Для этого есть второй вариант.

Вторым вариантом ввода сигнала в микроконтроллер является оптопара. Внутри оптопары стоит светодиодик, который своим светом управляет транзистором, “включая” или “выключая” выходы. У оптопары главный плюс в следующем: легко можно измерять наличие сотен и тысяч вольт. Самая обычная оптопара легко “развязывает” до 1500 вольт. Минус же тоже существенный: с её помощью нельзя (практически, да) измерять уровень сигнала. Только “есть” или “нет”.

Кнопки и прочие выключатели обычно присоединяются в микроконтроллер напрямую – там обычно неоткуда возникнуть “бякам”. Если возможность есть, то либо опять поставить на входе супрессор, либо стабилитрон с керамическим конденсатором. Опять же, страшные схемы в следующем посту.

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

062-Как подключить к микроконтроллеру нагрузку?

Моими любимыми способами являются использование “составного транзистора Дарлингтона” и “полевой транзистор”. Тут их переписывать не буду, ибо все прекрасно описано по ссылке выше. Мой выбор между способами простой: если надо коммутировать что-то до 5-10 ампер или быстро включать-выключать, выбираем транзистор. Выше – реле через составной транзистор. Быстро включать-выключать большие нагрузки мне не приходилось, но думаю, схем на всяких тиристорах и симисторах навалом.

Что бы проиллюстрировать вообще все вышеприведенное, вот вам очередная схема (она же в файле carsim-final)

carsim-final

Думаю, вдумчиво читающим уже почти все понятно, но на всякий случай прокомментирую. Слева вверху я сымитировал бортовую сеть автомобиля. Можно переключиться на 12В, 13,4, 16В и на регулируемое. Правее – стабилизатор напряжения на 5В. Слева внизу – делитель напряжения на резисторах R1 и R2 и развязка через оптопару U2. Правее стабилизатора две схемы включения нагрузки – через N-канальный полевой транзистор IRF610 и через сборку Дарлингтона ULN2003A.

К моему сожалению, proteus довольно небрежно относится (или у меня такая версия) к мощностям элементов, поэтому симуляция иногда прерывается (как и игнорируется D2). Если такое случилось, просто запустите заново.

В общем, схема выглядит достаточно страшной, что бы напугаться окончательно, особенно с непривычки. Но открою страшный секрет: для отладки нашей первоначальной задачи достаточно к плате с микроконтроллером дополнительно прикупить обычный переменный или подстроечный резистор на 500 Ом и выше. Индикатором срабатывания будет “пользовательский” светодиод, который есть на большинстве плат. Но как обычно, об этом в следующем посту.

Карпутер. 3. Выбираем микроконтроллер.

Итак, со схемами в proteus наигрались, теперь голова полна идеями, хотелками и желалками. Но ни одна идея не реализуется сама собой, поэтому надо выбрать “движок” для нее.

Как выбирают контроллер?

Во-первых, по личным предпочтениям. Кому-то нравится одна архитектура, кому-то другая. У кого-то уже есть опыт с одними микроконтроллерами и ему лень изучать другие … Но я считаю, что раз опыта и предпочтений нет, поэтому – stm32. Вам на данном этапе все равно, а мне потом спасибо скажете.

Во-вторых, по скорости. Если задача сложная, то думаю понятно, что работающий на 72МГц контроллер обгонит работающего на 16МГц (грубо – у кого больше литраж у двигателя, тот быстрее разгонится или больше увезет). А если устройство работает от батареек, то наоборот, устройство работающее на 16МГц легко даст фору работающему на 72х (опять же, чем больше литров, тем чаще на заправку надо будет ездить). Но на данном этапе нам совершенно все равно, какая скорость у контроллера – для нас подойдет любая.

И наконец, по числу портов и их возможностями. Все порты делятся на два типа: цифровые и аналоговые. Цифровые оперируют уровнями типа “есть сигнал” и “нету сигнала”, а аналоговые – “какой уровень у сигнала?”. Говоря другими словами – кнопки, выключатели и прочие переключатели – это цифровые, а всякие регуляторы, измерители и прочее – аналоговые. На каждую кнопку, релюшку или измеритель надо по одному порту (конечно, есть куча возможностей, как от этого уйти, но пока нам этого не надо). И крайне рекомендую при выборе зарезервировать пару портов под всякие доделки и внезапно всплывшие идеи.

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

Что будем делать-то? В смысле для чего мы все это затеяли? Давайте начнем с простого. Пусть будет система автоматического включения света в машине. Как пример использования: садимся в машину, включаем зажигание, заводим машину и через некоторое время наш контроллер включает фары. Выключили зажигание – все выключилось. Сплошные бонусы: стартеру легче крутить двигатель – фары не отбирают лишних ампер и вам не надо будет помнить о включении фар.

Какой будет алгоритм работы?

1. Измеряем напряжение бортовой сети
2. Напряжение меньше 13В? если да, иди на п.1
3. Подождать 5 секунд.
4. Включить фары.

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

(отступление) Не хотите фары включать? Ну тогда например можно автоматически включать и выключать компрессор в пневмосистеме. Или в зависимости от температуры включать нагреватель или вентилятор. В общем, подойдет любой вариант “измерил что-то и как это что-то достило такого-то уровня – включил или выключил нечто”.

Вернемся к нашим баранам. Нам нужен микроконтроллер, у которого есть как минимум 1 аналоговый порт на вход и 1 цифровой порт на выход. Сейчас смешно, да. Но потом всего будет не хватать и начнутся мучения.

Теперь готовимся скачать много из сети. Для начала нам нужна программа STM32CubeMx. (Все поисковики ее легко находят, но вот прямая ссылка http://www.st.com/web/catalog/tools/FM147/CL1794/SC961/SS1533/PF259242?sc=stm32cube там мотайте страницу в самый низ и справа будет маленькая красная кнопочка Download).

Зачем нужна эта программа? Как я писал в первом посте, STM32 имеют один, но очень большой и неприятный минус – очень сложно начать с ними работать. В этих микроконтроллерах очень много возможностей и вариаций, поэтому даже просто запустить его составляет очень большую проблему. Команды инициализации, предназначенные для одной серии, не подходят для другой. Один и тот же порт может выполнять разные функции на разной частоте, причем все это настраивается в четырех или пяти местах. В общем, реальный кошмар после атмеловских контроллеров и 99% причин неработащих программ.

Вот и придумали этакий “генератор кода инициализации”, когда можно мышкой не торопясь повыбирать порты и их функции. При этом идет одновременный контроль правильности использования порта и непересечение его с другими функциями. В общем, скачивайте, распаковывайте и запускайте программу (может потребовать java, так что тоже ставьте). Как ставить программы, нажимая next, я рассказывать не буду 🙂

stmcube1

Перед вами откроется очень информативное окно. New Project – это создать новый проект, Load Project – загрузить старый, который редактировали раньше. Нам естесственно надо выбрать создать новый. И тут …

stmcube2

И тут перед вами откроется окно, в котором собрана вся (почти) линейка микроконтроллеров. Первая вкладка – MCU Selector позволяет выбрать подходящие контроллеры в их голом виде. Слева в табличке функционал, справа – подходящие контроллеры. Скажем, нужно нам в нашем проекте использовать одновременно ethernet и часы реального времени, так значит ставим галочки и получаем, что нам подходят 88 микроконтроллеров из 590 (на момент написания). Но эта вкладка для продвинутых пацанов.

Нам нужна следующая вкладка, которая называется Board Selector. Тут уже можно выбрать готовые платы, со всем распаянным. Сразу рекомендую нажать кнопку “>>”, которая будет показывать изображение платы.

stmcube3

Механизм тот же самый – слева выбираем что хочется, а справа получаем список того, где это есть. Потом открываем веб-сайт ближайшего магазина электроники и смотрим на наличие и цену. Лично у меня есть платы STM32L100 и STM32F3 (именно она изображения на скриншоте). Так как F3 мне нравится больше, то и в дальнейшем я буду использовать именно эту плату. Но повторюсь, вы можете использовать любую плату или процессор – главное, что бы он вам подошел по характеристикам.

Выбрав плату или процессор, жамкаем на кнопоку ОК в самом низу. Компьютер немного подумает и потом выдаст примерно вот такую картинку.

stmcube4

Слева будут всякие возможности, которые умеет процессор, а справа – как и на что распределены ножки и процессора. Если вы вышли сюда из выбора плат, то программа сама показала, что на плате куда подключено. Как видите, все ножки помечены разными цветами.

Желтенькие и светлозеленые – ножки, назначение которых изменить нельзя. Питание, земля и прочие подобные ножки.
Оранживенькие – ножки, на которые повешено то, что есть на плате и что можно либо отключить, либо заиспользовать. У меня это кварцевые резонаторы, гироскоп с компасом, USB порт и так далее.
Зелененькие – это ножки, на которые тоже повешено то, что есть на плате, но это ТО – кнопки, светодиодики и прочее. Грубо говоря, отличие только в сложности с точки зрения контроллера. Таким же цветом будут обозначаться и ножки, которые вы выделили для вашего проекта.
Серенькие – свободные ножки, которые можно использовать.

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

Как менять назначение ножек? Есть два способа. Первый – это просто мышкой ткните на ножке. Вот для примера я ткнул на ножке, которая у меня подключена к голубой кнопке.

stmcube5

Как видите, эта ножка может выполнять аж 17 функций, но сейчас она работает как GPIO_Input (я ниже объясню, что это значит).

А второй способ – воспользоваться левой вкладкой и включить нужную функцию.

stmcube6

Как видим, у функции вообще горит желтый предупреждающий знак, который показывает, что что-то с ней не то. Открыв ее, можно увидеть подсвеченным красным подфункцию. В данном случае это IN1. Подведя мышку к красному, можно узнать, что с чем конфликтует. В данном конкретном случае можно увидеть, что 1й канал 1го аналого-цифрового преобразователя конфликтует на ножке процессора PA0, которая уже стоит в режиме GPIO_Input. Белиберда, да? Но ничего. Для примера можно обидеться и раз нам не дают использовать IN1, выбрать IN3, что бы это не значило. И обратите внимание, на рисунке процессора справа одновременно начнет показываться как “занятая” соответствующая ножка процессора. В нашем случае это PA3, в левом нижнем углу.

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

Итак, как же понять, какие функции можно повесить на ножку? Что бы не забивать голову, я опишу только наиболее нужные и часто используемые функции. Назначение других можете узнать сами, когда прижмет (но 90% это никогда не понадобится).

Итак, что можно выбрать?

ADC – Или АЦП, аналогово-цифровой преобразователь. Показывает значение напряжения. У большинства АЦП есть каналы, к которым он может подключаться. А каналы напрямую подключены к ножкам. То есть когда вам надо измерить напряжение на 1,2 и 3й ножке, то микроконтроллер на самом деле будет выполнять примерно следующее “подключить ацп к ножке 1, измерить, подключить ацп к ножке 2, измерить, подключить ацп к ножке 3, измерить”. В принципе, для большинства задач этого достаточно, ведь измерение одного канала занимает от 1 до 10 мс. Но есть задачи, когда необходимо реально одновременно измерить напряжение на несколких ножках. В таком случае используют два или больше АЦП. Например, в F3 серии аж 4 АЦП, поэтому мы можем измерять 4 уровня одновременно. Если мы заиспользуем все доступные ресурсы, то сможем за 0,1с измерить 59 аналоговых выводов (ардуинщики, вы рыдаете? :).

DAC – или ЦАП. Цифро-аналоговый преобразователь. Преобразует некоторое значение в уровень сигнала на выходе. Обычно один DAC имеет от 1 до 10 выходов, каждый из которых можно регулировать отдельно.

TIM – таймеры. Срабатывающие “раз в нное время” сигналы. На таймерах в stm делается очень многое – от PWM (управление сервомоторами и яркостью) до подсчета частоты смены сигнала на входе. Немножко к ним имеют отношение RTC – часы реального времени (которые считают минуты и секунды, а не тики и такты) и WDG – системы, которые автоматически перезагружают контроллер, если он завис, но я их касаться не буду

USART/UART – контроллеры для связи с “внешним миром”: с компьютерами, с другими контроллерами и так далее.

И наконец GPIO. Это порты общего назначения. То есть на них можно вешать все, что душе угодно. Они могут быть GPIO_Input – порт, работающий на вход (который принимает сигнал “есть” и “нет”) и GPIO_Output – порт, работающий на выход (который выдает сигнал “есть” и “нет”). Вы можете увидеть GPIO_Reset – это означает, что порт находится в хз каком стоянии и GPIO_EXTI – это выход прерывания. В общем лишнее на данном этапе.

Все ножки маркируются следующим способом: [подсистема]_[функция]. Пример:

ADC1_IN6 – 6й вход 1го АЦП контроллера
DAC1_OUT1 – 1й выход 1го ЦАП контроллера
USART1_TX – порт передачи 1 контроллера связи.

Но вернемся назад. Из всего выше перечисленного нам нужен один ADC ввод и один GPIO_Output вывод. Для ввода я заиспользую ADC1_IN2 (ножка PA1), а для вывода GPIO_Output – PC5. Они расположены на одной стороне реальной платы, поэтому мне будет удобно с ними работать. И что самое главное, они не конфликтуют ни с чем, что уже есть на плате.

stmcube7

Щелкаем и меняем назначение нужных нам ножек. Обратите внимание на то, что у PA1 нет булавки, а у PC5 – есть. Это та самая функция переназначения портов, когда вдруг функционал будет конфликтовать, а нам нет разницы, откуда его брать. Что бы “прикрепить” функционал к ножке, надо просто правой кнопкой мышки по ней щелкнуть и выбрать Signal Pinning. Теперь ни одна сволочь не отберет у нас ее :). Кстати, там же можно и дать название ножке, что бы не запутаться.

stmcube8

Согласитесь, так немного красивее? И так по всем ножкам-функциям, которые нам потребуются в нашем будующем устройстве. Не подходит что-то – возвращяемся назад и выбираем другую плату/микроконтроллер. Но я буду считать, что мы этот этап успешно преодолели и с большим трудом выбрали и назначили так нужные нам аналоговый порт на вход и цифровой порт на выход.

Можно сохранить проект на всякий случай, ибо это только начало.

Теперь щелкаем следующую вкладку – Clock Configuration. И у некоторых сейчас порвет мониторы 🙂

stmcube9

На этой вкладке вы можете увидеть, с какой скоростью работают внутренности микроконтроллера. Эта вкладка очень полезна тогда, когда мы озабочены энергопотреблением микроконтроллера. Играясь тут, можно легко на порядок понизить энергопотребление микроконтроллера. Но нам это не надо, поэтому переходим на следующую – Configuration

stmcube10

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

На картинке мы видим включенный контроллер ADC1 (для него нужны контроллер DMA, NVIC и RCC) и контроллер GPIO (Для него нужен RCC). В общем, давайте поверим, что нам это надо.

На этом экране у нас есть возможность тонкой настройки. Жмем на ADC1

stmcube11

Тут собраны все тонкие настройки для данного контроллера. Особо менять нечего, за исключением подсвеченного – Continuous Conversion Mode. Поставьте его в Enabled. Данная галочка говорит, что мы желаем запрограммировать контроллер так, что бы он постоянно мерял свои входы. И более того, измерянные значения сразу присваивал переменным. Ну ленивый я, пусть железка сама все делает 🙂

Аналогичную картинку можно получить и по GPIO портам.

stmcube12

Тут можно тоже поизменять разные параметры, но нам тут менять тоже ничего не надо.

В общем, полезная вкладка, особенно когда начинаешь использовать более сложные вещи, как USART или USB – здесь можно настроить все.

И наконец, последняя вкладка – Power Consumption Calculator. Тут можно прикинуть, сколько электричества будет потреблять микроконтроллер.

stmcube13

Но подчеркиваю, именно прикинуть. Ибо система не знает, сколько потребляет то, что еще подключено к этому контроллеру. На приведенном выше скриншоте я уже понажимал все кнопки. Согласно картинке, если мы ничего не будем подключать к этому микроконтроллеру, то на полной мощности он будет потреблять 30 миллиампер. Или говоря другими словами, от одной батарейки АА он проработает 3 с лишним суток. И это я не тыкал в различные режимы энергосбережения …

Итак, остался один последний шаг. Сгенерировать исходный код, котрый будет компилироваться и прошиваться в контроллер. На панели сверху есть кнопка “шестеренка с палкой”. Нажимаем ее и …

stmcube14

Заполняем, где будут располагаться файлики и как мы обзовем проект. Так же выберем, для какой среды разработки будет генерироваться исходный текст. Выбор небольшой и все предлагаемые системы – полный шлак (тут конечно у каждого свои фломастеры, но тот же бесплатный CoCox уделывает Keil как бог черепаху), поэтому выберите MDK-ARM, как наиболее описанную в русском интернете.

Если вы запускаете генерацию в первый раз, система предложит скачать Firmware Package именно для вашего процессора. Ждем пока скачает и нагенерирует.

stmcube15

Увидели это окошко? Поздравляю! Вы прошли большую часть пути. Остался еще один шаг. Всего один …

Открываем браузер на https://www.keil.com/download/product/ и выбираем MDK-ARM v5. Вам дадут анкету, в которой реально проверяется только email. Проверяется – в смысле их сервер подключается к вашему серверу и проверяет валидность ящика, поэтому емайлы типа 2@1.co не проходят. Остальное нужно только для того, что бы выбрать, на каком языке потом вам напишет продавец со словами “купите у нас”. Как обычно, у данной версии есть ограничения и самым главным из которых является ограничение в объеме кода в 32 килобайта. Поверьте, это довольно приличный объем для микроконтроллеров и вам его хватит надолго. Но если вас это напрягает, то сами знаете где можно найти вылеченную версию совершенно бесплатно.

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

Как обычно, рассказывать как ставить программы с помощью нажатия кнопки next, я не буду. Единственное, что при первом запуске вылезет Packs Installer – дождитесь, пока он отработает и закрывайте его. Так что ставьте Keil и в той папочке, куда сохранили проект, найдите каталог Projects, в нем MDK-ARM и там ваш файл с типом mVision4 Project. Нажимаем на него …

stmcube16

Я тут его немного сплющил, но вы увидите именно это. Теперь нажимаем на кнопочку, которая во втором ряду, под “открыть”. Похожа на папку для бумаг, в которую входит стрелочка. Ну или на клавиатуре F7. Этим мы запускаем компиляцию всего того, чего мы нагородили выше.

stmcube17

И только после того, как вы увидели в окошке снизу строчку 0 Errors(s), 0 Warning(s) вы можете поздравить себя – у вас есть полностью готовая прошивка для микроконтроллера. Ну и что, что она пока ничего не делает, зато 90% нашей первоначальной задачи уже выполнено. Теперь вы можете идти в магазин и покупать реальный микроконтроллер за реальные деньги. И у вас есть уверенность, что он заработает.

А вот как и что подключать к контроллеру – это уже в следующем посте.

Карпутер. 2. Все не так страшно …

Отписываясь на форумах, я обнаружил что после предложений “давай сделай, это же не сложно” получал в ответ “не, у меня с электричеством плохо, боюсь чего-нибудь сжечь” или другие подобные ответы. Товарищи, господа и пацаны! Поверьте, автомобиль по своей сути – набор проводков, предохранителей и выключателей. Даже “мозги” машины внутри себя состоят из большого количества выключателей. Так что придется сделать отступление и помочь овладеть этими переключателями.

Раз вы читаете это, значит у вас есть компьютер и браузер. Открываете браузер и идете на http://www.labcenter.com/. Там все по английски, но вам нужен раздел Downloads, а там скачать prodemo.exe. В этом здоровом файле находится редактор схем и печатных плат. А так же симулятор этих самых электрических схем. То есть вы можете как угодно “коротить”, “вешать сопли” и развлекаться другими способами: никакого урона электронике вы не нанесете.

proteus_screen

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

Вот тут http://multik.org/carsim/ лежит готовый проект для proteus (просто скачайте файл carsim.dsn и кликните на нем – он откроется в proteus). Он довольно приблизительно имитирует электропроводку обычной машины. Знающие электрику начнут кривить носом и искать ошибки (а они там есть), а незнающие могут нажать слева внизу кнопочку “play” (треугольник вправо, если кто не понял) и поиграться. Поиграться в буквальном смысле: выключатели выключают и включают лампочки, а пипикалка пипикает.

При этом схема полностью отражает реалии: скажем, можно заменить предохранитель на имеющий более низкий номинал (Выделите мышкой предохранитель и нажмите Ctrl-E, там увидите что-то типа 2А) и увидеть, как он сгорает при попытке включить нагрузку.

Итак, что бы было понятно что к чему, пройдусь по схеме слева-направо.

proteus1

Здесь имитация генератора и ключа зажигания (SW1), аккумулятора и отключателя массы (SW2) вместе с главным предохранителем. Вольтметр показывает напряжение в “бортовой сети”.

proteus2

Тут имитация работы ближнего и дальнего света. Переключатель SW3 имеет три положения – выключено, ближний свет и дальний свет. Лампы L1 и L2 отвечают за “ближний”, а L3 и L4 – за “дальний”.

proteus3

Эта часть имитирует салонный свет. 5 выключателей – это концевики дверей и багажника. Пока любой из них замкнут (соответствующая дверь открыта), будет гореть свет в салоне или лампочка L5.

proteus4

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

С последней частью предлагаю разобраться самим, главное громкость поменьше сделайте 🙂

Итак, я буду считать, что наиболее нетерпеливые наигрались, а некоторые даже пошли читать инструкции или даже смотреть (в гугле “proteus начинающим” выдаст все необходимое).

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

Кнопки. Бывают нормально замкнутые (концевики в дверях) и нормально разомкнутые (кнопка сигнала). Принцип простой: нажал, она сменила состояние (замыкала цель – теперь размыкает) и будет в таком состоянии, пока ее не отпустить.

Выключатель. Такой же, как кнопка, только состояние фиксируется (держать не надо)

Переключатель. Полностью аналогичен выключателю, только коммутирует несколько выходов. Пример – SW3 выше. Или замок зажигания.

Енкодер. Тот же переключатель, только после переключения на последний выход начинает с первого. Самое распространенное применение – крутилки громкости на современных магнитолах. Можно вращать в любую сторону сколько угодно раз.

Переменный резистор (он же переменное сопротивление). Штука, меняющая свое сопротивление в зависимости от каких-то условий. Наиболее распространенный пример – датчик уровня топлива. Много топлива – сопротивление маленькое, мало – сопротивление большое.

И … в принципе все. Все остальные датчики можно рассматривать как комбинацию предидущих. Скажем, датчик Холла (используется как датчик скорости в раздатке/коробке и на колесах) – для наших целей это тот же самый переменный резистор, только его переменность зависит от магнитного поля. Датчик температуры – это выключатель или опять же резистор, состояние которых зависит от температуры. Датчик дождя – это резистор, который реагирует на отраженный каплями воды свет от стоящего рядом светодиодика.

Да, особняком стоят всякие OBD, CAN и прочие, но там все в цифре и я этого коснусь потом.

Как читать разные датчики я опишу через пару постов. Сейчас могу упомянуть только то, что из-за нежности микроконтроллеров ничего нельзя подключать “напрямую”.

С обратным управлением все гораздо проще: микроконтроллеры “дохлые” и поэтому без транзисторов/релюшек не обойтись вообще никак. Типовые схемы я тоже опишу.

Согласитесь, совсем не страшно же? Тогда в следующем посту будем выбирать конкретный микроконтроллер под ваши нужды.

Карпутер. 1. Предисловие и выбор микроконтроллера

Хотел начать с обычного отсыла к классике (“этим постом я начинаю …”), но потом передумал. Начну обыкновенно.

Итак, после продажи машины и разборок с банком у меня появилось немного свободного времени, которое тут же начали заполнять мысли о не сделанном и недоделанном. А недоделанного у меня оказалось прилично: от дописывания диагностики машины через OBD и заканчивая переводом “из соплей на скрутках” различных доделок для машины.

С одной стороны, можно просто взять и забить на все это, ибо машины уже нет и тестировать особо не на чем. А с другой стороны, машина потом появится и снова вспоминать, чего не доделано и где это недоделанное валяется? Ну и свободное время позволяет более подробно описать тот путь, который может быть кто-то будет повторять.

Для начала я решил составить список того, что у меня недоделано (просто скопирую из форумных постов)

1) Контроллер второго аккумулятора. Штука с вольтметрами, контролирующая подключение второго аккумулятора. Есть подобная у t-max, но она вся в светодиодиках и тупая. Алгоритм грубо говоря такой: смотрим на напряжение на первом аккумуляторе, как превысило 13В (значит завелись), подключаем второй (для зарядки и теде). Если на первом долгое время 12В, значит можно отключить второй — мы на стоянке. Если ниже, то не отключать — мы лебедимся и второй аккумулятор нужен. Ну и кнопочка принудительного подключения второго, если первый на стоянке разрядился по каким-то причинам. У водителя индикатор с вольтами и кнопочка.

2) “Сумматор баков”. У многих машин есть два источника горючки (скажем, бензин и газ), а у некоторых их три (два бака с бензином и газ). Суть — выводить на штатный указатель уровня сумму уровней баков. Например, от нуля до четверти — первый бак, от четверти до половины — второй и от половины до полного — газ. Или еще как. Дополнительно выравнивание нелинейности датчиков уровня, когда то стрелка не двигается, то начинает падать. И специальная фича для патриотоводов — обработка уровня “приборка пикнула” так, что бы она не пищала при каждом торможении-разгоне.

3) “Корректор спидометра”. Меня напрягает 10-15% погрешность спидометра даже на штатных колесах. Меня напрягает нелинейность этого вранья. И стоит сменить размерность колес, как все привычки типа “раз стрелка на 90, значит я еду 85” приходится “перепривычивать”. Дополнительно была мысль сделать вывод “поехали — включи ближний свет/ДХО”, что бы не дергать переключатели руками и не зажигать фары перед заводом зимой.

4) “удлинитель выключателей”. Грубо говоря — управляемые удаленное релюшки. Например поставил свет вокруг, и к нему вместо кучи силовых проводов тащишь один силовой потолще и один управляющий. Или для компрессора сзади или для усилителя … в общем, везде, где надо управлять чем-то мощным и это мощное далеко от водителя.

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

Но после прикидывания схем внезапно выяснилось, что очень многие функции дублируются. Скажем, для многих применений полезно знать напряжение в бортовой сети. И как индикатор для ответа на вопрос “заведен ли двигатель?” и как точку отсчета для некоторых корректировок. И если собрать 5 схем, то что, к аккумулятору тянуть 5 проводов от разных точек? А как настраивать все это безобразие? Городить кучу кнопок и выключателей и обрамлять все это светодиодами?

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

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

Attiny, они же tinyAVR контроллеры. Основной их плюс – в распространенности. Они существуют в разных корпусах, с разным числом выводов, есть куча примеров схем и кода. Из минусов можно отметить то, что из-за широкой номенклатуры нет решений “все в одном”. И в итоге получается, что даже для изготовления одной схемы надо покупать отдельный программатор, разбираться с фьюзами и прочим. А это все стоит денег (скажем один более-менее приличный программатор стоит на порядок дороже контроллера) и окупается только на десятках собранных схем. Но для простых задач им нет равных.

AtMega или Adrduino. Те же самые плюсы, что и у “тинек”, но добавляется то, что все решения уже идут готовыми. Подключил плату к компьютеру, настучал в окошке код и он уже выполняется. Главный минус же состоит в том, что все эти решения рассчитаны на “сделал максимально быстро, не считаясь с затратами”. Отсюда совершенно дикие цены как на сами платы, так и на модули расширения (shield, шилд). Скажем, самая дешевая плата в классическом (для ардуинки) формате стоит от тысячи рублей, при этом функционала на ней – кот наплакал. А цены на самые дорогие, с чуть-чуть большим набором портов легко упрыгивают за сотню баксов.

Ну и есть у этих плат общие недостатки. Скажем, отлаживать (пошаговое исполнение программ и прочее) можно только с помощью специальных средств (jtag) и то на старших моделях контроллеров. Нет ЦАП, нет всяких околопромышленных интерфейсов (скажем, узнайте, во что встанет подключить к ардуинке контроллер CAN) и так далее и тому подобное.

Следующими идут миниатюрные компьютеры. Paspberry Pi, OLinuXino и так далее. Основной плюс – внутри них работает привычный многим Linux, код можно писать практически на чем угодно и они подключаются к монитору или обычному телевизору. Так как основное предназначение у них тоже самое, что и у ардуинок, то и минусы те же самые – дикие цены как на сами компьютеры, так и на платы расширения к ним. Плюс все эти компьютеры совершенно (ну по сравнению с вышеперечисленным) не имеют портов ввода вывода и обладают диким энергопотреблением.

К этому описанию можно смело добавить разные платы с Android внутри. Плюсы и минусы абсолютно те же самые. Для планшетов еще пойдет, а для встраиваемой электроники – никак.

И наконец, моя нынешняя вершина – микроконтроллеры stm32. У есть один, но очень большой и жирный минус: в них совершенно невозможно разобраться “с наскоку”. Даже простая задача “помигать светодиодиком” для начинающего легко может вылиться в многочасовое копание в документации, которая к тому же вся на английском. Все остальное – сплошные плюсы: от широчайшего арсенала портов и интерфейсов до дикой производительности. Как дополнение – архитектуру stm32 для своих микроконтроллеров используют несколько производителей, поэтому средств разработки – дикие горы, на любой вкус, любую задачу и на любой кошелек.

Скажем, возьму самую дешевую плату для разработки на stm32 – STM32L100C-DISCO. 256 килобайт памяти для программ (ардуинки и прочие уже рыдают), 16 килобайт ОЗУ, работает на 32Мгц, кроме АЦП (16 каналов!) и ЦАП имеет кучу аппаратных(!) интерфейсов типа I2C и 40 с лишним портов ввода-вывода. По меркам stm – это микроконтроллер начального (нет, начальнейшего) уровня. И вот эта плата, с уже готовым программатором и парочкой светодиодиков стоит в два раза дешевле самой дешевой ардуинки.

А стоит сравнять стоимость, как уже можно получить STM32F3DISCOVERY, где добавят гироскоп с компасом, кучку светодиодиков, поднимут объем ОЗУ до 48килобайт и частоту процессора до 72Мгц. После этого увеличат число портов ввода-ввывода практически в два раза и добавят горку аппаратных интерфейсов.

А за цену какой-нибудь arduino mega можно взять офигенный набор разработчика с LCD экраном и дичайшими возможностями.

Более того, подлая st обеспечила более-менее приличную совместимость снизу-вверх. То есть написав программу для “младшего” микроконтроллера, потом с минимальными переделками ее можно перенести на более “старший” микроконтроллер. Нет ни путаницы с обозначениями портов, ни с их функционалом.

Думаю, после этого вам станет понятным, какие микроконтроллеры я буду использовать в дальнейших разработках 🙂

Если вам стало мало avr …

… или добро пожаловать в ад, ардуинщик!

Любой человек, который использует в своих проекта arduino, рано или поздно сталкивается с тем, что ему перестает хватать возможностей имеющегося микроконтроллера. Те, кому просто не хватает ножек, пытаются мигрировать на mega, остальные ищут шилды с необходимым функционалом или начинают изобретать свои. Но любому дрыгоножеству рано или поздно наступает предел: не хватает! Наиболее малодушные спрыгивают на raspberry или другие подобные платы, а считающие что они сильны духом начинают смотреть на другие платформы.

У меня есть и ардуинки и “малинки” и кучка других плат, поэтому я вполне резонно считал, что в микроконтроллерах я далеко не чайник и знаю, с какой стороны пины дергать … В общем, через друзей ко мне поступило предложение сделать довольно простенькую (на фоне уже сделанных проектов) систему. Но на stm32. В памяти сразу всплыла отладочная плата stm32f3discovery, купленная “на сдачу” при очередной закупке и пылящаяся в закромах. Даже не обсудив условия, соглашаюсь: форсированное обучение новой платформе, да еще и на живом проекте, всегда лучше “ну вот посижу вечерком, побалуюсь проектиками …”. Дополнительным бонусом стало изучение микроконтроллеров, на которых построено управление раздаточной коробкой и климатом в моем УАЗе.

Лирическая завлекалка: (из описания) … плата на базе микроконтроллера STM32F303VCT6 включает в себя встроенный отладчик ST-LINK/V2, акселерометр, гироскоп, электронный компас STMEMS, разъем MiniUSB, светодиоды и пользовательские кнопки. Процессор работает на частоте до 72МГц и предоставляет пользователю 90 каналов ввода-вывода. И все это продается за 600 рублей. В одном из самых дорогих магазинов. Аналогичный функционал (ну почти аналогичный: таких скоростей и объемов памяти нет) на ардуине будет стоить около 7-8 тысяч рублей. А отладчиков с аналогичными возможностями на ардуинках вообще нет как класса.

И тут я совершил первую ошибку, впрочем вполне понятную в моем положении: не посмотрел на поддержку микроконтроллера производителем. Ну в самом деле, ведь они делают микропроцессор и плату на нем, а значит должна быть и документация и примеры … Как же я ошибался … В общем, выбрали микроконтроллер и плату просто по необходимому функционалу. Ей оказалась плата STM32L100C-DISCO.

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

Судите сами. Вот кусочек кода:

RCC->APB2ENR |= RCC_APB2Periph_GPIOC;
GPIOC->CRH |=0x33;
GPIOC->CRH &= ~0xCC;
GPIOC->ODR |= (GPIO_ODR_ODR9 | GPIO_ODR_ODR8);
GPIOC->BSRR=(GPIO_BSRR_BS8|GPIO_BSRR_BS9);

Это всего-лишь простейшее зажигание двух светодиодиков.

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

Второе отступление: в отличии от ардуинки, для stm32 есть много вариантов сред для разработки. В результате любая тема “а что выбрать?” довольно быстро превращается в обычный срач. Лично я выбрал бесплатную CooCox. Не без глюков, но все что надо есть.

Вторая ошибка: я считал, что раз микроконтроллеры принадлежат к одной архитектуре, то и программироваться они должны одинаково. Ну грубо говоря если на SMT32F0 какой-то код включает ножку А0 на чтение, то тот же код должен включать ту же ножку и на STM32L1. Хренушки. Все разное даже для микроконтроллеров одной серии, но различающихся разными буковками на конце. Особенно для дополнительного функционала типа таймеров. В результате примеры из интернета в лучшем случае просто не работали (вы когда-нибудь видели неработающий blink на ардуинке? А тут легко!), а в худшем просто не компилировались.

Я было впал в печаль, но решил что я не первый в таком положении, а значит должен быть какой-то выход. И выход был найден практически сразу: SPL. Фирменная библиотека от STmicrosystems.

Еще одно отступление: для других процессоров у ST есть более навороченные и новые библиотеки. Но вот для L – нету. Смотреть на мою первую ошибку.

Радости моей не было предела. Код сразу преобразился в почти читаемый:

GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8|GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init( GPIOC , &GPIO_InitStructure);
GPIO_SetBits(GPIOC, GPIO_Pin_8|GPIO_Pin_9);

Это уже было прорывом. Хоть и были проблемы со всякими константами, но они были вполне понятными: не стоит ожидать скорости работы ножки в 50МГц от контроллера работающего на 32х.

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

На одном из шагов потребовалось прицепиться к контроллеру по обычному ком-порту (USART по импортному). Уже вполне привычные заклинания, аналогичные вышеприведенным и честно спертым из интернета и … и ничего. В смысле вообще ничего.

Попробовал один пример: пусто. Второй: пусто. Начитался про DMA (в stm32 можно сделать так, что бы внутренности микроконтроллера сами отсылали данные, не требуя постоянного присмотра из программы), написал: пусто. Я начал метаться в разные стороны: то пример попробую, то документацию почитаю. Ничего. Не работает.

Тогда я вспомнил, что я вообще-то работаю с железной штукой, а не с обычной программой. Сажусь логическим пробником на порты микроконтроллера и вижу, что что-то он там все-таки передает. Обрадованно кричу “это проблемы на другой стороне, железка по rs232 не хочет работать!”. Тут же сам себя урезониваю: с другими штуками эта железка вполне себе работает. А с моей нет. Значит проблема все-таки у меня …

Достаю осциллограф и смотрю на ножки. Сигналы есть, всякие нолики-единички я вижу очень отчетливо.

Нахожу переходник для компьютера и подключаю. Запускаю терминалку. С контроллера передаю 00, в компьютер приходит 00. Передаю с контроллера 55, в компьютер приходит два байта. Передаю АА, компьютер получает аж три байта! Офигеваю. Даже мрачно.

Еще одно отступление: в принципе всем необходимым арсеналом настоящий ардуинщик обзаводится еще в процессе, но многие обходятся дешевым китайским мультиметром (а то и вовсе живут без него). Тут же очень желательно заиметь осциллограф, даже самый простенький. Более-менее приличные, подключаемые к компу стоят 7-8 тысяч и очень сильно облегчат отладку устройств. Даже хвалимый многими Keil (он умеет рисовать рисуночки происходящего на портах) в некоторых случаях очень сильно лажает.

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

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

Через некоторое время я обнаружил себя тупо играющимся частотой развертки осциллографа. Рисуночек передачи раздвигается-сжимается … а внизу бегают циферки разрешения. Постепенно в мой мозг прямо-таки просачивается мысль “какого хрена этот пик шириной 20мс? он же должен быть 10!”. Лезу в программу, ставлю вместо положенных 115200 скорость 230400, заливаю и вуаля! Все работает! Попрыгав горным козлом по комнате, я стал разбираться, в чем же причина такого поведения.

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

Кратко говоря, все дело было в неправильном указании частоты процессора. Библиотекописатели были уверены, что он работает на 32МГц, а в реальности он работает на 16МГц. А так как в STM32 все (в смысле вообще все) рассчитывается исходя из этого значения, то и usart в реальности работал на скорости 57600 вместо требуемых мне 115200.

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

Прослезившись, я пошел реализовывать следующий по плану функционал: простой АЦП. Программе надо замерить уровень сигнала на одной из ножек и потом согласно этому уровню начать делать свое черное дело. И тут я опять встрял: программа либо висла, либо в ответ возвращала 0. Уже наученный горьким опытом, я посмотрел реальные данные на ножке. Как легко догадаться, они отличались от 0 …

В общем, я мучался. Я страдал и рыдал. Я даже помощи на форумах попросил. Но судя по обилию аналогичных вопросов, я был не одинок. Я даже чуть не смалодушничал и не решил попробовать бэйсик для stm (есть закрытый проект, который позволяет программировать на бейсике, С или паскале. Со своими библиотеками и ни с чем не совместимый).

И снова я решил поразмыслить. Раз я не один такой, кому не нравится шариться вместо документации по заголовочным файлам в поиске ответов, то наверняка же уже есть решения? В принципе да, есть. Любой производитель софта по stm имеет по своей библиотечке, но как-то они вяло их поддерживают …

И тут я натыкаюсь на библиотеку opencm3. С открытыми исходниками, поддерживает мой процессор, как и кучку других и даже примеры есть. Уже наученный горьким опытом, полез в исходники. Библиотека сделана по принципу SPL, но как-то более изящней что ли. То есть библиотека по сути является набором функций-оберток вокруг трахтибидохов с регистрами. Но с документацией. Пусть скудной, пусть не всегда полной, но весь есть что почитать! На фоне остального бардака это выглядело просто изумительно.

В итоге код практически приблизился по внятности к ардуинному:

rcc_periph_clock_enable(RCC_GPIOС);
gpio_mode_setup(GPIOС, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO8 | GPIO9);
gpio_set(GPIOС, GPIO8|GPIO9);

Попробовал на этой библиотеке сделать АЦП – работает. ЦАП – работает. USART – работает. Даже таймеры удалось сконфигурировать без шаманства!

В общем, пока я категорически рекомендую эту библиотеку. Стало сильно проще работать.

Прочитавший это “ардуинщик” легко может ужаснуться и подумать “нафиг-нафиг. лучше я уж потихоньку, полегоньку на старом добром avr переживу”. Зря. Да, ST еще те редиски и специально делают все так, что бы их продукция была доступна только профессионалам, имеющим возможность потратить кучу времени и денег на изучение платформы. Зато в ответ вы получаете доступ к дешевым и мощным микроконтроллерам, которые могут делать столько интересных вещей, которых на avr попросту нет. И поверьте, даже прочитав описание какого-нибудь контроллера типа “имеет 5 таймеров”, вы никогда не узнаете, что с этими таймерами можно делать, пока не попробуете и не залезете в документацию. Ведь архитектура stm позволяет скрещивать функционал внутри самым причудливым образом. И к примеру, можно сделать так, что бы один и тот же таймер в одной прошивке мигал светодиодиком, а в другой читал показания енкодера моторчика …

Как говорится, продолжение следует.