Arduino.ru

Данный материал предназначен для «настоящих программистов»  , которые, как известно, «не используют Паскаль». Это не значит, что читать его могут только профессионалы. К целевой аудитории относятся и новички, но только те из них, кто в душе «настоящие программисты» и набор необходимых навыков для них лишь вопрос времени.  

Итак, поехали!

Почему-то исторически так сложилось, что скетчи для Ардуино разрабатываются основном на С и С++. Есть конечно, отдельные личности, ратующие за язык ассемблера и небольшая группа сектантов, что-то мямлящих про Паскаль, но общей картины это не меняет – подавляющее большинство программистов для Ардуино - С’онисты. Это факт и спорить с ним бессмысленно.

И факт этот не может не вызывать сожаления у  «настоящих программистов». Ведь в мире существует такое множество прекрасных языков, на которых можно писать замечательные скетчи! Чего, стоит только великий язык INTERCAL с его операторами COMEFROM («получить управление из» - полная противоположность GOTO – шутка разработчиков языка на тему GOTO-фобии), циклами «делать пока» и «не делать пока» и, разумеется, замечательным модификатором PLEASE, позволяющим сделать компилятор и среду исполнения более сговорчивыми. А взять язык, WHITESPACE! Это же не программирование, а поэзия! Вся Ваша программа целиком состоит из пробелов, табуляция и переводов строки! Представляете, как эффектно она выгладит напечатанной на бумаге! По крайней мере, ни одна зараза не сделает Вам замечания, что Вы как-то не так расположили отступы!

Но даже в ряду этих прекрасных языков, есть жемчужины, которые просто не с чем сравнивать. И одной из таких жемчужин, безусловно, является язык программирования BrainFuck ( статья в Википедии со множеством ссылок, группа русскоязычных фанатов языка в ЖЖ ). Название можно перевести на русский язык как «Вынос мозга» и поверьте, язык своё название отрабатывает сполна!

Ресурсы об этом языке легко гуглятся и, если Вы копнёте, то увидите, что он очень популярен – по всему миру проходят конкурсы по написанию программ на нём, много сред разработки, реализации под все платформы и т.д.  Особенно в восторге это этого языка будут новички, поскольку в нём практически отсутствует синтаксис, а стало быть, невозможны синтаксические ошибки, сообщениями о которых С-компилятор выносит новичкам мозг почище всякого BrainFuck’а (справедливости ради, замечу, что одну ошибку там таки можно сделать, но об этом позже).

Итак, что же это за язык?

Программы исполняются на т.н. BrainFuck-машине, которая имеет упорядоченный массив памяти, состоящий из ячеек изначально заполненных нулями. Классически ячейка представляется байтом, но есть реализации и с двух и даже четырёхбайтовыми ячейками. Сам язык не накладывает никаких ограничений. У машины имеется головка считывания/записи, которая всегда находится над какой-нибудь ячейкой, которую называют «текущая ячейка». Ну, и, наконец, имеется 8 команд:

Это всё! Больше в языке нет ничего!

Синтаксис программы очень простой. Команды пишутся последовательно и отделяются друг от друга чем угодно (включая и «ничем»). Любые другие символы (не являющиеся командами) считаются разделителями и просто игнорируются. Это открывает широкий простор для комментирования программ, хотя настоящим программистам комментарии не нужны, т.к. ничто не документирует код лучше, чем сам код :)

Примеры правильных программ на BrainFuck

      >>.<++,- <  [+,<>]
      >>>этот текст ни на что не влияет, просто разделитель >>>+++.---<
   

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

Несмотря на скромное количество команд, язык является алгоритмически полным (при условии бесконечного размера памяти, конечно), а это означает, что на нём можно записать любой алгоритм. Доказательством этого факта я здесь заморачиваться не буду, просто поверьте, что это так. Таким образом, снимаются всякие вопросы о том, а можно ли на нём сделать «то или это». Можно всё, что представимо в виде алгоритма. Заметим, кстати, что горячо любимый С++ тоже алгоритмически полон при условии бесконечной памяти.

Теперь, когда мы познакомились со столь замечательным языком, надеюсь, никто не станет спорить с тем, что сегодня великий день для всего Ардуино – сообщества, т.к. именно сегодня BrainFuck становится доступным для разработки Ардуино-скетчей! Да, да, друзья мои! Я счастлив представить вам первый, простой, но уже вполне функциональный интерпретатор, с помощью которого мы можем писать скетчи на BrainFuck прямо в привычной нам среде Arduino IDE. Уверен, что появление такого замечательного языка в нашем «ящике с инструментами» произведет революцию в написании скетчей! Никогда ещё разрабатывать их не было так легко и приятно, и никогда ещё скетчи не были столь простыми и понятными!

Особенности BrainFuck-машины для Arduino

Несмотря на многочисленные соблазны, было принято решение не дополнять язык никакими Ардуино-ориентированными расширениями и сохранить его в первозданной чистоте. Специфика платформы отражена только в структуре памяти BrainFuck-машины. К ячейкам общего назначения добавлены специальные ячейки, соответствующие портам ввода/вывода Ардуино. В данной реализации интерпретатора поддерживаются двенадцать портов – цифровые пины со второго по тринадцатый включительно. Всего имеется 512 ячеек общего назначения и 12 ячеек-портов. Изначально головка установлена над нулевой ячейкой. Справа от неё остальные 511 ячейки памяти, а слева 12 ячеек соответствующих пинам. Номера пинов растут справа налево.

Поддержка аналоговых пинов, таймеров и всего остального оставлена на будущие версии интерпретатора. Пока у нас есть только цифровые пины.

Перед началом исполнения программы, ячейки общего назначения содержат нули (как и определено в языке), а вот ячейки-порты соответствуют реальному состоянию портов Ардуино: содержат нули, если на соответствующем пине LOW и единицы, если на соответствующем пине HIGH.

Операции «.» и «,» для ячеек общего назначения означают вывод в Serial и ввод оттуда соответственно (ввод сделан без проверки, а есть ли там что-то, просто выполняется read()). Эти же операции для ячеек-портов означают вывод содержимого текущей ячейки в порт (digitalWrite) и ввод состояния порта в текущую ячейку (digitalRead).

Интерпретатор реализован в виде библиотеки, содержащей всего одну функцию BrainFuck с единственным параметром типа char *. Параметр – собственно программа на BrainFuck (в виде строки), которую необходимо выполнить. Функция возвращает:

BF_SUCCESS - если программа выполнилась успешно
BF_PROGRAM_UNDERFLOW – если отсутствует открывающая [
BF_PROGRAM_EXHAUSTED – если отсутствует закрывающая ]
BF_MEMORY_UNDERFLOW – если операция > вышла за пределы памяти
BF_MEMORY_EXHAUSTED – если операция < вышла за пределы памяти

Константы определены в файле BrainFuck.h

Для того, чтобы всё заработало необходимо установить библиотеку. Для этого в папке libraries нужно создать папку BrainFuck и поместить в неё два файла: BrainFuck.cpp и BrainFuck.h

Текст файла BrainFuck.cpp

#include <arduino.h>
#include <string.h>
#include "brainfuck.h"

#define	PINS_MEMORY_SIZE	12
#define	DB_MEMORY_SIZE	(DB_MEMORY + PINS_MEMORY_SIZE)

BFResult BrainFuck(char * bfProgram) {
	static char bfMemory[DB_MEMORY_SIZE];
	int memPtr = PINS_MEMORY_SIZE;
	int loopCounter = 0;
   //
   // Инициализация памяти
	memset(bfMemory + PINS_MEMORY_SIZE, 0, DB_MEMORY);
	for (int8_t i = 2; i < 14; i++) bfMemory[PINS_MEMORY_SIZE + 1 - i] = digitalRead(i);
   //
   // удаление из строки-программы всех символов кроме <>+-.,[]
	static const char * bfCommands = "<>+-.,[]";
	char *p = bfProgram;
	for (int ncmd = strspn(p, bfCommands); ncmd < (int)strlen(p); ncmd = strspn(p, bfCommands)) {
		p += ncmd;
		strcpy(p, p + strcspn(p, bfCommands));
	}
   //
   // Собственно цикл интерпретатора
	const int programSize = strlen(bfProgram);
	for (int progPtr = 0; progPtr < programSize; progPtr++) {
		switch (bfProgram[progPtr]) {
			case '>':
				memPtr++;
				break;
			case '<':
				memPtr--;
				break;
			case '+':
				bfMemory[memPtr]++;
				break;
			case '-':
				bfMemory[memPtr]--;
				break;
			case '.':
				if (memPtr < PINS_MEMORY_SIZE) digitalWrite(PINS_MEMORY_SIZE + 1 - memPtr, bfMemory[memPtr]);
				else Serial.print(bfMemory[memPtr]);
				break;
			case ',':
				if (memPtr < PINS_MEMORY_SIZE) bfMemory[memPtr] = digitalRead(PINS_MEMORY_SIZE + 1 - memPtr);
				else bfMemory[memPtr] = Serial.read();
				break;
			case '[':
				if (!bfMemory[memPtr]) {
					loopCounter++;
					while (loopCounter) {
						if (++progPtr >= programSize) return BF_PROGRAM_EXHAUSTED;
						if (bfProgram[progPtr] == '[') loopCounter++;
						else if (bfProgram[progPtr] == ']') loopCounter--;
					}
				}
				break;
			case ']':
				if (bfMemory[memPtr]) {
					loopCounter++;
					while (loopCounter) {
						if (--progPtr < 0) return BF_PROGRAM_UNDERFLOW;
						if (bfProgram[progPtr] == '[') loopCounter--;
						else if (bfProgram[progPtr] == ']') loopCounter++;
					}
					if (--progPtr < -1) return BF_PROGRAM_UNDERFLOW;
				}
				break;
		}
		if (memPtr < 0) return BF_MEMORY_UNDERFLOW;
		if (memPtr >= DB_MEMORY_SIZE) return BF_MEMORY_EXHAUSTED;
	}
	return BF_SUCCESS;
}

Текст файла BrainFuck.h

#ifndef	BRAINFUCK_H
#define	BRAINFUCK_H

#define DB_MEMORY	512

typedef enum { 
	BF_SUCCESS = 0,
	BF_PROGRAM_UNDERFLOW,
	BF_PROGRAM_EXHAUSTED,
	BF_MEMORY_UNDERFLOW,
	BF_MEMORY_EXHAUSTED
} BFResult;


//
// ВНИМАНИЕ!!!
// Функция изменяет переданную ей строку-аргумент
// а именно удаляет из неё все символы, не являющиеся 
// командами языка BrainFuck
//
BFResult BrainFuck(char *);

#endif	//	BRAINFUCK_H

Вот собственно и всё. Добро пожаловать в славную семью брейнфакеров!

Как это работает?

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

1. вывести в Serial 0 (не символ ‘0’, а именно число 0)

Поскольку изначально в ячейках нули, то нужно просто вывести текущую ячейку операцией «.»

#include <BrainFuck.h>

void setup(void) {
   Serial.begin(115200);
   BrainFuck(".");
}

void loop(void) {}

2. вывести в Serial символ ‘0’

Поскольку изначально в ячейках нули, а код символа ‘0’ – 48, то можно 48 раз увеличить текущую ячейку на 1, а затем вывести её значение операцией «.» (это простейший способ, но программу можно сделать гораздо короче, если воспользоваться циклом)

#include <BrainFuck.h>

void setup(void) {
      Serial.begin(115200);
      BrainFuck("++++++++++++++++++++++++++++++++++++++++++++++++.");
}

void loop(void) {}

Можете запустить и полюбоваться на нолик в мониторе порта.

3. Включить светодиод на пине 13

Изначально головка стоит напротив ячейки 0 (см. рисунок выше). Чтобы перевести её к ячейке соответствующей пину 13, необходимо сдвинуть её влево на 12 позиций. Затем можно увеличить содержимое текущей ячейки на 1 и вывести её в порт операцией «.». Если светодиод перед этим не горел (в ячейке был 0), то он загорится. Если же горел (в ячейке была 1), то он будет продолжать гореть.

#include <BrainFuck.h>

void setup(void) {
      BrainFuck("<<<<<<<<<<<<+.");
}

void loop(void) {}

Любуйтесь.

Примеры программ

Теперь перейдём к примерам более или менее реальных программ.

Обычно принято начинать с примера «Hello, World!». В Ардуино роль «Hello, World!» играет «Blink» и правильно было бы начать с него, но из большого уважения к сообществу С’онистов, которые скоро могут официально стать ажно целым этносом, я всё-таки начну с классического «Hello, World!», тем более, что мне это ничего не стоит, т.к. программу я попросту стащил с Википедии ничего в ней не меняя.

«Hello, World!»

Программа выводит в Serial фразу «Hello, World!». Комментировать я её не буду, т.к. она буквально посимвольно разобрана в Википедии, кому интересно, смотрите подробный разбор там.

#include <BrainFuck.h>

///////////////////////////////////////////////////////////
//
//	Программа на BrainFuck 
//	Выводит в Serial строку "Hello, World!"
//
static char * bfHelloWorld = (char *)
	"++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++"
	".>+.+++++++..+++.>++.<<+++++++++++++++.>.+++."
	"------.--------.>+.>.";

void setup(void) {
	Serial.begin(115200);
	BrainFuck(bfHelloWorld);
}

void loop(void) {}

Обратите внимание, как лаконично, строго и законченно выглядит текст на BrainFuck! Такая простота, лаконичность и ясность просто недостижима в языках типа С, не правда ли?

«Blink»

Теперь, когда долг исполнен и мир поприветствован, давайте помигаем светодиодом – это ведь наше любимое занятие, не правда ли? Задача разбивается на две: инвертировать светодиод и подождать задержку. Если это сделать, то можно вставлять всё это в loop и радоваться.

Давайте думать, как это сделать. У меня вот такая идея по поводу инвертирования:

1) ячейку 0 используем для индикации нужно или нет зажигать светодиод. Сначала поместим туда единицу (типа, нужно).

2) пойдём к ячейке 13-го пина и если в ней 0 (светодиод не горит), то ничего делать пока не будем, а вот если 1 (светодиод горит), то погасим его и обнулим ячейку 0

3) теперь идём к ячейке 0 и, если в ней не 0 (светодиод нужно зажигать), то зажигаем его.

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

Вот что получилось (видит Бог, комментирование заняло втрое больше времени, чем написание):

#include <BrainFuck.h>

///////////////////////////////////////////////////////////
//
//   Программа на BrainFuck 
//   Обыкновенный Blink с частотой приблизительно 1Гц
//   программу нужно просто вставить в loop
//
static char * bfBlink = (char *) ""
//
//Инвертируем пин 13
//
   "+"               // в ячейку №0 пока запишем 1, впредь там будет 1, если светодиод надо зажечь и 0 если нет
   "<<<<<<<<<<<<"    // топаем к ячейке 13го пина
   "["               // ЕСЛИ там не 0 (на пине HIGH) ТО
      "-"            //    делаем его нулём 
      "."            //    и выводим 0 (LOW) на пин
      ">>>>>>>>>>>>" //    топаем обратно к ячейке №0
      "[-]"          //    обуляем ячейку №0 (это признак того, что светодиод зажигать не надо)
      "<<<<<<<<<<<<" //    возвращаемся обратно и пину 13
      "[-]"          //    обнуляем текущую ячейку, чтобы выйти из цикла
   "]"               // выход из цикла (этим циклом мы смоделировали IF) 
//   
//   К этому моменту головка стоит на ячейке пина 13
//   В ячейке №0 находится 1, если светодиод надо зажигать
//   или 0, если светодиод зажигать не надо
//   
   ">>>>>>>>>>>>"    // топаем к ячейке №0
   "["               // ЕСЛИ там не 0 (надо зажигать светодиод) ТО
      "<<<<<<<<<<<<" //    топаем к ячейке 13го пина
      "+"            //    увеличиваем её на 1 (теперь там 1)
      "."            //    записываем 1 (HIGH) в порт
      "[-]"          //    обнуляем текущую ячейку чтобы выйти из цикла
   "]"               // выход из цикла (этим циклом мы смоделировали IF) 
//   
//   К этому пин 13 нивертирован Если там было HIGH то стало LOW и наоборот
//   
//   Теперь нужно отработать задержку
//   Поскольку у нас нет длоступа к слубам времени и темаерам
//   будем отрабатывать задержку просто циклом
//   
//   Сделаем 5 вложенных циклов Эмпирически подобрано так чтобы 
//   частота блинка была 1Гц
//   
   "+++++++"               // Увеличиваем текущую ячеку на 7
   "["                     // ЕСЛИ там не 0 ТО
      ">++++++++"          //    переходим к соседней (вправо) ячейке и увеличиваем её на 8
      "["                  //    ЕСЛИ там не 0 ТО
         ">++++++++"       //       переходим к соседней (вправо) ячейке и увеличиваем её на 8
         "["               //       ЕСЛИ там не 0 ТО
            ">++++++++"    //          переходим к соседней (вправо) ячейке и увеличиваем её на 8
            "["            //          ЕСЛИ там не 0 ТО
               ">++++++++" //             переходим к соседней (вправо) ячейке и увеличиваем её на 8
               "[-]"       //             обнуляем текущую ячейку чтобы выйти из цикла
               "<-"        //             возвращаемся в ячейку на шаг влево и уменьшаем её на 1
            "]"            //          конец цикла
            "<-"           //          возвращаемся в ячейку на шаг влево и уменьшаем её на 1
         "]"               //       конец цикла
         "<-"              //       возвращаемся в ячейку на шаг влево и уменьшаем её на 1
      "]"                  //    конец цикла
      "<-"                 //    возвращаемся в ячейку на шаг влево и уменьшаем её на 1
   "]";                    // конец цикла 


void setup(void) {
   pinMode(13, OUTPUT);
}

void loop(void) {
   BrainFuck(bfBlink); 
}

В принципе, это программа работает (запустите и проверьте), но вот выглядит она совсем не по BrainFuck’овски. С точки зрения идейно-выдержанного BrainFuck’а это и не программа вовсе, а просто «шозанах» какой-то! Правильная, идейно-выдержанная программа на BrainFuck должна выглядеть вот так:

#include <BrainFuck.h>

///////////////////////////////////////////////////////////
//
//	Программа на BrainFuck 
//	Обыкновенный Blink с частотой прибл. 1гц
// программу нужно просто вставить в loop
//
static char * bfBlink = (char *) 
	"+<<<<<<<<<<<<[-.>>>>>>>>>>>>[-]<<<<<<<<<<<<[-]]"
	">>>>>>>>>>>>[<<<<<<<<<<<<+.[-]]+++++++[>+++++++"
	"+[>++++++++[>++++++++[>++++++++[-]<-]<-]<-]<-]";

void setup(void) {
	pinMode(13, OUTPUT);
}

void loop(void) {
	BrainFuck(bfBlink); 
}

Делает она тоже самое, что и предыдущая, но выглядит так, как и должны выглядеть программы на BrainFuck написанные настоящими программистами!

Предыдущий пример всем хорош, но он требует, чтобы программа на BrainFuck вызывалась из loop() и у случайного читателя (не у настоящего программиста, конечно) может возникнуть подозрение, что нам слабо организовать бесконечный цикл на самом BrainFuck. Спешу разочаровать – таки нет, не слабо! Более того, легко. Смотрите.

#include <BrainFuck.h>

///////////////////////////////////////////////////////////
//
//	Программа на BrainFuck 
//	Модификация Blink с частотой прибл. 1Гц
// не нуждается во внешнем цикле loop
//	её достаточно вставить в setup - сама будет
// мигать, т.к. цикл в ней уже есть свой
//
static char * bfBlinkL = (char *)
   "+[>"                                              // Внешний цикл 
   "+<<<<<<<<<<<<<[-.>>>>>>>>>>>>>[-]<<<<<<<<<<<<<[-" //    Эти две строки инвертируют 
   "]]>>>>>>>>>>>>>[<<<<<<<<<<<<<+.>>>>>>>>>>>>>[-]]" //      цифровой пин 13	
   "+++++++[>++++++++[>++++++++[>++++++++[>++++++++[" //    Эти две строки дают задержку
   "-]<-]<-]<-]<-]"                                   //      для блинка
   "<]";                                              // Конец внешнего цикла 

void setup(void) {
	pinMode(13, OUTPUT);
	BrainFuck(bfBlinkL);
}

void loop(void) {}

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

Ну, и последний на сегодня пример – обработка нажатия кнопки. Допустим, к 12-му пину подключена кнопка. Пин притянут к земле и при нажатии кнопки на нём появляется HIGH. Задача – зажигать светодиод на 13-ом пине тогда, когда кнопка нажата и гасить, когда не нажата. Комментировать пример я не стал – оставляю читателю самому разобраться. Пример вполне работоспособный, можете загрузить и попробовать.

#include <BrainFuck.h>

///////////////////////////////////////////////////////////
//
//	Программа на BrainFuck 
//  Зажигает светодион на пине 13, если на пине 12 HIGH
//  и гасит, если там LOW. Нужно вставить в loop()
//
static  char * bfButton = (char *)
   "+<<<<<<<<<<<[<+.>>>>>>>>>>>>[-]<<<<<<<<<<<[-"
   "]]>>>>>>>>>>>[<<<<<<<<<<<<[-].>>>>>>>>>>>>[-]]";

void setup(void) {
   pinMode(13, OUTPUT);
   pinMode(12, INPUT);
}

void loop(void) {
   BrainFuck(bfButton); 
}

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

Конеыно, интерпретатор неполностью поддерживает платформу и нуждается в расширении (аналоговые пины, служба времени, прерывания и т.п.). Также не помешал ьы и компилятор непосредственно в коды AVR. Ну, и может быть аппаратная реализация BrainFuck-машины, но это уже выходит за рамки Ардуино. Но всё это потом. И только в том случае, если язык наберёт достаточное количество сторонников в чём я лично, учитывая необычайную простоту, красоту и выразительную мощь этого языка, нисколько не сомневаюсь!