Arduino и python: управление платой с помощью оболочки языка

Языки программирования для Arduino

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

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

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

Python

Общаться с Arduino по последовательному интерфейсу довольно просто в Python. 

На Unix подобных системах вы можете читать и писать через последовательное устройство,

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

Если вы уже сведущий в Python, то у вас, вероятно, будет хорошая практика — но если вы относительно плохо знакомы с языком то есть более простые способы начать программировать для Arduino, чем этот.

Однако Python очень подходящий вариант для использования вместе с Ардуино.

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

К тому же, если Вы когда-нибудь, начнете работать с платформами отличными от Arduino, то вы найдете,ваш опыт с Python весьма полезным.

Snap4Arduino

Если вы знаете Berkeley Snap (BYOB) и Arduino, возможно, вы уже догадались, это комбинация обоих.

Snap4Arduino это модификация визуального языка программирования Snap, который позволяет легко взаимодействовать практически со всеми версиями макетных плат Arduino.

C#

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

Вы можете запускать CmdMessenger в Майкрософт Visual Studio или использовать другию альтернативу. Оттуда вы сможете общаться между ПК и Arduino с использованием C#, делать вызовы функций или отправлять и получать команды.

ArduBlock

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

скачать с Github

Выглядит все действительно изящно, ArduBlock совмещает визуальное программирование (простое перемещение блоков) и фактическое программирование Arduino. Программное обеспечение работает как инструмент для Arduino IDE.

После завершения работы над вашим эскизом и подачи команды на загрузку, программное обеспечение просто разбирает вашу блок-схему и превращает ее в реальный код для Arduino. Далее происходит загрузка на вашу плату.

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

Источник: http://arduinoguru.ru/index.php/10-news/latest/62-languages-for-arduino

Как отправить значение из Arduino на Python, а затем использовать это значение

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

Я получил часть моего кода, который работает очень хорошо, графический интерфейс и системы управления, но я застрял. Я пытаюсь использовать датчик параллакса ping, чтобы получить расстояние до информации объектов из Arduino Mega и отправить это значение моему элементу управления Python script для отображения на удаленном графическом интерфейсе.

Основная проблема, с которой я сталкиваюсь, заключается в том, как интегрировать код Python, который будет использовать уже установленный COM-порт с Arduino, и отправить сообщение, чтобы сообщить Arduino опросить датчик ping, а затем отправить в программу Python, которая будет получать значение, а затем позвольте мне вставить это значение в мой графический интерфейс.

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

import serial
ser = serial.Serial('/dev/ttyUSB0', 9600) from PythonCard import model class MainWindow(model.Background): def on_SpdBtn_mouseClick(self, event): spd = self.components.SpdSpin.value def on_FBtn_mouseClick(self, event): spd = self.components.SpdSpin.value ser.write('@') ser.write('F') ser.write(chr(spd)) def on_BBtn_mouseClick(self, event): spd = self.components.SpdSpin.value ser.write('@') ser.write('B') ser.write(chr(spd)) def on_LBtn_mouseClick(self, event): spd = self.components.SpdSpin.value ser.write('@') ser.write('L') ser.write(chr(spd)) def on_RBtn_mouseClick(self, event): spd = self.components.SpdSpin.value ser.write('@') ser.write('R') ser.write(chr(spd)) def on_SBtn_mouseClick(self, event): spd = self.components.SpdSpin.value ser.write('@') ser.write('S') ser.write('0') def on_PngDisBtn_mouseClick(self, event): ser.write('~') ser.write('P1') ser.write('p2') app = model.Application(MainWindow)
app.MainLoop()

То, что я действительно хотел бы сделать, это улучшить приведенный выше код и добавить кнопку, чтобы щелкнуть, чтобы сообщить Python отправить сообщение в Arduino, чтобы проверить датчик ping и вернуть значение. Я очень грамотный с кодом Arduino, но я только начал играть с Python за последние две недели.

Источник: http://qaru.site/questions/756245/how-to-send-a-value-from-arduino-to-python-and-then-use-that-value

Python GUI for controlling an Arduino with a Servo

Python is a very versatile programming language that is used to run embedded software on Linux devices such as the Raspberry Pi or to write scripts to automate test. Python can also be used to create GUI on a computer.

There are various software packages out there that includes all the Python GUI library. We however found Tkinter to be the most simple of them all.

In this post, we are going to show you how to write a very simple GUI in Python to control a servo connected to an Arduino.

The Python GUI presented in this post sends commands over serial which is then interpreted by the firmware running on the Arduino.

Requirements

    • First of all, download Tkinter and install it.
    • Get some servos. We bought a couple of 10X2XSG90 9G Micro Servo Motor on GearBest for £1.96.

Arduino Servo Connections

Arduino Code

To keep things simple, we are going to use the Arduino servo library but you can also write your own library if you wish. If you want to know more on how servos can be controlled, visit this tutorial from Sparkfun.

#include Servo myservo; // create servo object to control a servo int pos = 90; // variable to store the servo position void setup() { Serial.begin(9600); myservo.attach(9); //Servo connected to D9
} void loop() { // send data only when you receive data: while (Serial.available() > 0) { // read the incoming byte: int c = Serial.read(); delay(2); // say what you got: Serial.print(«C is «); Serial.println(c, DEC); myservo.write(c); }
}

Python GUI code

After you install Tkinter, open up “IDLE(Python GUI)”. You will be greeted with this window:

To start writing your Python GUI code, go to File and click on New File to get a new window:

This is where you type your python code and to run it, go to Run and click on Run Module.

A good website for simple Python GUI example and tutorials, visit TutorialPoint.

The Python Code we wrote to control the Servo is:

# -*- coding: utf-8 -*-
from Tkinter import *
import sys
import glob
import serial
import time
RightLeftCounter = 90 class App: def __init__(self, master, ser): self.ser = ser self.button = Button(master, text=»QUIT», fg=»red», command=quit) self.button.grid(row=0, column=0, padx=0, pady=0, sticky=»nw») self.slogan = Button(master, text=»Reset», command=self.write_reset) self.slogan.grid(row=0, column=4, padx=0, pady=0, sticky=»nw») self.Left = Button(master, text=»←»,padx=10, command=self.write_Left) self.Left.grid(row=0, column=1, padx=0, pady=0, sticky=»nw») self.Right = Button(master, text=»→»,padx=10, command=self.write_Right) self.Right.grid(row=0, column=6, padx=2, pady=0, sticky=»nw») self.sweep = Button(master, text=»Sweep», command=self.write_sweep) self.sweep.grid(row=0, column=8, padx=0, pady=0, sticky=»nw») def write_Left(self): global RightLeftCounter if (RightLeftCounter>0): RightLeftCounter -=1 self.ser.write(chr(RightLeftCounter)) print(RightLeftCounter) print self.ser.readline() def write_Right(self): global RightLeftCounter if (RightLeftCounter

Источник: https://behindthesciences.com/electronics/python-gui-for-controlling-an-arduino-with-a-servo/

Python лучше C! (Или все-таки наоборот?)

Журнал РАДИОЛОЦМАН, октябрь 2016

Max Maxfield

embedded.com

Если вы введете в поисковик Google что-нибудь вроде «Python vs. C», то найдете множество сравнений этих языков. К сожалению, понять, какой же из них «лучше», почти невозможно по многим причинам, и не в последнюю очередь из-за того, что чрезвычайно трудно определить, что подразумевается под «лучшим».

Читайте также:  Подключение жк дисплея к микроконтроллеру arduino

Одним из аспектов всего этого является то, что в сети не так уж часто встречаются дискуссии, в которых языки Python и C сравниваются в контексте встраиваемых систем, особенно приложений на основе малых микроконтроллеров для «вещей», предназначенных для подключения к Интернету вещей. Так что, я готов порассуждать здесь об этом, но сначала…

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

Если вы посмотрите, например, в Wikipedia, то найдете 54 языка, названия которых начинаются с буквы «A» (я уж не говорю о тех, которые начинаются с «C» или «P»), и этот список даже не включает в себя более эзотерические языки, такие как Whitespace, в котором используются только пробельные символы (пробелы, табуляции и возврат), и игнорируются все другие, но мы отвлеклись…

Причина, по которой я затеял здесь эту пустую болтовню, заключается в том, что я только-только закончил чтение блестящей книги под названием «Учимся программировать с Minecraft» (Learn to Program with Minecraft) автора Крейга Ричардсона (Craig Richardson). Акцент в этой книге сделан на обучении языку программирования Python; в ней предлагается наиболее удобный, интуитивно понятный и новаторский подход, который я когда-либо видел для любого языка.

В своем обзоре книги я, в частности, сказал: «Я не хочу блуждать в этих дебрях, обсуждая здесь плюсы и минусы таких языков, как C и Python – это заслуживает отдельной статьи». И я был не слишком удивлен, обнаружив, что был прав на 100%, поскольку это действительно отдельная статья.

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

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

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

Кто-то мог бы сказать: «Язык является статически типизированным, если типы любых переменных известны во время компиляции, а динамически типизирован тот язык, в котором типы любых переменных интерпретируются во время выполнения».

В то же время, в консалтинговой компании Cunningham & Cunningham, скажут, что на самом деле статическая типизация означает, что «…значение явно (что не то же самое, как во время компиляции) ограничено в отношении типа значения, которое оно может обозначать, и что реализации языка, будь то компилятор или интерпретатор, навязывают и используют эти ограничения в максимально возможной степени». Что ж, я рад, что мы прояснили этот момент.

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

Если вы, например, прочитали достаточно статей, то увидите, что C описывается как слабо и сильно типизированный, в зависимости от точки зрения автора.

Кроме того, если вы принимаете определение сильной типизации как «Тип значения не меняется внезапно», то как объясните тот факт, что в Python можно сделать следующее:

bob = 6 bob = 6.5

bob = «My name is Bob»

На самом деле, говоря «строго типизированный», мы имеем ввиду, что строка, содержащая только цифры (вроде «123456») не сможет волшебным образом превратиться в число без выполнения нами явной операции (в отличие от Perl, например).

В случае приведенного выше фрагмента кода, все, что мы говорим – это то, что переменная bob может иметь различные типы в разные моменты времени. Если бы мы использовали метод type(bob) после bob = 6, то было бы возвращено int (целое число), после bob = 6.

5 вернется float (число с плавающей точкой), а после bob = «My name is Bob» будет возвращено str (строка).

Одно, с чем можем согласиться мы все – это то, что C, в отличие от Python, не заставит вас использовать отступы.

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

Еще один момент, с которым мы все готовы согласиться, касается того, что код на языке C компилируется, а код на Python интерпретируется (давайте не будем здесь погружаться в дебри обсуждения компиляции «на лету»).

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

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

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

Давайте начнем с того, что я думаю о том, что происходило до эпохи Python – примерно в конце 1980-х и начале 1990-х.

В то время я был склонен визуализировать программный пейзаж каким-то таким образом (Рисунок 1).

Рисунок 1. Так я думал примерно в 1990-м году.

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

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

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

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

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

В рамках этого мы могли бы заметить, что, по большому счету, сегодня ассемблер используется лишь в малых микроконтроллерах с крохотными объемами памяти (Рисунок 2).

Рисунок 2. Как, по моему мнению, люди думают о языках программирования в 2016 году.

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

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

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

Также верно и то, что чистый Python изначально не позволяет делать такие вещи, как считывание регистров микроконтроллера и ячеек памяти, хотя он поддерживает битовые операции.

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

Читайте также:  Уроки arduino: основы работы с семисегментными дисплеями

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

В случае с беспроводным стеком ZigBee, написанным на C, где любые приложения, как правило, будут также написаны на C, сам стек может занимать порядка 100 КБ Flash-памяти, а затем вы должны будете рассмотреть вопрос о дополнительной памяти, необходимой для приложения (более сложным приложениям понадобятся более дорогие микроконтроллеры с памятью 256 КБ). Кроме того, скорее всего вам придется скомпилировать стек на основе C в сочетании с вашим приложением, также на основе C, в один исполняемый файл, который затем нужно будет загрузить в ваш узел беспроводной связи. Помимо этого, придется перекомпилировать ваше приложение со стеком для каждого целевого микроконтроллера.

Для сравнения, стек компании Synapse, который, как и ZigBee, находится на вершине физического уровня и уровня управления доступом к среде стандарта IEEE 802.15.

4, требует лишь порядка 55 КБ flash-памяти, включая виртуальную машину Python.

Это означает, что если вы решили использовать недорогой микроконтроллер с объемом памяти 128 КБ, то для приложений на основе Python у вас останется 73 КБ памяти.

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

Поскольку каждый байткод формируется из 1 до 10 машинных кодов – давайте возьмем среднее значение 5, – это значит, что 73 КБ памяти вашего приложения на самом деле эквивалентны 73 × 5 = 365 КБ.

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

Продолжая свои размышления, я также поинтересовался у моего друга Дэвида Юинга (David Ewing), что он думает о дискуссии «C против Python». Дэвид работает техническим директором Synapse Wireless и, в отличие от вашего покорного слуги, является опытным программистом. Дэвид ответил следующим образом:

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

  • С является компилирующим языком, более «близким к железу». Это «универсальный ассемблер». Он чист и элегантен. Моя любимая цитата из книги K&R 30-летней давности: «C не является большим языком, и его нельзя хорошо описать большой книгой». 
  • Python с его «динамической типизацией» и прочими особенностями снижает риск появления «ненужных сложностей». Python интерпретируется (или компилируется «на лету»), поэтому у вас могут быть глупые ошибки, которые не будут обнаружены до момента исполнения. Тем не менее, компиляторы не всегда выявляют серьезные нетривиальные ошибки. В таких случаях поможет только тестирование; решение должно быть тщательно протестировано, независимо от языка реализации.

Дэвид продолжал:

Если проблема может быть решена на Python, то она также может быть решена и на C; но обратное не всегда верно. Однако если проблема может быть решена на Python, то:

  • Решение (исходный код) будет проще, чем соответствующий код на C.
  • Код будет более «читаемым».
  • Возможно, еще важнее, что он будет более легок в написании (это качество часто упускается из виду!).

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

Я похож на Дэвида в том, что ценю плюсы, связанные с обоими языками. Мне нравятся умные вещи, которые можно сделать с указателями в C, но я также ценю более интуитивный, простой в использовании синтаксис Python.

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

Что я скажу дальше, вы знаете, не так ли? Что вы думаете обо всем этом? Какой из этих двух языков вы предпочитаете (а) в общем, и (б) для встраиваемых приложений? Кроме того, если бы мы расширили сферу, то есть ли какой-нибудь другой язык, который вы предпочли бы использовать в мире встраиваемых систем?

Источник: https://www.rlocman.ru/review/article.html?di=163693

Знакомство с платой MicroPython

MicroPython — проект, ставящий перед собой целью портирование Python на микроконтроллеры STM. В ноябре прошлого года Damien George, британский физик-теоретик, увлекающийся электроникой и робототехникой, опубликовал на Kickstarter проект платы с микроконтроллером STM, писать код для которой возможно на языке Python.

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

Проект получил довольно большое количество разработчиков как версии Python для микроконтроллеров STM, так и для библиотек для работы с внешними устройствами. 

Каковы преимущества платы MicroPython? Во-первых, цена оригинальной платы сравнима с ценами на оригинальные платы Arduino — и это при кардинально различающихся возможностях.

 Во-вторых, Python — язык более высокоуровневый и простой, чем Wiring для Arduino или же C для AVR, что, несомненно, является плюсом для начинающих.

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

 В-третьих, для использования программного обеспечения MicroPython необязательно иметь оригинальную плату — можно скомпилировать ПО под другой подходящий МК от STM (об этом расскажу позднее) или даже использовать как минималистичную и очень быструю версию Python на ПК. На данный момент заявлена начальная поддержка для плат NetDuino Plus 2, STM Discovery STM32F407 и Teensy 3.1. Более актуальный список поддерживаемых плат доступен здесь.

Возможности

Как можно увидеть, плата имеет огромное количество GPIO и различных интерфейсов. К примеру, можно сравнить её с платой Arduino Uno:

 Arduino UnoMicroPythonЦена

Платформа

Язык программирования

Размер

ROM для кода

GPIO/ADC/DAC

Интерфейсы

Плюсы из коробки

Дополнительно

20EUR (оригинальная) 30EUR (оригинальная)
AVR STM
Wiring, C, Assembler (AVR)  Python, C, Assembler (STM)
2,7*2,1inch 1,7*1,6inch
16/32k 91к + расширение SD-картами
20/8/0 38/16/2
UART (объед. с USB), SPI, I2C,  6xUART, 2xSPI, 2xI2C, 2xCAN 
1xLED 2xLED, кнопка и I2C-акселерометр
Унифицированные слоты расширения  USB-OTG, USB-UART/HID/storage

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

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

Unboxing, или самая бесполезная часть

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

Тут выяснилось, что очень многие USB-microUSB кабели — крайне чувствительные к движениям и постоянно норовят прервать соединение.

Пришлось найти короткий с толстой изоляцией, отлично подошёл и до сих пор работает без каких-либо проблем. 

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

Уже работающие возможности

  • Интерактивная консоль Python через виртуальный последовательный порт через USB. Это отличная помощь в разработке, которая, естественно, не могла не появиться на этой плате. Все те возможности, которые поддерживаются скриптами, а также новые возможности платы, которые порой появляются при обновлении прошивки, можно перед этим испытать в консоли. USB — хардварный, на самом чипе STM, без посредников типа FT232.  
  • Встроенный акселерометр. Да, это то, с чем можно работать, достав плату из коробки, то, что связывает плату с внешним миром. Что-то похожее я встречал разве что в более специфичных проектах, вроде Arduino Esplora, и это, как по мне, помогает оценить возможности платы, даже ничего не припаивая.
  • USB storage для скриптов. Не нужно подключать карту для более простых проектов — 100 килобайтов для кода к вашим услугам, и они доступны как простая папка с файлами при подключении к компьютеру. Последним порой не могут похвастаться даже самые новые смартфоны 😉
  • USB HID как приятное дополнение. Пока поддерживается только имитация мыши, клавиатура ожидается в скором времени — и, несомненно, ей найдётся применение. Также скоро обещают сделать USB-OTG — это резко расширит возможности платы, хоть и потребуется дополнительная рабочая сила для разработки драйверов. 
  • Обновление через USB. Для плат STM это довольно стандартная возможность, но не везде она сделана так, чтобы использовать её было реально удобно. 
  • Доступные модули для SPI/I2C/UART/ADC/DAC. В сочетании с интерактивной консолью — можно считать это частичной заменой Bus Pirate (популярный инструмент, использующийся в том числе как консоль для работы с различными протоколами). Конечно, в плане функций Bus Pirate является ещё много чем, но если можно использовать уже существующий инструмент для выполнения части задач — почему бы и нет?
  • Логические уровни — 3.3В, но все GPIO пины, кроме двух, принимают 5В. К слову, на плате установлен линейный регулятор с низким падением напряжения, минимальное напряжение на его входе — 3.6 вольт, что позволяет запитать плату от одной 3.7В LiIon/LiPo батареи или трёх AAA/AA.
Читайте также:  Введение в c# sharp: программирование простым языком - arduino+

Подключил к ноутбуку с Linux, сразу же появился последовательный порт, плюс внешний диск — память самой платы. В памяти хранятся скрипты, readme и драйвер для Windows, что довольно удобно и напоминает USB 3G-модемы.

Обновление прошивки

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

Оказалось, что нужно было просто-напросто обновить прошивку.

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

А на этом месте поподробнее…

Инструкция для Windows есть здесь, а для Linux потребуются следующие манипуляции:

  1. Скачать файл последней прошивки отсюда
  2. Установить утилиту dfu-util (в Debian/Ubuntu находится в пакете dfu-util)
  3. Замкнуть на PyBoard контакты DFU и 3V3
  4. Подключить PyBoard к компьютеру
  5. Запустить команду 

sudo dfu-util —alt 0 -D путь/к/файлу/прошивки.dfu

После прошивки и переподключения платы прошивка будет обновлена. В моём случае — после перепрошивки всё заработало нормально.

Оказалось, что плате не нравится горячее извлечение. Если быть точным, то не нравится это встроенной памяти, файловая система которой — FAT. После одного извлечения список файлов перестал читаться, но всё прошло после проверки файловой системы на ошибки.

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

При использовании советую учитывать этот маленький нюанс и «извлекать» встроенную память перед отсоединением кабеля.

​Написание первого скрипта

Тут всё очень просто. Подключаю плату как диск:

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

Отлично. Теперь открываем файл main.py:

Пишем в нём самый простой код, который зажигает два светодиода и попеременно мигает ими по очереди с интервалом в одну секунду. led.toggle() обозначает переключение состояния светодиода на противоположное. Сохраняем, перезапускаем — мигает. 

К слову, хорошая коллекция демо-скриптов есть в этом репозитории на GitHub. 

Сброс к заводским настройкам

У PyBoard есть две функции на случай возникновения проблем — безопасный режим (игнорирование файлов boot.py&main.py) или же сброс к чистой ФС. Первый способ полезен, когда из-за бесконечного цикла в коде/неправильного режима USB проблему трудно исправить, но она в целом несущественна.

Второй способ полезен в случае каких-либо серьёзных проблем, вроде повреждений ФС, но полностью уничтожает данные на ней. Для перехода к этим функциям отключаем плату от компьютера, затем зажимаем кнопку USR (левая) и подключаем обратно.

После этого,  всё ещё держа кнопку USR, щёлкаем кнопкой RST (правая) и дожидаемся момента, когда будут мигать оранжевый и зелёный светодиоды:

  • Для безопасного режима отпускаем кнопку USR в момент, когда будет гореть только оранжевый светодиод. Он мигнёт 4 раза, после этого будет активирован безопасный режим, во время которого можно подключиться к последовательному порту или примонтировать файловую систему.
  • Для сброса к заводским настройкам отпускаем кнопку USR в момент, когда будут гореть и оранжевый, и зелёный светодиоды. Они мигнут 4 раза, после этого загорится красный светодиод. Когда он потухнет, сброс закончится. Для того, чтобы продолжить работу с платой, просто щёлкните кнопкой RST. 

Последняя заметка — имеющуюся у меня плату не удастся просто так подключить к какому-нибудь устройству. Почему? Не напаяны контакты. Это можно и нужно исправить, официальный совет — напаять контактные группы типа «мама» так, чтобы контакты приходились на лицевую сторону платы, к примеру, так:

Или так:

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

Выбор контактов обусловлен тем, что так труднее что-то закоротить, когда плата MicroPython не вставлена в какую-либо, но подключена к питанию, как и тем, что ответные контактные группы дешевле — а именно их потребуется больше всего, чтобы создавать различные шилды. Зачем напаивать контакты так, чтобы они приходились на лицевую часть? Всё очень просто. 

Полезна ли мне эта плата как разработчику? Да, несомненно. У меня е

сть проекты, где Raspberry Pi/любой другой SoM на Linux/OpenWRT — оверкилл, а Arduino — уже недостаточно, к примеру — обработка данных с датчиков положения и корректировка положения в пространстве, синтез звука, контроль большого числа устройств на I2C/SPI или же устройств с высокой скоростью передачи и т.п.

В процессе работы оказалось, что эта плата — отличный инструмент для прототипирования благодаря простому ЯП и возможности интерактивной отладки — теперь, прежде чем создавать библиотеку Arduino для какого-то нового проекта, я создаю модуль Python для MicroPython и проверяю на нём, так как таким образом уменьшается число ошибок при конвертации данных из даташита в код. В следующих статьях я обязательно расскажу и об этом подходе.

Думаю, что после следующего цикла производства я возьму себе ещё пару таких плат — или же, в крайнем случае, STM32F407 Discovery, на которую уже портировали MicroPython. Если я выберу последний вариант, то однозначно поделюсь статьёй на тему установки и настройки, а пока инструкции можно в сокращённом виде увидеть 

Источник: http://cxem.net/arduino/arduino131.php

Ссылка на основную публикацию