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

7. Часть седьмая, препроцессорно-ассемблерная.

Компилятор gcc — далеко не самая удобная вещь. В частности, когда дело касается ассемблерных вставок. Вы помните, сколько \n\t пришлось написать. Когда речь идет о передаче параметров в ассемблерную вставку и возврате значения, все становится еще муторнее (сюды читать)… Не то, чтобы неподъёмно, но не интересно.

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

Создадим в нашей пользовательской библиотеке файлы MirmPS_assemf.h и Mirm_as.S .
Заголовочный файл «MirmPS_assemf.h», если помните, мы уже подключили в файле MirmPS.h .

MirmPS_assemf.h будет содержать заголовки, необходимые для того, чтобы функция copyContext, описанная в файле Mirm_as.S могла быть распознана препроцессором, линковщиком и компилятором.

Обратите внимание, на расширение Mirm_as.S . По соглашениям, принятым для среды Win никакой разницы между расширениями .S и .s не существует. Но дело в том, что .S — это не расширение, это окончание и ноги у него растут откуда-то со стороны линукса. Компилятор gcc в среде Arduino, настроен так, что файлы .s будут проигнорированы. Поэтому правильный вариант заглавный, Mirm_as.S .

Код файла MirmPS_assemf.h практически полностью состоит из директив препроцессора:

#ifndef _Mirm_Assembler_     //Защита от
#define _Mirm_Assembler_     //двойного подключения

//Общие определения

#ifdef __ASSEMBLER__

//Определения для ассемблера
.equ UDR0, 0xc6    // Эти определения в программе
.equ UCSR0A, 0xc0  // не используются. Приведены,
.equ TXC0, 6       // как пример.

#endif    //#ifdef __ASSEMBLER__

#ifndef __ASSEMBLER__

//Определения не для ассемблера.

#ifdef __cplusplus
extern "C"{             //extern "C" декларирует, что
			//передача параметров
			//в функцию и возвращение результата
	                //должны вестись по соглашениям
	                //языка Си, а не C++.
#endif    //#ifdef __cplusplus

int volatile copyContext(int)__attribute__((naked));

// copyContext:
// Определена, как naked. В данном случае это не обязательно.
// Определена, как volatile. На всякий случай.
// принимает и возвращает int по соглашениям языка Си.

#ifdef __cplusplus
} // extern "C"
#endif    //#ifdef __cplusplus

#endif    //#if not def __ASSEMBLER__

#endif    //#ifndef _Mirm_Assembler_

Это стандартное описание. Так все делают. Комментировать тут можно многое, но лучше поискать в интернетах. В интернетах все подробно и доходчиво.
Единственное, что нас по настоящему интересует, так это конструкция

extern "C"{
       ......
} 

Чтобы ее понять, надо знать, что разные языки программирования при передаче параметров и извлечении результата используют разные способы. Класификатор extern «C» говорит компилятору, передавать в функцию параметры надо как в языке «С» и также возвращать её результат. Называется это — порядок связывания языка «C». Важно понимать, что больше ни на что extern «C» не влияет. Писать функцию при этом можно на любом языке. И такое описание используют для связи с Ассемблером или же Фортраном.

Как же выглядит порядок связывания языка «C»? Для AVR данные будут передаваться в регистрах, с R25 (первый) по R8 (При этом очередной параметр всегда начинается в регистре с четным номером.). То, что не влезает, хитрым образом передается в стеке. Наш int будет лежать в R25:R24. И возвращенный результат, кстати, забираться будет оттуда же. Старший байт будет в R25. Младший в R24.

Теперь сама функция. она хранится в Mirm_as.S :

#include "MirmPS_assemf.h"

.global copyContext  ; Объявление о том, что на точку
                     ; copyContext будут ссылаться извне

copyContext:         ;метка входа в функцию.
mov r30,r24          ;перемещаем полученное значение
mov r31,r25          ;в регистровую пару Z
ldi r29,0x05         ;устанавливаем в регистровую пару
ldi r28,0x00         ;Y адрес 0x0500
ldi r18,35           ;Нам надо отщелкать 35 байтов
		     ;в r18 будет счетчик.

adiw r30,1           ;Инкрементация регистровой пары Z
                     ;нужна по соображениям хитрой
		     ;адресной математики

		     ;С инициализацией закончили.

copyContext_1:	     ;Точка входа рабочего цикла

LD r19,-Y            ;Декрементировать Y, после чего
		     ;ЗАГРУЗИТЬ В регистр r19
		     ;содержимое ИЗ ячейки на которую Y
		     ;ссылается

ST -Z,r19            ;Декрементировать Z, после чего
		     ;ЗАПИСАТЬ ИЗ регистра r19
		     ;содержимое В ячейку на которую Z
		     ;ссылается

dec r18              ;Декрементировать счетчик.
brne copyContext_1   ;Если r18 не равно нулю
		     ;вернуться к точке copyContext_1
		     ; иначе

sbiw r30,1           ;Декрементация регистровой пары Z
                     ;нужна по соображениям хитрой
		     ;адресной математики

mov r24,r30          ;Записываем назад в R25:R24
mov r25,r31          ;Тот адрес на котором мы остановились

ret                  ;Директива возврата из функции 

Как работает эта функция? Копирование осуществляется с помощью механизма косвенной адресации, реализованной в AVR. Этот механизм позволяет регистрам обращаться к ячейке памяти по ее адресу. При этом адрес храниться в одной из регистровых пар X,Y,Z. Это специальные регистровые пары, предназначенные для работы с механизмом косвенной адресации. X это R27:R26. Y это R29:R28. Z это R31:R30.

В Y кладем те адреса, откуда будем копировать. В Z те адреса, куда.
Есть хитрый момент. При косвенном чтении регистровую пару можно автоматически инкрементировать и декрементировать. Но почему-то инкрементация проходит как пост, а декрементация как пред. То есть, значение сперва декрементируется, а уже потом косвенно считывается. А пользуемся мы именно декрементацией.
Поэтому регистр Y ручками устанавливаем не 0x04FF, а в 0x0500 (дабы считать 0x04FF), и к регистру Z также предварительно прибавляем единичку.

Конструкция

dec r18
brne copyContext_1 

Это счетчик цикла.

dec r18 Декрементирует r18.

brne copyContext_1 интересуется, возвращала ли предыдущая операция нулевой флаг (флаги — это биты регистра состояния SREG. Один из них устанавливается при нулевом исходе арифметических операций, таких как dec). Если флаг не установлен, то осуществляет переход назад на начало цикла. Если установлен, то прыжок на copyContext_1 игноририруется и программа покидает цикл.

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

Наконец возвращаем значение в R25:R24 (напоминаю про соглашение связывания языка Си.) и возвращаемся из функции.

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

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

Файлы MirmPS_assemf.h и Mirm_as.S готовы.

Всё… Библиотека написана.
Осталось написать тестовый скетч.

Но прежде немного отвлечеммся и поговорим про оператор goto.

8. Часть восьмая, в которой… Магия…

Функция

void branching(void)
{       setStackPointer(0x04,0xFF);
        branching_2();
        if (Taskcount==0) {Taskcount++;goto *programm1;}
        if (Taskcount==1) {Taskcount++;goto *programm2;}
}

использует оператор goto в форме goto *(func). Не то, чтобы programm1 было обязательно вызывать через goto, но здесь это уместно.

Оператор goto — это самый многострадальный оператор языка Си… В чем его только не обвиняет.
И в том, что из-за него программы не читабельны. И в том, что из-за него компилятор не может эфективно проводить оптимизацию. В том, что он не укладывается в парадигму структурного программирования. В том, что его использование может привести к нарушению логической целостности программы. Последнее, кстати — абсолютная правда я это даже продемонстрирую.

Оператор goto это страшилка. Это то чем матёрые преподаватели пугают бедных студентов. Это как дети и спички. И не надо, мол, лазать там, где не надо лазать.

Но есть вещи пострашнее goto… Например ассемблерные вставки. Те самые, которые мы столь активно используем.

Тут получается какая-то несуразность. Если программист юзает ассемблер — он крут. Если оператор goto — он нуб. Интересно.

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

С точки зрения ассемблера goto может выглядеть как соответствующе оформленный переход на основе дирректив jmp или rjmp, или ijmp.

От ВЫЗОВОВ call,icall,rcall (на основе которых строятся функции) ПЕРЕХОДЫ jmp, rjmp, ijmp отличаются тем, что вызовы возвращают точку вызова в стек, а переходы не возвращают. В этом вся разница.

То есть переход

goto *programm1;

отличается от вызова

programm1();

, тем, что из вызова можно вернуться, а из перехода нет.

Это с точки зрения функциональности. Следует добавить, что компилятор автоматически оформляет вызов какими-то вещами, направленными на сохранение контекста. Переход, что логично, не оформляется.

А что-бы вы получше поняли, чем так опасен оператор goto я приведу пример.

Рассмотрим скетч Ардуино (ту замечательную библиотеку, что мы написали не подключаем. Сейчас она не нужна).

Вот код

void setup(void)
{goto *k;
while(1){};//цикл-ловушка, призванный подвесить программу по выходу из k.
}

void loop(void)
{digitalWrite(13,1);}

void k (void)
{
digitalWrite(13,1);delay(200);digitalWrite(13,0);delay(200);
}

Как вы думаете, что произойдет?… Если бы на месте goto *k; был бы вызов k() ответ был бы очевиден. Программа мигнет диодом и уснет на строке while(1){}, так никогда и не попадя в тело функции loop.

А если goto *k;
Правильный ответ — loop будет вызван. И светодиод, мигнув загорится на постоянной основе.

Механизм работы такой. Ядро Ардуино вызывает функцию

setup()

Которая тут же выполняет переход

goto *k;

Функция

void k (void)
{digitalWrite(13,1);delay(200);digitalWrite(13,0);delay(200);}

Мигает светодиодом и… ВНИМАНИЕ… осуществляет возврат из функции.

«Куда?»,- воскликните вы. Ведь функция k() никогда не вызывалась и в стеке не содержится обратного адреса. Но что-то в стеке есть?

В стеке лежит адрес возврата из последней вызванной функции… функции setup()…

Круто, да?… А после функции setup(), как известно выполняется функция loop().

Вот такая магия.

Так что же… Получается, что мы вернулись из функции setup() по возврату функции k(). А теперь представьте, что функция k() определена как int возвращает какое-то значение. Кому она чего вернет? Функции setup, которая void? Интересно, не так ли…

А давайте наоборот…

Усложним пример:

int a;

void setup() {
Serial.begin(9600);
a=func_int();
Serial.println(a);
}

void loop()
{}

void func_void ()
{}

int func_int () {
 goto *func_void;
 return(222);}

Что мы увидим по Serial интерфейсу?

Как вы, наверное, поняли, я подменил возврат из функции func_int(), который возвращает int возвратом из функции func_void(), которая не возвращает ничего.
Но…

a=func_int();

Переменная «a» думает, что ей возвращают число int… И ищет его в тех регистрах, куда оно должно прийти.

Так что же мы увидим по Serial интерфейсу? Правильный ответ такой: «Всё, что угодно».

Заглянув в Serial, мы можем увидеть электронных человечков, следы информационного шторма, комнату, где малыш компилятор хранит свои игрушки… Может даже ответ на Главный вопрос жизни, Вселенной и всего всего такого.

Лично я увидел «152»…

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

Если дать меч в руки невежды, он много не навоюет. Он лишь покалечит себя и своих товарищей. Только понимая законы работы микроконтроллера, чувствуя и предсказывая действия союзника компилятора, можно полностью отдавшись чувству момента гордо написать goto и единым взмахом разрубить Гордиев Узел логической связности. Ибо величайшая структура — это отсутствие всякой структуры.

8. Часть восьмая, в которой программа запускается.

Повествование подходит к концу.
У нас есть библиотека, в которой лежат 4-ре файла.

И сейчас мы напишем скетч, который проиллюстрирует ее работу.

Стандартный скетч Ардуино состоит из функций

void setup() {
}

void loop() {
}

Но мы функцию main переписали, а потому теперь основа скетча выглядит так:

#include <MirmPS.h>

void setup() {
}

void loop1() {
}

void loop2() {
}

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

Простейший вариант, проверяющий правильность многопоточной работы.

#include <MirmPS.h>

void setup()
{  Serial.begin(9600);
  TIMSK2=1;}

void loop2()
{digitalWrite(13,1);delay(500);digitalWrite(13,0);delay(500);}

void loop1()
{Serial.println("HelloWorld");delay(2000);}

Видите. И светодиод мигает. И HelloWorld отписывается. Обратите внимания, что функции delay() повели себя неожиданно в том плане, что многопоточность совершенно не мешает им корректно отрабатываться. Эта приятная неожиданность объясняется тем, что в среде Arduino delay реализован на системном таймере, а не на пустом цикле.

Что до команды

TIMSK2=1;

, то эта строка включает в работу переключатель контекста, разрешая соответствующее прерывание.

Но это маленькая демонстрация.

А теперь о настоящей двупоточной программе.

Мне понравился осциллограф, представленный в статье.
Он бесподобен. Он состоит из небольшого скетча Ардуино и большого скетча для Processing.

Скетч для процессинга вот (не забудьте вставить в скетч номер своего COM-порта.
Для этого надо модифицировать соответствующим образом строчку
port = new Serial(this,»COM1″, 38400); // Serial.list()[0]):

import processing.serial.*;

Serial port; // Create object from Serial class
int valA;
int valB;
int valC;
int valD;
int valE;
int valF;
// this should have been some kind of 2-diminsional array, I guess, but it works.
int[] valuesA;
int[] valuesB;
int[] valuesC;
int[] valuesD;
int[] valuesE;
int[] valuesF;

PFont fontA;
PFont fontB;

void setup()
{

// make sure you have these fonts made for Processing. Use Tools...Create Font.
// "fontA" is a 48 pt font of some sort. It's what we use to show the "now" value.
  fontA = loadFont("CourierNewPSMT-48.vlw");

// "fontB" is a 14 pt font of some sort. It's what we use to show the min and max values.
  fontB = loadFont("CourierNewPSMT-14.vlw");

// I wouldn't change the size if I were you. There are some functions that don't use
// the actual sizes to figure out where to put things. Sorry about that.
  size(550, 600);

// Open the port that the board is connected to and use the same speed
// anything faster than 38.4k seems faster than the ADC on the Arduino can keep up with.
// So, if you want it to be smooth, keep it at or below 38400. 28800 doesn't work at all,
// I do not know why. If you turn on smooth() you need to drop the rate to 19.2k or lower.
// You will probably have to adjust Serial.list()[1] to get your serial port.
  port = new Serial(this,"COM1", 38400); // Serial.list()[0]

// These are 6 arrays for the 6 analog input channels.
// I'm sure it could have just as well been a 2d array, but I'm not that familiar
// with Processing yet and this was the easy way out.
  valuesA = new int[width-150];
  valuesB = new int[width-150];
  valuesC = new int[width-150];
  valuesD = new int[width-150];
  valuesE = new int[width-150];
  valuesF = new int[width-150];
// the -150 gives us room on the side for our text values.

// this turns on anti-aliasing. max bps is about 19.2k.
// uncomment out the next line to turn it on. Personally, I think it's better left off.
//smooth();
}

int getY(int val)
{
  // I added -40 to this line to keep the lines from overlapping, to
  // keep the values within their gray boxes.
  return (int)(val / 1023.0f * (height-40)) - 1;
}

void draw()
{
  String decoder = "";
  while (port.available() >= 3)
  {
    // read serial until we get to an "A".
    decoder = port.readStringUntil(65);
  }
// sanity check. make sure the string we got from the Arduino has all the values inside.
if ((decoder.indexOf("B")>=1) & (decoder.indexOf("C")>=1) &
(decoder.indexOf("D")>=1) & (decoder.indexOf("E")>=1) &
(decoder.indexOf("F")>=1))
{
  // decoder string doesn't contain an A at the beginning. it's at the end.
  valA=int(decoder.substring(0,decoder.indexOf("B")));
  //println("A" + str(valA));
  valB=int(decoder.substring(decoder.indexOf("B")+1,decoder.indexOf("C")));
  //println("B" + str(valB));
  valC=int(decoder.substring(decoder.indexOf("C")+1,decoder.indexOf("D")));
  //println("C" + str(valC));
  valD=int(decoder.substring(decoder.indexOf("D")+1,decoder.indexOf("E")));
  //println("D" + str(valD));
  valE=int(decoder.substring(decoder.indexOf("E")+1,decoder.indexOf("F")));
  //println("E" + str(valE));
  valF=int(decoder.substring(decoder.indexOf("F")+1,decoder.indexOf("A")));
  //println("F" + str(valF));
  }

  //shift the new values into the array, move everything else over by one
  for (int i=0; i
(не забудьте вставить в скетч номер своего COM-порта.

Для этого надо модифицировать соответствующим образом строчку

  port = new Serial(this,"COM1", 38400); // Serial.list()[0])
Всё. Дело за малым, запустить его на Processing-е.
А что до скетча Ардуино, то он вот:
//
// Oscilloscope
// http://accrochages.drone.ws/en/node/90
//

#define ANALOGA_IN 0
#define ANALOGB_IN 1
#define ANALOGC_IN 2
#define ANALOGD_IN 3
#define ANALOGE_IN 4
#define ANALOGF_IN 5

int counter = 0;

void setup()
{
  Serial.begin(38400);
}

void loop()
{
  int val[5];

  val[0] = analogRead(ANALOGA_IN);
  val[1] = analogRead(ANALOGB_IN);
  val[2] = analogRead(ANALOGC_IN);
  val[3] = analogRead(ANALOGD_IN);
  val[4] = analogRead(ANALOGE_IN);
  val[5] = analogRead(ANALOGF_IN);


  Serial.print( "A" );
  Serial.print( val[0] );

  Serial.print( "B" );
  Serial.print( val[1] );
  Serial.print( "C" );
  Serial.print( val[2] );
  Serial.print( "D" );
  Serial.print( val[3] );
  Serial.print( "E" );
  Serial.print( val[4] );
  Serial.print( "F" );
  Serial.print( val[5] );
}
Маленький, но удаленький...
Чуть чуть изменим его.
Подключим #include MirmPS.h.

В функции setup() добавим строку TIMSK2=1;

Функцию loop переименуем в loop1, а в конец файла добавим еще чуть чуть кода - наш второй процесс.
Вот таким образом:
#include <MirmPS.h>



//
// Oscilloscope
// http://accrochages.drone.ws/en/node/90
//

#define ANALOGA_IN 0
#define ANALOGB_IN 1
#define ANALOGC_IN 2
#define ANALOGD_IN 3
#define ANALOGE_IN 4
#define ANALOGF_IN 5

int counter = 0;

void setup()
{
  Serial.begin(38400);
  TIMSK2=1;
}

void loop1()
{
  int val[5];

  val[0] = analogRead(ANALOGA_IN);
  val[1] = analogRead(ANALOGB_IN);
  val[2] = analogRead(ANALOGC_IN);
  val[3] = analogRead(ANALOGD_IN);
  val[4] = analogRead(ANALOGE_IN);
  val[5] = analogRead(ANALOGF_IN);


  Serial.print( "A" );
  Serial.print( val[0] );
  Serial.print( "B" );
  Serial.print( val[1] );
  Serial.print( "C" );
  Serial.print( val[2] );
  Serial.print( "D" );
  Serial.print( val[3] );
  Serial.print( "E" );
  Serial.print( val[4] );
  Serial.print( "F" );
  Serial.print( val[5] );
}

float j=0;float i=0;

void loop2()
{analogWrite(5,(sin(j)+1)*128);
j=j+PI/720/6; if (j>2*PI) j=0;
analogWrite(6,i);
i=i+0.05; if (i>255) i=0;
}
Как видите, второй процесс чего-то там аналогово вырисовывает.
Я думаю, вы поняли логику. Я собираются одним Ардуино и рисовать аналоговый сигнал во втором потоке и одновременно его считывать в первом потоке.
Однако непосредственно считать не получится, ибо analogWrite, как вы знаете - не аналоговый сигнал, а ШИМ сигнал... Если мы подадим его на осциллограф, то в лучшем случае увидим скачки разной кучности. В худшем - не увидим ничего. Для того, чтобы ШИМ сигнал превратить в настоящий аналоговый сигнал, его надо отфильтровать. В сумме это уже будем цифро-аналоговый  преобразователь.
Схема.



.. Это половина схемы. Вывод номер 5 и еще 3 аналоговых входа подключаются анлогично... Конденсатор у меня на 470 микроФарад резисторы по 100 Ом.
Вот результат работы всей системы:


Что мы тут видим?... Ну во первых, что наш ЦАП - дерьмо. Как только светодиод открывается, он тут же проседает.
Ну, и конечно, что многопоточность работает. Это не может не радовать.
Тоже самое вживую:

Собственно, основное преимущество многопоточности было продемонстрировано. Две не связанные программы без лишних раздумий запустились на одной платформе.
9. Часть девятая. Последняя.
Прежде чем отпустить ваше внимание (если оно еще сохраняется)...
Я должен отметить еще две-три вещи:
Функции ядра Ардуино рассчитаны на работу в режиме постоянных прерываний от системного таймера.

Это значит, что они не критичны к остановам и не разрушаются в многопоточном режиме. Это очень удобно. Если же есть какие-то сомнения, функцию всегда можно сделать атомарной, выполнив перед ней макрос cli(), а после нее макрос sei(). В этом случае на время работы такой функции прерывания будут запрещены.
Если есть переменные, с которыми работают сразу оба процесса, их следует описывать как volatile, а обращения к ним делать атомарными.
О динамическом распределении памяти. Я писал второй стек в кучу. А куча распределяется при динамическом распределении... Если подключить распределение, будет коллапс. Что делать, если нужно динамическое распределение? Это очевидно. Динамически распределить место под стек и писать туда, не забывая, что стек пишется сверху вниз.
И, наконец, третье. Мы сделали два потока. Но никто не мешал сделать три или четыре. Можно повесить переключение контекста на любое прерывание. Никто не мешает создавать потоки динамически по ходу выполнения программы. Не запрещает вводить приоритеты...
И вообще... Мы вольны делать все, что захотим. И это хорошо.
Спасибо.
Баг репорт №1: Чтобы можно было вызывать функции, работающие на основе прерываний (например Wire.endTransmision) из тела функции setup(), необходимо в функции programm1 поменять местами вызовы функции setup() и макроса sei(). Глобальное разрешение прерываний должно идти раньше вызова функции setup().