*** ВНИМАНИЕ: Блог переехал на другой адрес - demin.ws ***

суббота, 7 апреля 2012 г.

Блог переехал

Уважаемые читатели!

После некоторой работы, блог переезжает. Новый адрес - http://demin.ws/

Детали переезда - как, что, почему и все остальные спетни королевского двора буквально скоро. 

Технически все существующие посты и каменты перенесены и должны работать как и раньше.

RSS для русских постов - http://demin.ws/atom.xml

RSS для английских постов - http://demin.ws/english/atom.xml

Замечания и проблемы: alexander@demin.ws

среда, 7 марта 2012 г.

NOR Machine in Ruby

My article about a virtual CPU, a machine, computing only one instruction - NOR, is The Pragmatic Bookshelf magazine.

The idea was previously described in a series of posts:

понедельник, 6 февраля 2012 г.

Born by copy-paste

I usually start crying when see a copy-paste with numbered variables. A probability to screw up is very high, just forget to change a single number after pasting. Here is a horrifying piece of code (don't you mind to spot on an incy wincy typo?)

void Test_SplitPair() {
  typedef std::pair<std::string, std::string> Pair;
  using string::SplitPair;

  const Pair p1 = SplitPair("", '=');
  assert(p1.first.empty());
  assert(p1.second.empty());

  const Pair p2 = SplitPair("=", '=');
  assert(p2.first.empty());
  assert(p2.second.empty());

  const Pair p3 = SplitPair("name=value", '=');
  assert(p3.first == "name");
  assert(p3.second == "value");

  const Pair p4 = SplitPair("name = value", '=');
  assert(p3.first == "name");
  assert(p3.second == "value");

  const Pair p5 = SplitPair(" n ame  \t =  va lue  \r\n", '=');
  assert(p5.first == " n ame  \t ");
  assert(p5.second == "  va lue  \r\n");
}

Any ways to make to better? The ideal solution is to split to multiple tests. But even less radical approach works to avoid copy-paste problems:

void Test_SplitPair() {
  typedef std::pair<std::string, std::string> Pair;
  using string::SplitPair;
  {
  const Pair p = SplitPair("", '=');
  assert(p.first.empty());
  assert(p.second.empty());
  }
  {
  const Pair p = SplitPair("=", '=');
  assert(p.first.empty());
  assert(p.second.empty());
  }
  {
  const Pair p = SplitPair("name=value", '=');
  assert(p.first == "name");
  assert(p.second == "value");
  }
  {
  const Pair p = SplitPair("name = value", '=');
  assert(p.first == "name");
  assert(p.second == "value");
  }
  {
  const Pair p = SplitPair(" n ame  \t =  va lue  \r\n", '=');
  assert(p.first == " n ame  \t ");
  assert(p.second == "  va lue  \r\n");
  }
}

Рожденный копипастом

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

void Test_SplitPair() {
  typedef std::pair<std::string, std::string> Pair;
  using string::SplitPair;

  const Pair p1 = SplitPair("", '=');
  assert(p1.first.empty());
  assert(p1.second.empty());

  const Pair p2 = SplitPair("=", '=');
  assert(p2.first.empty());
  assert(p2.second.empty());

  const Pair p3 = SplitPair("name=value", '=');
  assert(p3.first == "name");
  assert(p3.second == "value");

  const Pair p4 = SplitPair("name = value", '=');
  assert(p3.first == "name");
  assert(p3.second == "value");

  const Pair p5 = SplitPair(" n ame  \t =  va lue  \r\n", '=');
  assert(p5.first == " n ame  \t ");
  assert(p5.second == "  va lue  \r\n");
}

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

void Test_SplitPair() {
  typedef std::pair<std::string, std::string> Pair;
  using string::SplitPair;
  {
  const Pair p = SplitPair("", '=');
  assert(p.first.empty());
  assert(p.second.empty());
  }
  {
  const Pair p = SplitPair("=", '=');
  assert(p.first.empty());
  assert(p.second.empty());
  }
  {
  const Pair p = SplitPair("name=value", '=');
  assert(p.first == "name");
  assert(p.second == "value");
  }
  {
  const Pair p = SplitPair("name = value", '=');
  assert(p.first == "name");
  assert(p.second == "value");
  }
  {
  const Pair p = SplitPair(" n ame  \t =  va lue  \r\n", '=');
  assert(p.first == " n ame  \t ");
  assert(p.second == "  va lue  \r\n");
  }
}

четверг, 2 февраля 2012 г.

Вiased review of "Seven languages in seven weeks"

I have finished accelerated reading of "Seven languages in seven weeks" by Bruce Tate.

http://demin.ws/images/covers/english/7-languages-in-7-weeks-cover.jpg

In my case it was "Seven languages in seven evenings". For each language there is an introduction, which makes sense only if a language is brand new for you. There are also interviews with creators of the languages. One of the asked interesting questions was about what the author would like to change in the language if he could re-design it from scratch now.

Languages:
  • Ruby
  • Io
  • Prolog
  • Scala
  • Erlang
  • Clojure
  • Haskell
The reviews of each chapter below are my subjective views two things at once: a programming language and a material about it. Why? For familiar languages it hardly makes any sense to describe the language per se, but to note interesting distinctive features could be useful. But if a languages is a green field, it is worth describe it in general.

Ruby

The Ruby chapter was quite useless for me because I thoughtfully read "Programming Ruby 1.9", and have been hooked. Ruby is an amazing scripting language. Each time when programming in Ruby I feel so delighted similar to when I tried PHP first time after Perl.

Ruby's creator, Yukihiro Matsumoto, says in the interview, that if he could re-design Ruby today, he'd like to change the concept of multi-threading to "Actor".

In short, "Actor" is when concurrent threads don't share memory and don't use mutex or semaphores for synchronization. Instead, they send and receive messages to each other, and messaging is provided by runtime and built-in to the languages syntax. Examples: Scala, Go, Erlang, Io.

Io

Io is a very small, compact language, based on prototypes like JavaScript, where there is no distinction between classes and objects.

There is an interesting concurrency feature in addition to actors and coroutines (cooperative multi-threading as in Lua), called futures. "Futures" are similar to the actor. There the only difference is when the caller thread tries to use the result of the future, it will be blocked until the future completes and gives the result back.

An example from the book:

// Fire up the future.
futureResult := URL with("http://google.com/") @fetch
writeln("Continue immediately when future is running in background.")
// This line will be executed immediately after spawning the future.
writeln("fetched ", futureResult size, " bytes")
// But this line will be blocked until the future returns.

Prolog

I've been gnawing this animal for years. But thanks to Erlang recently, all this functional stuff in general is now giving up for me, and monsters like Prolog or Haskell don't look so scary anymore.

It turned out that the depth of the material about Prolog has matched precisely with my level. The eight queens problem and a Sudoku solver were excellent examples for me.

Shortly, a program in Prolog is a pile of facts and rules. Then the Prolog runtime performs a depth-first search amongst possible results and tries to find those satisfying all the given facts and rules.

In fact, the Sudoku solver program is a set of variables, representing the Sudoku field, and a list of rules (summations by columns, rows and squared groups) according to the rules of Sudoku. Then Prolog performs an exhaustive search to find the values and their combinations satisfying the rules.

Of course, this is very much a superficial glance, but this has given me much more understanding of Prolog.

Scala

I will note only a few facts interesting to me.

Multi-threading is based on actors. After Erlang and Go you understand how good and handy it is. I think that Scala has all possible bells and whistles even invented for programming languages. But sometimes it has not only good consequences.

Erlang

I'm a big fan of Erlang and already read a few big books. That's why this book hasn't given to me anything new. But for novices this introduction may give quite solid view on Erlang functional approach and concurrency model.

Clojure

Clojure is a Lisp-based language driven by Java VM.

It has an interesting feature called STM, software transactional memory. In STM a piece of code is declared to be a transaction. It is executed atomically or all the changes of variables are rolled back.

And finally, Haskell

Haskell is a taught guy. The introduction in this book is very light and minimal, just to remember the word "Haskell". I read "Programming in Haskell" and currently I'm on "Real World Haskell", that's why I simply skimmed the chapter in this book.

Okay, to sum up. This book is to be read just once, to broaden your outlook.

Предвзятое мнение о книге "Seven languages in seven weeks"

Закончил ускоренное чтение по диагонали книги "Seven languages in seven weeks", автор Bruce Tate.

http://demin.ws/images/covers/english/7-languages-in-7-weeks-cover.jpg

В моей версии это было "Семь языков за семь вечеров". Для каждого языка дается минимальное введение, которое имеет смысл только если язык для вас вообще новый. Еще приводятся мини интервью с создателями языков, и один из интересных задаваемых им вопросов - это "чтобы вы сделали в языке иначе, если б можно начать сначала".

Описываются языки:
  • Ruby
  • Io
  • Prolog
  • Scala
  • Erlang
  • Clojure
  • Haskell
Обзор каждой главы - это мой субъективный взгляд на две вещи сразу: язык программирования и материал главы про него. Объясню почему - для знакомых языков вряд ли имеет смысл описывать сам язык. Может имеет смысл отметить интересные отличительные моменты. А вроде для неизученных, типа Пролога или Clojure, можно и остановиться немного на самом языке.

Ruby

Про Ruby ничего особенно из книги не вынес, так как вдумчиво читал "Programming Ruby 1.9", после чего подсел на этот язык. Ruby - фантастический скриптовой язык. Каждый раз, когда пишу на нем, испытываю удовольствие примерно такое, когда я после Perl'а попробовал в первый раз PHP.

Автор языка сказал в интервью, что, создавая бы язык заново сегодня, он бы хотел для многопоточности вместо традиционных потоков сделать модель "actor".

В двух словах, Actor - это когда параллельные потоки разделяют ресурсы не через память и механизмы синхронизации типа мьютексов и семафоров, а через обмен сообщениями, прием и посылка которых обеспечиваются средой, и они встроены в синтаксис языка. Например, как в Scala, Go, Erlang, Io.

Io

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

Интересный механизм многопоточности в дополнение к actor и coroutine (коллективная многозадачность, как в Lua), называемый futures. "Futures" - это вроде бы как обычный actor, поток запущенный работать параллельно. Но с одним отличием: как только создающий поток попытается воспользоваться результатом future, он будет заблокирован до тех пор, пока future не вычислит это значение.

Примерчик из книги:

// Запускаем future
futureResult := URL with("http://google.com/") @fetch
writeln("Сразу начинаем делать что еще, пока future работает в фоне.")
// Эта строка будет выполнена сразу.
writeln("fetched ", futureResult size, " bytes")
// А вот эта строка будет заблокирована, пока future не выполнится.

Идем дальше, Prolog.

Этого зверя я грызу давно. К счастью, благодаря освоению Erlang'а, я стал реально въезжать в функциональную тему в целом, и монстры типа Пролога или Хаскелла уже не за пределами понимания.

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

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

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

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

Идем дальше, Scala.

Отмечу только отдельные факты, интересные мне.

Многопоточность на основе actors, то есть когда потоки обмениваются сообщениями. После Go и Erlang понимаешь как это удобно и правильно.

Про остальное - по-моему в Scalа есть все возможные свистелки и перделки, когда-либо придуманные в области языков программирования. В общем, если вы фанат Java VM, то надо брать полноценную книгу по Scala и грызть ее.

Идем далее, Erlang.

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

Clojure

Снова язык на основе Java VM. Clojure - это разновидность Лиспа со всеми вытекающими.
Интересная возможность языка, в общем-то не связанная с его лисповой сущностью - это STM, software transactional memory. Это когда некий кусок кода в программе объявляется транзакцией, и он выполняется атомарно, либо все изменения откатываются.

Ну и под занавес, Haskell.

Хаскелл суров, и данная книга - это крайне минимальное введение, просто для запоминания слова Хаскелл. Я кое как осилил отличную книгу Душкина и "Programming in Haskell", а сейчас читаю "Real World Haskell", поэтому главу этой книги просто пролистал.

Вывод: книга 100% одноразовая, но, как говориться, раз не... полезно для кругозора и для программистских терок на кухне.

понедельник, 30 января 2012 г.

My current languages

I have realised recently that I like to learn new programming languages. A symptom is a very easy to spot: I have a permanent pile of books I am reading. Thanks for the iPad, I can have them all with me all the time and choose depending on mood. Surprisingly, but books about languages are being read first and replaced with new ones.

Simply wanted to share current interests.

Everyday work (design, planning, coding and reviews): C and C++. C++ 0x11 goes at full speed and it is worth to catch up. ACCU 2012 is almost fully dedicated to the new C++.

For fun:

  • scripting - Ruby
  • a server side and multi-threading: Erlang and Go
  • embedded: Lua and Scheme

To "gnaw" in hope to write something real - Haskell and Prolog.

In a queue at least minimum acquaintance: Clojure. This one is more promising because it is Lisp.

After overall migration to Mac, I wish to try Objection-C and AppleScript in action. But what to write on Mac, in Objective-C? Of course, UI! But UI is totally out of my interests. But, Objective-C still looks tempting because of so quickly growing mobile apps market.

From recently touched, but not involved:

  • Scala - a sophisticated language requiring a "deep dive", and without a real suitable problem the interest is gone. Twitter is already re-written in Scala ;-).
  • Racket - an interesting Lisp based animal on steroids of a very powerful library.

Мои текущие языки

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

Просто хотел поделиться текущими интересами.

Каждодневная работа (проектирование, планирование, кодирование и ревью): C и С++. Тут C++ 0x11 полным ходом, и надо подтягиваться. ACCU 2012 в этом году посвящен в основном новому C++.

Для души:

  • скриптование - Ruby
  • серверное и многопоточное - Erlang и Go
  • встраивание сценариев - Lua и Scheme

Для "погрызть" в надежде когда-нибудь написать что-нибудь реальное - Haskell и немного Пролог (тут надежд совсем мало).

В очереди на хотя бы минимальное ознакомление: Clojure. Тут надежд больше, так как это все-таки Lisp.

С общей недавней миграцией на Мак хочется попробовать в действии Objective-C и AppleScript. А что еще писать на Маке, да еще и на Objective-C? Конечно UI! А UI это на 200% не мой профиль. Но, если серьезно, сложно загасить внутреннюю хотелку освоить Objective-C, когда тут вокруг всякие iOS'ы.

Из недавнего ознакомленного, но в которое не втянулся:

  • Scala - большой язык, требующий погружения и, без реальной подходящей задачи как-то нет запала. Ну не Твиттер же новый писать? ;-).
  • Racket - вот этот зверь мне очень понравился как лисповый язык с мощной библиотекой всего. Но как обратная сторона, язык получился большой, как Scala, и как-то пока не подвернулось подходящей интересной задачи.

четверг, 26 января 2012 г.

Graph visualization in DOT / Визуализация графов в языке DOT

The English version of the post is below.

Предыстория. Мы обрабатываем финансовые транзакции. Возникла задача профилирования. Решили записать путь прохода транзакции по системе и построить граф связей между модулями - кто кого вызывает. Два способа построения: на основе статического анализа исходников и через трассировку реальных вызовов во время выполнения.

Итак, связи зафиксированы. Теперь их надо их как-то представить и построить граф, визуально.

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

Есть такой язык представления графов, называется DOT. Прелесть его в предельной простоте. Например, простейший граф:

graph name {
  a -- b
  b -- c
  b -- d
}

Натравливаешь на это дело специальную программу и получаешь:
http://demin.ws/images/blog/dot-graph.png

Все! Картинка на выходе в SVG. Можно хоть на стену вешать.

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

Если кому интересно, я выложил пример реальной трассировки (по понятным причинам, имена изменены). В целом дает представление о простоте исходника и о возможностях визуализации - PNG и SVG.

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

В целом, отличная технология.

Background. We do financial transactions processing. At some point we decided that we need profiling. We could record a path of how a transaction being passed amongst modules. There are two options - either to do static analysis or to trace the runtime.

So, the connections are determined and now we have to formalize and visualize them.

At the first glance this is not an easy task, but it turned out there is a simple and elegant solution.

There is a plain text language to declare graphs -- DOT. Its beauty is in ultimate simplicity. For example, a trivial graph:

graph name {
  a -- b
  b -- c
  b -- d
}

Feed it to special software and get this:
http://demin.ws/images/blog/dot-graph.png

That's it! The output is in SVG, ready to stick on a wall.

Unfortunately, the best software I've found to visualize DOT is Graphviz. It does pretty decent job properly processing quite sophisticated graphs, but in terms of user experience it is shite.

If anyone is interested, I've uploaded a real trace (obviously, names are obfuscated). It gives an idea about simplicity of the source and visualization capabilities - PNG and SVG.

Again, the graph formalization is dead simple - you only need to specify pairs of connected vertices. Also, in DOT you can describe directed graphs and extra attributes of the vertices.

To sum up, great technology.

четверг, 19 января 2012 г.

Maximite - 8-bit nostalgia with a soldering iron / Ностальгия по временам Радио-86РК и Спектрума с паяльником в руках

The English version of this post is below.


Некоторое время назад я наткнулся на интересный проект - Maximite.

Это микрокомпьютер на базе Microchip PIC32 со встроенным Бейсиком. Прелесть тут в том, что собрать его можно за пару часов.

http://geoffg.net/Images/Maximite/icon.jpg

По возможностям он немного мощнее Радио-86РК и классического Спектрума. Но вот периферия у него сказочная: SD/FAT карточка, USB, VGA, PS/2, таймеры, RS232, I2C, SPI, PWM, ADC/DAC и просто одиночные порты-пины общего назначения.

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

Проект полностью открытый. Автор дает схемы, исходные коды прошивки и рекомендации по наладке.

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

Программы и данные можно хранить на SD карточке. Если на карточке есть файл "AUTORUN.BAS", то прошивка автоматически запускает его при старте.

Мне это все понравилось, но паять мне было лень. А в интернете продавались только конструкторы.

В итоге я заказал конструктор у Altronics.

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

Поехали.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0099.jpg

Вот тут я уже припаял несколько элементов. Я в пайке не совсем новичок, но держал паяльник в руках последний раз лет пять назад. Кислоты у меня не было, поэтому для ускорения процесса я выкрашивал канифоль прямо на точки пайки. Эффект примерно такой же. Паяльник (тот, что в тарелке) с острым жалом.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0102.jpg

Первый час я возился с несколькими элементами, но потом дело наладилось.

Вот тут уже готова половина.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0103.jpg

Но еще через час все было готово.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0106.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0107.jpg

Maximite может питаться либо от внешних 9 вольт, либо от USB. Я подключил вторым способом.

Итак, запуск. Подключаем USB и VGA к монитору. Работает!

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0110.jpg

Бейсик готов выполнять команды, но пока нет клавиатуры. Чисто PS/2 клавиатуры у меня не было, поэтому я попытался через USB-PS/2 переходник. Увы, воткнуть не получилось.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0111.jpg

На следующий день я взял у наших айтишников старую PS/2 клавиатуру и таки подключился.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0119.jpg

Корпус.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0114.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0115.jpg

В закрытом виде.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0112.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0113.jpg

Надо отдать должное - конструктор от Altronics отличного качества. Отверстия на плате металлизированы, что значительно упрощается пайку. Корпус моментально собирается.

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

Maximite имеет встроенную возможность обновления прошивки, и специальный программатор не нужен. Надо открыть корпус и перезапустить Maximite, удерживая специальный микро-выключатель. Устройство впадает в состояние boot loader'а, и специальной утилитой через USB можно заливать обновление.

Maximite видится в USB-подсистеме как стандартное CDC устройство. Но для Windows нужно все равно сначала поставить драйвер для создания виртуального COM-порта. На Маке этот драйвер встроен.

Подключаем.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0116.jpg

Заливаем.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0118.jpg

Ура. Прошивка обновлена с 2.1 до последней 3.0A.

Как я уже говорил, Maximite поддерживает VGA для дисплея и PS/2 для клавиатуры. Но это не все. Если подключить Maximite через USB к компьютеру, то кроме питания можно запустить программу эмулятор терминала, которая через виртуальный порт RS232 (работающий через USB) может обмениться данными с Maximite. Все, что Maximite выводит на VGA также дублируется в порт, а все что Maximite получает из порта расценивается как принятое с клавиатуры.

То есть можно вообще отключить VGA и PS/2 и работать чисто через терминал. Это офигительная возможность.

Например, картинка с VGA (вольтметр):

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01130.jpg

И одновременно с экрана терминала:

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01129.jpg

Забавно, экран у Maximite работает с точками, а не со знакоместами. Когда на экран выводится символ, то он дублируется, как я уже сказал, в терминале. А если рисуется графика, то она, естественно, в терминале не видна.

Диалект Бейсика в Maximite немного необычен, но зато дает доступ ко всей периферии без ограничения, причем прямо операторами языка.

На сайте автора есть архив с программами на Бейсике, демонстрирующие некоторые возможности Maximite.

Я приведу несколько картинок.

Часы.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01125.jpg

Редактор знакогенератора.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01123.jpg

Вольметр.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01132.jpg

Пару головоломок.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01128.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01133.jpg

А что это, думаю, объяснять не надо.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01126.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01131.jpg

Ну, конечно, привет Хабру!

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01134.jpg

Заключение

Каждая копейка, потраченная мной на этот эксперимент, стоила полученного кайфа.

Сам проект Maximite удивляет своей законченностью. Все как-то очень органично и просто. И самое главное - это работает!

Как мне кажется - для начинающих, даже детей, интересующихся микропроцессорной техникой, Maximite - это просто находка. Элементарная сборка, не требующая настройки. Я, как полный дилетант, собрал все за несколько часов.

Когда мой брат лет двадцать назад собирал Радио-86РК и Спектрум, ходила шутка про устройства для самостоятельной сборки, описываемые в журнале "Радио" - если авторы говорят, что устройство не требует наладки, то значит есть хотя бы минимальный шанс его наладить, ну я если авторы говорят, что требуется минимальная наладка...

В общем, хотите тряхнуть восьмибитной стариной с паяльником в рукам - соберите Maximite.



Recently I have come across an interesting project - Maximite.

This is a micro-computer based on Microchip PIC32 running BASIC. It is so simple that even a novice can build it in a few hours.

http://geoffg.net/Images/Maximite/icon.jpg

It is a bit more powerful than Radio-86RK and ZX Spectrum 48. But its peripherals are fantastic: SD/FAT card, USB, VGA, PS/2, timers, RS232, I2C, SPI, PWM, ADC/DAC and individial general purpose pins.

If you build it on a mock up board buying parts by youself, it will cost less then ten Australian dollars.

The project is open-sourced (schematics, PCB artwork, sources).

Even if quickly flip through the documentation, no doubts - a list features is impressive. All peripherals are available directly from BASIC.

Programs and data can be stored on a SD card. If there is a "AUTORUN.BAS" file on the card, BASIC will run at the start.

I liked Maximite, but soldering is not my favourite activity. Unfortunately it is only possible to buy a kit, but not a fully assembled unit.

I ordered the kit from Altronics and soon after it arrived.

Only the microprocessor was already soldered because soldering such form factor chip isn’t an easy task.

Anyway, screw it, let’s do it.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0099.jpg

Here a few parts are already in place. I’m not a complete newbie in soldering but last time I took a soldering iron in my hands was about five years ago. I had no acid for soldering, so I was crumbling rosin right to soldering points. The effect is similar to acid. The soldering iron (the one on the plate) with a sharp sting.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0102.jpg

I spent the first hour struggling with only a few parts, but eventually it went smoother.

A half is ready.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0103.jpg

After one more hour it was all done.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0106.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0107.jpg

Maximite can be powered from an external 9V source or form USB. I used USB.

Plug into USB and VGA. An off you go!

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0110.jpg

BASIC is ready but there is no keyboard. I hand’t a proper PS/2 one and I tried a USB-PS/2 connector. Alas, it didn’t fit.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0111.jpg

Next day I found the PS/2 keyboard and finally connected.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0119.jpg

The case.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0114.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0115.jpg

Fully assembled.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0112.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0113.jpg

I have to admit - the kit from Altronics is a very good quality product. The holes are metallized on the board, and the case fits perfectly.

Then I had to upgrade the firmware to the latest version. Maximite can flash itself over USB without a special programmer. Just open the case and hold a special button when swithing Maximite on. It goes to a boot loader mode.

Maxitite is a standard CDC device in USB infrastructure. Windows still requires a driver though, but Mac has it built-in.

Plug-in.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0116.jpg

Flashing.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/img_0118.jpg

Right, the firmware is upgraded up to 3.0A.

As I said, Maximite supports VGA and PS/2, but you can also connect it to a PC via USB. In this case Maximite mirrors the VGA output to that serial connection to the PC, also treats the data coming from that connection as keyboard input.

So, it is possible to detach VGA and PS/2 at all and talk to Maximite over the serial USB connection only.

For example, VGA dispay (voltmeter):

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01130.jpg

The same data on in a terminal emulation application on the PC:

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01129.jpg

Interestingly, Maximite works with pixels, not characters. So when a character is being displayed, it is also copied to the console, but when Maxitile draws graphics it is not visible in the serial console.

BASIC language in Maximite gives full control over the peripherals using operators.

There is an archive of BASIC programs running on Maximite available of the project website.

There are a few screenshots.

Clock.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01125.jpg

Character editor.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01123.jpg

Voltmeter.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01132.jpg

Puzzles.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01128.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01133.jpg

I believe, no comment here.

http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01126.jpg http://github.com/begoon/blog/raw/master/2012_01_19_maximite/dsc01131.jpg

Conclusion

Every penny I have spent on Maximite is worth that fun I’ve got.

The Maximite project is surprisingly solid. Everything is nice and simple. And it works!

For beginners, even kids, interested in microelectronics, Maximite is simply a godsend. Easy and nice to build. I as an amateur have built everything in a few hours only.

When my brother was building Radio-86RK and Spectrum about twenty years ago, there was a joke about DIY projects published in radio electronics magazines: if a author says that his device doesn’t required any tuning, there is at least a little chance to get it working; but the author says that his device does require some minor tuning...

Anyway, if you want to come back to your 8-bit youth with a soldering iron in hands — build Maximite.