Arduino и ЧПУ на Portal-PK.ru http://f-studio.biz/ Arduino проекты, уроки, а также самоделки и самодельные ЧПУ станки на Portal-PK.ru ru Компоненты роботов. Основные исполнительные механизмы и электроника роботов http://f-studio.biz/news/168-komponenty-robotov-osnovnye-ispolnitelnye.html Константин Portal-PK 2019-03-25T18:08:52+03:00 Робот обычно состоит из 5 основных компонентов:

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

Контроллер

2. Рука – это часть робота, которая имеет датчики для выполнения своих предварительно запрограммированных операций. Они построены так, чтобы напоминать человеческие руки, и имеют плечи, локти, запястья и даже пальцы. Говорят, что каждый сустав дает роботу 1 степень свободы. Простая рука робота с 3 степенями свободы может двигаться тремя способами: вверх и вниз, влево и вправо, вперед и назад. Большинство работающих роботов сегодня имеют 6 степеней свободы, чтобы позволить им достичь любой возможной точки пространства в своей рабочей зоне.

3. Привод: Приводы (секции между соединениями) перемещаются в нужное положение. Как правило, привод приводится в действие пневматическим гидравлическим давлением или электричеством.

Приводы

4. End-Effector. Конечный эффектор можно рассматривать как «руку» на конце роботизированной руки. Существует множество возможных конечных эффекторов, включая захват, вакуумный насос, пинцет, скальпель, паяльную лампу, сварщик, пистолет-распылитель или что-то еще, что поможет ему выполнить свою работу. Некоторые роботы могут менять конечные эффекторы и перепрограммироваться для другого набора задач.

5. Датчик: Датчик отправляет информацию в виде электронных сигналов обратно в контроллер. Датчики также предоставляют контроллеру робота информацию о его окружении и позволяют ему узнать точное положение руки или состояние окружающего мира. Одна из наиболее интересных областей разработки сенсоров – это компьютерное зрение и распознавание объектов. Роботизированные датчики могут обнаруживать инфракрасное излучение, чтобы «видеть» в темноте.

Датчик

Основные исполнительные механизмы

Три типа исполнительных механизмов в основном используются в робототехнике, в зависимости от энергии, которую они преобразовывают:

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

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

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


Электроника под капотом любого робота может быть разделена на несколько подкатегорий:

· Силовые системы

· Датчики

· Приводы

· Микроконтроллеры и процессоры

· Полезные программные средства

Силовые системы: Роботам, как и людям, нужна энергия, чтобы функционировать. Обычно у роботов есть аккумуляторы, что делает их мобильными и, следовательно, более полезными. Само собой разумеется, что чем больше батарея (чем больше емкость батареи), тем дольше робот может работать. Но не может быть бесконечно большой батареи на маленьком роботе. Это компромисс, который инженеры энергетических систем пытаются сбалансировать.

Датчики: Батареи важны и с ними интересно играть. Но что хорошего в батареях без остальной бортовой электроники? Как и человеческая сенсорная система, которая состоит из глаз, носа, ушей, вкусовых рецепторов и кожи, у роботов тоже есть сенсорная система. Само собой разумеется, что система не так развита, как наша, но в последнее время произошли некоторые значительные улучшения. Типичная сенсорная система робота будет состоять из ряда аналоговых и цифровых датчиков, таких как камера для зрения, микрофоны для восприятия звука, ультразвуковые или инфракрасные датчики для восприятия расстояния (это похоже на эхолокацию у летучих мышей и китов), и гибкие / тактильные датчики для восприятия физических ощущений.

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

Микроконтроллеры и процессоры: Одна из самых важных частей робота – это мозг! Так же, как человеческий мозг, мозг робота отвечает за управление всеми его действиями. Он состоит из микроконтроллеров и микропроцессоров. Микроконтроллеры – небольшие микросхемы, состоящие из сотен тысяч транзисторов. Они имеют набор программируемых цифровых выводов ввода / вывода, называемых выводами GPIO (общего назначения ввода / вывода), немного флэш-памяти, немного оперативной памяти и небольшое ядро процессора. Микроконтроллер обычно используется для более повторяющихся задач. Их можно запрограммировать на выполнение определенного набора функций и они будут выполнять эти функции одна за другой несколько раз.

Микроконтроллеры и процессоры

Полезные программные инструменты – это предоставленные коды ПО, которое предоставляет инструменты для создания прототипов схем на макете программного обеспечения.


]]>
Классы роботов. Подвиды современных роботов. http://f-studio.biz/news/167-klassy-robotov-podvidy-sovremennyh-robotov.html Константин Portal-PK 2019-03-17T09:30:25+03:00 Роботы могут быть классифицированы в соответствии с различными критериями, такими как степень их свободы, кинематическая структура, технология привода, геометрия мастерской и характеристики движения.

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

Общего назначения: если он обладает 6 степенями свободы.

Избыточный робот: если он обладает более чем 6 степенями свободы. Это дает больше свободы для перемещения по препятствиям и работы в ограниченном рабочем пространстве.

Дефицит робота: если он обладает менее чем 6 степенями свободы.

 манипулятор должен иметь 6 степеней свободы

Классификация по кинематической структуре: по кинематической структуре роботы могут быть классифицированы как:

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

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

Гибридный манипулятор: если он состоит из цепей с разомкнутым и замкнутым контуром. Пример: Fanuc S-900 W. Многие промышленные роботы используют этот тип конструкции робота.


Стационарные роботы – это роботизированные системы, которые работают без изменения своих позиций. Обозначение робота как «неподвижного» не означает, что он фактически не движется. Что означает «стационарный», так это то, что основание устройства не двигается во время работы.

Стационарные роботы

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

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

Роботы на колесах

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

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

Роботы на ножках

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

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

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

Летающие роботы

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

Rolling Robotic Balls (мобильные сферические роботы)

Swarm – это роботизированные системы, состоящие из нескольких маленьких роботов. Эти системы конструктивно не создают единого объединенного робота, но работают совместно. Подобно модульным роботизированным устройствам, элементы роящихся роботов имеют гораздо меньшую функциональность.

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

Микро Роботы

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

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

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


Понравилась статья пишите в комментарии или на форум.

]]>
Что такое робототехника http://f-studio.biz/news/166-chto-takoe-robototehnika.html Константин Portal-PK 2019-03-13T09:08:57+03:00 Давайте начнем отвечать на этот вопрос, понимая, что такое робототехника. Это область создания роботов для некоторых конкретных целей.

люди вели себя как роботы, а роботы - как люди

Мы живем в эпоху, когда мы хотим, чтобы люди вели себя как роботы, а роботы - как люди. Три основных компонента, которые необходимы для эмуляции человеческих качеств при выполнении конкретных задач:

а) программирование (реагирование на ситуации);

б) аппаратное обеспечение (в основном из механических степеней свободы);

в) встроенные системы (притоки). То, что может хранить и выполнять программы.

Значение и область применения робототехники

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

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

Значение и область применения робототехники

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

Существуют доказательства того, что механизированные фигуры, похожие на человека, которые датируются древними временами в Греции. Понятие искусственного человека встречается в художественных произведениях с начала 19 века. Несмотря на эти первоначальные мысли и представления, рассвет робототехнической революции начался всерьез в 1950-х годах. Джордж Девол изобрел первого программируемого робота с цифровым управлением в 1954 году. Это в конечном итоге положило начало современной индустрии робототехники.

Когда был сделан первый робот

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

программируемым роботом стал Unimate

Ранняя история Около 270 г. до н.э. древнегреческий инженер по имени Ктесибий делал водяные часы с автоматами или свободными фигурами. Греческий математик Archytas of Tarentum постулировал механическую птицу, которую он назвал «Голубь», которая двигалась при воздействии пара.

Чем отличаются первые роботы от современных роботов

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

Общее определение значения

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

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

  1. принимать электронное программирование;
  2. обрабатывать данные или физическое восприятие в электронном виде;
  3. работать автономно;
  4. в некоторой степени передвигаться;
  5. управлять физическими частями самого себя или физическими процессами;
  6. ощущать и манипулировать своим окружением и проявлять разумное поведение, особенно поведение, которое имитирует людей или других животных.

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

]]>
detachInterrupt() http://f-studio.biz/news/106-detachinterrupt.html Константин Portal-PK 2017-05-16T11:43:49+03:00 Описание

Запрещает заданное прерывание.

Синтаксис

detachInterrupt(interrupt)
detachInterrupt(pin)     //только для Arduino Due 

Параметры

  • interrupt: номер прерывания, которое необходимо запретить (подробнее см. attachInterrupt()).
  • pin: номер вывода, соответствующее прерывание которого необходимо запретить (только для Arduino Due)
]]>
attachInterrupt() http://f-studio.biz/news/105-attachinterrupt.html Константин Portal-PK 2017-05-16T11:40:41+03:00 Описание

Задает функцию, которую необходимо вызвать при возникновении внешнего прерывания. Заменяет предыдущую функцию, если таковая была ранее ассоциирована с прерыванием. В большинстве плат Ардуино существует два внешних прерывания: номер 0 (цифровой вывод 2) и 1 (цифровой вывод 3). Номера выводов для внешних прерываний, доступные в тех или иных платах Ардуино, приведены в таблице ниже:

Плата int.0 int.1 int.2 int.3 int.4 int.5
Uno, Ethernet 2 3
Mega2560 2 3 21 20 19 18
Leonardo 3 2 0 1 7
Due (см. ниже)

Плата Arduino Due предоставляет больше возможностей по работе с прерываниями, поскольку позволяют ассоциировать функцию-обработчик прерывания с любым из доступных выводов. При этом в функции attachInterrupt() можно непосредственно указывать номер вывода.

Синтаксис

attachInterrupt(interrupt, function, mode)
attachInterrupt(pin, function, mode)     // только для Arduino Due

Параметры

interrupt: номер прерывания (int)
pin: номер вывода (только для Arduino Due)
function: функция, которую необходимо вызвать при возникновении прерывания; эта функция должна быть без параметров и не возвращать никаких значений. Такую функцию иногда называют обработчиком прерывания.
mode:

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

  • LOW - прерывание будет срабатывать всякий раз, когда на выводе присутствует низкий уровень сигнала
  • CHANGE - прерывание будет срабатывать всякий раз, когда меняется состояние вывода
  • RISING - прерывание сработает, когда состояние вывода изменится с низкого уровня на высокий
  • FALLING - прерывание сработает, когда состояние вывода изменится с высокого уровня на низкий.

В Arduino Due доступно еще одно значение:

  • HIGH - прерывание будет срабатывать всякий раз, когда на выводе присутствует высокий уровень сигнала (только для Arduino Due).

Возвращаемые значения

нет

Примечание

Внутри функции-обработчика прерывания функция delay() не будет работать; значения, возвращаемые функцией millis(), не будут увеличиваться. Также будут потеряны данные, полученные по последовательному интерфейсу во время выполнения обработчика прерывания. Любые переменные, которые изменяются внутри функции обработчика должны быть объявлены как volatile.

Использование прерываний

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

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

Пример

int pin = 13;
volatile int state = LOW;
void setup()
{
  pinMode(pin, OUTPUT);
  attachInterrupt(0, blink, CHANGE);
}
void loop()
{
  digitalWrite(pin, state);
}
void blink()
{
  state = !state;
}
]]>
random() http://f-studio.biz/news/104-random.html Константин Portal-PK 2017-05-16T09:52:53+03:00 Описание

Функция random() генерирует псевдо-случайные числа.

Синтаксис

random(max)
random(min, max)

Параметры

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

max - верхняя граница случайной величины, не включительно.

Возвращаемые значения

случайное число в диапазоне от min до max-1 (long)

Примечание

Если при циклическом использовании функции random() важно получать последовательность различных случайных чисел, то для инициализации генератора случайных чисел используйте функцию randomSeed() с параметром, представляющим собой в определенной степени случайную величину. Таким параметром может быть, например, величина напряжения, считанная функцией analogRead() с не подсоединенного вывода.

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

Пример

long randNumber;
 
void setup(){
  Serial.begin(9600);
 
  // если аналоговый вход 0 ни к чему не подсоединен, то произвольный аналоговый
  // шум на нем обеспечит разные исходные числа, передаваемые функции randomSeed()
  // при каждом запуске программы. Впоследствии это позволит функции random 
  // генерировать разные значения.
  randomSeed(analogRead(0));
}
 
void loop() {
  // выводим случайное число в диапазоне от 0 до 299
  randNumber = random(300);
  Serial.println(randNumber);  
 
  // выводим случайное число в диапазоне от 10 до 19
  randNumber = random(10, 20);
  Serial.println(randNumber);
 
  delay(50);
}
]]>
randomSeed(seed) http://f-studio.biz/news/103-randomseedseed.html Константин Portal-PK 2017-05-16T09:51:00+03:00 Описание

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

Если при циклическом использовании функции random() важно получать последовательность различных случайных чисел, то для инициализации генератора случайных чисел используйте функцию randomSeed() с параметром, представляющим собой в определенной степени случайную величину. Таким параметром может быть, например, величина напряжения, считанная функцией analogRead() с неподсоединенного вывода.

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

Параметры

long, int - число для генерирования начального значения.

Возвращаемые значения

нет

Пример

long randNumber;
 
void setup(){
  Serial.begin(9600);
  randomSeed(analogRead(0));
}
 
void loop(){
  randNumber = random(300);
  Serial.println(randNumber);
 
  delay(50);
}
]]>
tan(rad) http://f-studio.biz/news/102-tanrad.html Константин Portal-PK 2017-05-16T09:13:32+03:00 Описание

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

Параметры

rad: угол в радианах (float)

Возвращаемые значения

тангенс угла (double)

]]>
cos(rad) http://f-studio.biz/news/101-cosrad.html Константин Portal-PK 2017-05-16T09:12:44+03:00 Описание

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

Параметры

rad: угол в радианах (float)

Возвращаемые значения

косинус угла ("double")

]]>
sin(rad) http://f-studio.biz/news/100-sinrad.html Константин Portal-PK 2017-05-16T09:11:51+03:00 Описание

Вычисляет синус угла (в радианах). Результат лежит в пределах от -1 до 1.

Параметры

rad: угол в радианах (float)

Возвращаемые значения

синус угла (double)

]]>
sq(x) http://f-studio.biz/news/99-sqx.html Константин Portal-PK 2017-05-16T09:09:32+03:00 Описание

Вычисляет квадрат числа: число, умноженное само на себя.

Параметры

x: число, любой тип данных

Возвращаемые значения

квадрат числа

]]>
sqrt(x) http://f-studio.biz/news/98-sqrtx.html Константин Portal-PK 2017-05-16T09:08:29+03:00 Описание

Вычисляет квадратный корень числа.

Параметры

x: число, любой тип данных

Возвращаемые значения

double, квадратный корень числа.

]]>
pow(base, exponent) http://f-studio.biz/news/97-powbase-exponent.html Константин Portal-PK 2017-05-16T09:07:20+03:00 Описание

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

Параметры

base: число (float)

exponent: показатель степени, в которую необходимо возвести число (float)

Возвращаемые значения

Результат возведения в степень (double)

Пример

См. функцию fscale в библиотеке.

]]>
map(value, fromLow, fromHigh, toLow, toHigh) http://f-studio.biz/news/96-mapvalue-fromlow-fromhigh-tolow-tohigh.html Константин Portal-PK 2017-05-16T09:05:29+03:00 Описание

Преобразовывает значение переменной из одного диапазона в другой. Т.е. значение переменной value, равное fromLow, будет преобразовано в число toLow, а значение fromHigh - в toHigh. Все промежуточные значения value масштабируются относительного нового диапазона [toLow; toHigh].

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

Обратите внимание, что нижние пределы указываемых диапазонов (fromLow, toLow) численно могут быть больше верхних пределов (fromHigh, toHigh). В этом случае функция map() может использоваться для создания обратного диапазона чисел, например:

y = map(x, 1, 50, 50, 1);

Функция может обрабатывать отрицательные числа, поэтому этот пример

y = map(x, 1, 50, 50, -100);

также работает корректно.

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

Параметры

value: переменная, значение которой необходимо преобразовать

fromLow: нижний предел текущего диапазона переменной value

fromHigh: верхний предел текущего диапазона переменной value

toLow: нижний предел нового диапазона переменной value

toHigh: верхний предел нового диапазона переменной value

Возвращаемые значения

Преобразованное значение.

Пример

/* Преобразование аналогового значения в 8-битное число (от 0 до 255) */
void setup() {}
 
void loop()
{
  int val = analogRead(0);
  val = map(val, 0, 1023, 0, 255);
  analogWrite(9, val);
}

Дополнение

Для интересующихся математикой приводим исходный код функции:

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
]]>
функция dtostrf () http://f-studio.biz/news/95-funkciya--dtostrf-.html Константин Portal-PK 2017-05-16T08:58:24+03:00 Функция dtostrf (), преобразует данные с плавающей точкой в массив символов, поэтому они могут быть легко напечатаны.

Формат функции следующий

dtostrf(floatvar, StringLengthIncDecimalPoint, numVarsAfterDecimal, charbuf);

где:

floatvar - преобразуемая переменная типа float;

StringLengthIncDecimalPoint - длина получаемого символьного значения;

numVarsAfterDecimal - количество символов после запятой;

charbuf - символьный массив для сохранения результата преобразования

Следующий пример программы поможет понять что к чему

static float f_val = 123.6794;
static char outstr[15];

void setup() {
  dtostrf(f_val,7, 3, outstr);

  Serial.begin(9600);
  Serial.println(outstr);
}

void loop(){
}

В результате работы скетча получим

123.679

Имеем 7 символов вдлину, с тремя цифрами после запятой.

При этом, если бы входное значение было например 1.6794, что бы мы получили? Длина строчки символов осталась бы равной 7-ми, с тремя цифрами после запятой, и это значит что функция вставит 2 пробела сначала строки.

1.679

Теперь попробуйте сами.

]]>
constrain(x, a, b) - ​Ограничивает значение переменной заданными пределами. http://f-studio.biz/news/92-constrainx-a-b---​ogranichivaet-znachenie-peremennoi.html Константин Portal-PK 2017-04-24T14:11:10+03:00 Описание

Ограничивает значение переменной заданными пределами.

Параметры

x: переменная, значение которой необходимо ограничить, любой тип данных

a: нижний предел, любой тип данных

b: верхний предел, любой тип данных

Возвращаемые значения

x: если x лежит в пределах между a и b.

a: если x меньше a.

b: если x больше b.

Пример

sensVal = constrain(sensVal, 10, 150);
// числовые показания датчика ограничены диапазоном от 10 до 150
]]>
abs(x) Вычисляет абсолютную величину (модуль) числа. http://f-studio.biz/news/91-absx--vychislyaet-absolyutnuyu-velichinu-modul-chisla.html Константин Portal-PK 2017-04-24T14:09:04+03:00 Описание

Вычисляет абсолютную величину (модуль) числа.

Параметры

x: число

Возвращаемые значения

x: если x больше или равен 0.

-x: если x меньше 0.

Предупреждение

Реализация функции abs() запрещает указывать другие функции в качестве параметров в скобках - это приведет к некорректным результатам:

abs(a++);       // избегайте этого - функция выдаст некорректный результат
 
a++;
abs(a);        // вместо этого осуществляйте математические вычисления за пределами функции
]]>
max(x, y) - Arduino IDE http://f-studio.biz/news/90-maxx-y---arduino-ide.html Константин Portal-PK 2017-04-24T14:07:04+03:00 Вычисляет максимальное значение из двух чисел.

Параметры

x: первое число, любой тип данных

y: второе число, любой тип данных

Возвращаемые значения

Большее из двух указанных чисел.

Пример

sensVal = max(senVal, 20); // присваивает sensVal большее из двух чисел sensVal и 20
                           // позволяя убедиться, что значение sensVal будет не меньше 20

Примечание

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

Предупреждение

Реализация функции max() запрещает указывать другие функции в качестве параметров в скобках - это приведет к некорректным результатам:

max(a--, 0);   // избегайте этого - функция выдаст некорректный результат
 
a--;
max(a, 0);    // вместо этого - осуществляйте математические вычисления за пределами функции
]]>
min(x, y) - Arduino IDE http://f-studio.biz/news/89-minx-y---arduino-ide.html Константин Portal-PK 2017-04-24T14:04:31+03:00 Описание

Вычисляет минимальное значение из двух чисел.

Параметры

x: первое число, любой тип данных

y: второе число, любой тип данных

Возвращаемые значения

Меньшее из двух чисел.

Пример

sensVal = min(sensVal, 100); // присваивает sensVal меньшее из чисел sensVal и 100
                             // позволяя убедиться, что значение sensVal никогда не превысит 100

Примечание

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

Предупреждение

Реализация функции min() запрещает указывать другие функции в качестве параметров в скобках - это приведет к некорректным результатам:

min(a++, 100);   // избегайте этого - функция выдаст некорректный результат
a++;
min(a, 100);    // вместо этого - осуществляйте математические вычисления за пределами функции
]]>
delayMicroseconds() - Arduino http://f-studio.biz/news/87-delaymicroseconds---arduino.html Константин Portal-PK 2017-04-20T13:51:08+03:00 Описание

Приостанавливает выполнение программы на указанный промежуток времени (в микросекундах). В одной миллисекунде 1000 миллисекунд, и 1 000 000 микросекунд.

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

Синтаксис

delayMicroseconds(us)

Параметры

us: количество микросекунд, на которые необходимо приостановить программу (unsigned int)

Возвращаемые значения

нет

Пример

int outPin = 8;                 // цифровой вывод 8
 
void setup()
{
  pinMode(outPin, OUTPUT);      // конфигурируем цифровой вывод как выход
}
 
void loop()
{
  digitalWrite(outPin, HIGH);   // включаем вывод
  delayMicroseconds(50);        // задержка в 50 микросекунд 
  digitalWrite(outPin, LOW);    // выключаем вывод
  delayMicroseconds(50);        // задержка в 50 микросекунд
}

Вывод номер 8, сконфигурированный как выход, формирует последовательность импульсов с периодом 100 микросекунд

Предупреждения и известные проблемы

Данная функция работает с высокой точностью в диапазоне от 3 микросекунд и выше. При более коротких задержках точная работа delayMicroseconds() не гарантируется.

Начиная с версии Arduino 0018, функция delayMicroseconds() больше не отключает прерывания.

]]>
micros() -Ardiono IDE http://f-studio.biz/news/86-micros--ardiono-ide.html Константин Portal-PK 2017-04-20T13:48:37+03:00 Описание

Возвращает количество микросекунд, прошедших с момента начала выполнения программы Arduino. Возвращаемое число переполнится (сбросится в 0) спустя приблизительно 70 минут. На платах Arduino с тактовой частотой 16 МГц (Duemilanove и Nano) разрешение этой функции составляет четыре микросекунды (т.е. возвращаемое значение будет всегда кратно четырем). На платах Ардуино с тактовой частотой 8 МГц (LilyPad), разрешение функции составляет восемь микросекунд.

Примечание: в одной миллисекунде 1000 микросекунд, а в одной секунде - 1 000 000 микросекунд.

Параметры

Нет

Возвращаемые значения

Количество микросекунд, прошедших с момента старта программы (unsigned long)

Пример

unsigned long time;
 
void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.print("Time: ");
  time = micros();
  //выводим время с момента старта программы
  Serial.println(time);
  // ждем 1 секунду, чтобы не отправлять большой массив данных
  delay(1000);
}
]]>
millis() - Arduino IDE http://f-studio.biz/news/85-millis---arduino-ide.html Константин Portal-PK 2017-04-20T13:47:15+03:00 Описание

Возвращает количество миллисекунд, прошедших с момента старта программы Ардуино. Возвращаемое число переполнится (сбросится в 0) спустя приблизительно 50 дней.

Параметры

Нет

Возвращаемые значения

Количество миллисекунд, прошедших с момента старта программы (unsigned long)

Пример

unsigned long time;
 
void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.print("Time: ");
  time = millis();
  //выводим время с момента старта программы
  Serial.println(time);
  // ждем 1 секунду, чтобы не отправлять большой массив данных
  delay(1000);
}

Совет:

Помните, что значение, возвращаемое функцией millis(), имеет тип unsigned long. При попытке выполнения математических операций между этим значением и значениями другого типа (например, int) будет сгенерирована ошибка.

]]>
pulseIn() - Arduino http://f-studio.biz/news/84-pulsein---arduino.html Константин Portal-PK 2017-04-20T13:45:35+03:00 Считывает длительность импульса (любого - HIGH или LOW) на выводе. Например, если заданное значение (value) - HIGH, то функцияPulseIn() ожидает появления на выводе сигнала HIGH, затем засекает время и ожидает переключения вывода в состояние LOW, после чего останавливает отсчет времени. Функция возвращает длительность импульса в микросекундах, либо 0 в случае отсутствия импульса в течение определенного таймаута.

Эмпирическим путем установлено, что при использовании функции для измерения широких импульсов возможно возникновение ошибок. Функция работает с импульсами длительностью от 10 микросекунд до 3 минут.

Синтаксис

pulseIn(pin, value)
pulseIn(pin, value, timeout)

Параметры

pin: номер вывода, с которого необходимо считыть импульс (int)

value: тип считываемого импульса: HIGH или LOW (int)

timeout (опционально): время ожидания импульса в микросекундах; значение по умолчанию - одна секунда (unsigned long)

Возвращаемые значения

длительность импульса (в микросекундах) либо 0 в случае отсутствия импульса в течение таймаута (unsigned long)

Пример

int pin = 7;
unsigned long duration;
 
void setup()
{
  pinMode(pin, INPUT);
}
 
void loop()
{
  duration = pulseIn(pin, HIGH);
}
]]>
shiftIn() - Arduino http://f-studio.biz/news/83-shiftin---arduino.html Константин Portal-PK 2017-04-20T13:43:06+03:00 Осуществляет побитовый сдвиг и считывание байта данных, начиная с самого старшего (левого) или младшего (правого) значащего бита. Процесс считывания каждого бита заключается в следующем: тактовый вывод переводится в высокий уровень, считывается очередной бит из линии данных, после чего тактовый вывод сбрасывается в низкий уровень.

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

Синтаксис

byte incoming = shiftIn(dataPin, clockPin, bitOrder)

Параметры

dataPin: вывод, с которого будет считываться каждый бит (int)

clockPin: тактовый вывод, который будет переключаться при считывании с dataPin

bitOrder: порядок, в котором будут сдвигаться и считываться биты; может принимать значения MSBFIRST или LSBFIRST. (Most Significant Bit First - старший значащий бит первым, или Least Significant Bit - младший значащий бит первым)

Возвращаемые значения

считанное значение (byte)

]]>
shiftOut() - Arduino IDE http://f-studio.biz/news/82-shiftout---arduino-ide.html Константин Portal-PK 2017-04-20T13:40:35+03:00 Осуществляет побитовый сдвиг и вывод байта данных, начиная с самого старшего (левого) или младшего (правого) значащего бита. Функция поочередно отправляет каждый бит на указанный вывод данных, после чего формирует импульс (высокий уровень, затем низкий) на тактовом выводе, сообщая внешнему устройству о поступлении нового бита.

Примечание: Для взаимодействия с устройствами, тактируемыми по фронту импульсов, перед вызовом shiftOut() необходимо убедиться, что тактовый вывод переключен в низкий уровень, например с помощью функции digitalWrite(clockPin, LOW).

Функция является программной реализацией SPI; аппаратная версия реализована в библиотеке SPI, поэтому она является быстрее, но работает только со специальными выводами.

Синтаксис

shiftOut(dataPin, bitOrder, value)

Параметры

dataPin: вывод, которому будет отправляться каждый бит из сдвигаемого байта данных (int)

clockPin: тактовый вывод, который будет переключаться каждый раз, когда на выводе dataPin устанавливается корректное значение (int)

bitOrder: характеризует порядок, в котором будут сдвигаться и выводиться биты; может принимать значения MSBFIRST или LSBFIRST. (Most Significant Bit First - старший значащий бит первым, или Least Significant Bit - младший значащий бит первым)

value: сдвигаемый байт данных (byte)

Возвращаемые значения

нет

Примечание

Выводы dataPin и clockPin должны быть уже сконфигурированы как выходы с помощью функции pinMode().

На данный момент функция shiftOut позволяет выводить только 1 байт (8 бит), поэтому для вывода значений, больших 255, требуется два этапа:

// Последовательная передача в режиме MSBFIRST
int data = 500;
// сдвигаем и выводим старший байт
shiftOut(dataPin, clock, MSBFIRST, (data >> 8));  
// сдвигаем и выводим младший байт
shiftOut(dataPin, clock, MSBFIRST, data);
 
// Последовательная передача в режиме LSBFIRST
data = 500;
// сдвигаем и выводим младший байт
shiftOut(dataPin, clock, LSBFIRST, data);  
// сдвигаем и выводим старший байт
shiftOut(dataPin, clock, LSBFIRST, (data >> 8));

Пример

Схема, соответствующая примеру, описана в инструкции по работе со сдвиговым регистром 74HC595.

//**************************************************************  //
//  Название : shiftOutCode, Hello World                           //
//  Автор    : Carlyn Maw,Tom Igoe                                 //
//  Дата     : 25 октября 2006                                     //
//  Версия   : 1.0                                                 //
//  Заметки  : Программа использования сдвигового регистра 74HC595 //
//           : для счета от 0 to 255                               //
//****************************************************************
 
//Вывод соединен с выводом ST_CP микросхемы 74HC595
int latchPin = 8;
//Вывод соединен с выводом SH_CP микросхемы 74HC595
int clockPin = 12;
////Вывод соединен с DS микросхемы 74HC595
int dataPin = 11;
 
void setup() {
  //переключение выводов в режим работы "вывод", т.к. к ним идет обращение в главном цикле
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
 
void loop() {
  //процедура последовательного счета
  for (int j = 0; j < 256; j++) {
    //формируем ноль на latchPin и удерживаем его до конца передачи
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, j);   
    //возвращаем высокий уровень на latchin, тем самым сообщая микросхеме о том, что
    //больше не требуется воспринимать информацию
    digitalWrite(latchPin, HIGH);
    delay(1000);
  }
}
]]>
noTone() - Arduino IDE http://f-studio.biz/news/81-notone---arduino-ide.html Константин Portal-PK 2017-04-20T13:36:11+03:00 Прекращает генерирование прямоугольного сигнала после использования функции tone(). Если сигнал не генерируется, функция ни к чему не приводит.

ПРИМЕЧАНИЕ: для воспроизведение разных звуков на нескольких выводах, необходимо сперва вызывать noTone() на одном выводе и только после этого использовать функцию tone() на следующем.

Синтаксис

noTone(pin)

Параметры

pin: вывод, на котором следует прекратить генерирование сигнала

Возвращаемые значения

нет

]]>
tone() - Arduino IDE http://f-studio.biz/news/80-tone---arduino-ide.html Константин Portal-PK 2017-04-20T13:34:20+03:00 Описание

Генерирует на выводе прямоугольный сигнал заданной частоты (с коэффициентом заполнения 50%). Функция также позволяет задавать длительность сигнала. Однако, если длительность сигнала не указана, он будет генерироваться до тех пор, пока не будет вызвана функция noTone(). Для воспроизведения звука вывод можно подключить к зуммеру или динамику.

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

Использование функции tone() может влиять на ШИМ-сигнал на выводах 3 и 11 (на всех платах, кроме Mega).

ПРИМЕЧАНИЕ: для воспроизведение разных звуков на нескольких выводах, необходимо сперва вызывать noTone() на одном выводе и только после этого использовать функцию tone() на следующем.

Синтаксис

tone(pin, frequency)
tone(pin, frequency, duration)

Параметры

pin: вывод, на котором будет генерироваться сигнал

frequency: частота сигнала в Герцах - unsigned int

duration: длительность сигнала в миллисекундах (опционально) - unsigned long

Возвращаемые значения

нет

]]>
sizeof - Arduino IDE http://f-studio.biz/news/79-sizeof---arduino-ide.html Константин Portal-PK 2017-04-20T13:26:57+03:00 Описание

Оператор sizeof возвращает количество байт, занимаемых типом переменной, либо количество байт, занимаемых массивом.

Синтаксис

sizeof(variable)

Параметры

variable: переменная любого типа или массив (например, int, float, byte)

Пример кода

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

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

char myStr[] = "this is a test";
int i;
 
void setup(){
  Serial.begin(9600);
}
 
void loop() { 
  for (i = 0; i < sizeof(myStr) - 1; i++){
    Serial.print(i, DEC);
    Serial.print(" = ");
    Serial.write(myStr[i]);
    Serial.println();
  }
  delay(5000); // задержка программы
}

Обратите внимание, что sizeof возвращает общее количество байтов. Поэтому, при работе с массивами более объемных типов данных (такими, как int), цикл будет выглядеть примерно так. Кроме того, не забывайте, что правильно объявленная строка заканчивается нулевым символом с ASCII-кодом 0.

for (i = 0; i < (sizeof(myInts)/sizeof(int)) - 1; i++) {
  // какие-либо операции с myInts[i]
}
]]>
Ключевое слово const http://f-studio.biz/news/78-klyuchevoe-slovo-const.html Константин Portal-PK 2017-04-20T13:24:04+03:00 Ключевое слово const обозначает константу. Это спецификатор, который изменяет поведение переменной и делает ее доступной только для чтения. Другими словами, эта переменная может использоваться так же, как и любая другая переменная этого же типа, однако ее значение изменить нельзя. Если вы попытаетесь переприсвоить значение константе, компилятор выдаст ошибку.

На константы, обозначенные ключевым словом const, распространяются те же правила области видимости, как и для обычных переменных. Именно поэтому использование ключевого слова keyword при объявлении констант более предпочтительно, чем использование директивы #define.

Пример

const float pi = 3.14;
float x;
// ....
x = pi * 2;    // удобно использовать константы при математических вычислениях
pi = 7;        // ошибка - нельзя записывать значения (изменять) константы

#define или const

Для создания числовых или строковых констант можно использовать как const, так и #define. Для массивов необходимо использоватьconst. В общем случае при объявлении констант предпочтительнее использовать const вместо #define.

]]>
Ключевое слово volatile http://f-studio.biz/news/77-klyuchevoe-slovo-volatile.html Константин Portal-PK 2017-04-20T13:22:16+03:00 volatile - это ключевое слово, известное как спецификатор переменной. Как правило, употребляется перед указанием типа переменной, чтобы изменить порядок ее обработки компилятором и последующей программой.

Объявление переменной как volatile - это директива компилятору. Компилятор - программа, которая переводит программный код C/C++ в машинный код, представляющий собой набор команд для микроконтроллера ATmega в Ардуино.

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

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

Пример:

// переключение светодиода при изменении состояния вывода
 
int pin = 13;
volatile int state = LOW;
 
void setup()
{
  pinMode(pin, OUTPUT);
  attachInterrupt(0, blink, CHANGE);
}
 
void loop()
{
  digitalWrite(pin, state);
}
 
void blink()
{
  state = !state;
}
]]>
Static - Arduino IDE http://f-studio.biz/news/76-static----arduino-ide.html Константин Portal-PK 2017-04-20T13:20:43+03:00 Ключевое слово static используется для создания переменных, которые будут видны только одной функции. Однако, в отличие от локальных переменных, которые создаются и уничтожаются при каждом вызове функции, переменные static сохраняют свое значение между вызовами.

Переменные, объявленные как static, создаются и инициализируются только при первом вызове функции.

Пример:

/* RandomWalk
* Paul Badger 2007
* RandomWalk в случайном порядке перемещается вверх или вниз между двумя
* точками. Длина максимального перемещения за один цикл задается 
* параметром "stepsize".
* Статическая переменная увеличивается или уменьшается на случайную величину.
* Эта техника также известна как "розовый шум" или "пьяная походка".
*/
 
#define randomWalkLowRange -20
#define randomWalkHighRange 20
int stepsize;
 
int thisTime;
int total;
 
void setup()
{
  Serial.begin(9600);
}
 
void loop()
{        //  функция randomWalk 
  stepsize = 5;
  thisTime = randomWalk(stepsize);
  Serial.println(thisTime);
   delay(10);
}
 
int randomWalk(int moveSize){
  static int  place;     // переменная для хранения величины случайного перемещения - объявлена как static, поэтому 
                         // сохраняет свое значение между вызовами функции. При этом другие функции не могут ее изменить
 
  place = place + (random(-moveSize, moveSize + 1));
 
  if (place < randomWalkLowRange){                    // проверка нижнего и верхнего пределов
    place = place + (randomWalkLowRange - place);     // восстановление числа в положительном направлении
  }
  else if(place > randomWalkHighRange){
    place = place - (place - randomWalkHighRange);     // восстановление числа в отрицательном направлении
  }
 
  return place;
}
]]>
Область видимости переменной http://f-studio.biz/news/75-oblast-vidimosti-peremennoi.html Константин Portal-PK 2017-04-20T13:18:53+03:00 В языке программирования C, использующемся при программировании Ардуино, переменные имеют свойство, называемое область видимости, чего нельзя сказать про первые языки программирования (подобные BASIC), в которых все переменные являютсяглобальными.

Глобальная переменная - эта та переменная, которая может быть доступна ("видна") из любой функции программы. Локальные переменные доступны только внутри тех функций, в которых они объявлены. При программировании Ардуино, любая переменная, объявленная за пределами функции (таких как, setup(), loop(), и т.д.), является глобальной переменной.

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

Также иногда удобно объявить и инициализировать переменную внутри цикла for. В этом случае переменная будет доступна только в пределах скобок цикла for.

Пример:

int gPWMval;  // эта переменная будет доступна из любой функции
 
void setup()
{
  // ...
}
 
void loop()
{
  int i;    // переменная "i" "видна" только внутри "loop"
  float f;  // переменная "f" "видна" только внутри "loop"
  // ...
 
  for (int j = 0; j <100; j++){
  // переменная j доступна только внутри скобок цикла for
  }
 
}
]]>
Выводы, сконфигурированные как INPUT_PULLUP http://f-studio.biz/news/63-vyvody-skonfigurirovannye-kak-input_pullup.html Константин Portal-PK 2017-03-02T08:26:09+03:00 Микроконтроллер ATmega в Ардуино имеет внутренние подтягивающие резисторы (резисторы, подключенные к питанию внутри микросхемы), которыми можно управлять. Если вы предпочитаете использовать их вместо внешних резисторов, подключенных к земле, - используйте параметр INPUT_PULLUP в функции pinMode(). Это позволит инвертировать поведение подключенного к выводу внешнего датчика: HIGH будет означать его отключение, а LOW - включение. См. пример использования INPUT_PULLUP при последовательной связи.

]]>
float() http://f-studio.biz/news/61-float.html Константин Portal-PK 2017-03-01T12:38:40+03:00 Описание

Приводит значение к типу float.

Синтаксис

float(x)

Параметры

x: значение любого типа

Возвращаемые значения

float

]]>
long() http://f-studio.biz/news/60-long.html Константин Portal-PK 2017-03-01T12:36:38+03:00 Описание

Приводит значение к типу long.

Синтаксис

long(x)

Параметры

x: значение любого типа

Возвращаемые значения

long

]]>
word() http://f-studio.biz/news/59-word.html Константин Portal-PK 2017-03-01T12:34:34+03:00 Описание

Приводит значение к типу word или создает значение типа word из двух байт.

Синтаксис

word(x)
word(h, l)

Параметры

x: значение любого типа

h: старший байт (левая часть) значения word

l: младший байт (правая часть) значения word

Возвращаемые значения

word


]]>
int() http://f-studio.biz/news/58-int.html Константин Portal-PK 2017-03-01T12:32:44+03:00 Описание

Приводит значение к типу int.

Синтаксис

int(x)

Параметры

x: значение любого типа

Возвращаемые значения

int


]]>
byte() http://f-studio.biz/news/57-byte.html Константин Portal-PK 2017-03-01T12:30:30+03:00 Описание

Приводит значение к типу byte.

Синтаксис

byte(x)

Параметры

x: значение любого типа

Возвращаемые значения

byte


]]>
char() Преобразование типов данных http://f-studio.biz/news/56-char-preobrazovanie-tipov-dannyh.html Константин Portal-PK 2017-03-01T12:27:37+03:00 Описание

Приводит значение к типу char.

Синтаксис

char(x)

Параметры

x: значение любого типа

Возвращаемые значения

char


]]>
Библиотека Servo http://f-studio.biz/news/51-biblioteka-servo.html Константин Portal-PK 2017-02-13T12:06:07+03:00 Эта библиотека функций для Arduino контроллера предоставляет набор функций для управления сервоприводами. Стандартные сервоприводы позволяют поворачивать привод на опредленный угол от 0 до 180 градусов обычно. Некоторые сервоприводы позволяют совершать полные обороты на заданной скорости.

Библиотека Servo позволяет одновременно управлять 12-ю сервоприводами на большинстве плат Arduino и 48-ю на Arduino Mega. На контроллерах отличных от Mega использование библиотеки отключает возможность использовать выходы 9 и 10 врежиме ШИМ даже если привод не подключен к этим выводам. На плате Mega могут быть использованы до 12 сервоприводов без потери функционала ШИМ. При использовании Mega для управления от 12 до 23 сервоприводов нельзя будет использовать выходы 11 и 12 для ШИМ.

Подключение

В общем случае сервопривод подключается 3-мя проводами : питание, земля и сигнальный. Обычно питание - красный провод и может быть подключен к выводу +5V на плате Arduino. Черный провод земля подключается к GND выводу Arduino, сигнальный, обычно желты, провод подключается к цифровому выводу котроллера Arduino. Следует отметить, что мощные сервоприводы могут создавать большую нагрузку, в этом случает он должен быть запитан отдельно (не через выход +5V Arduino). Тоже самое верно для случая подключения сразу нескольких сервоприводов. Убедитесь, что привод и контроллер подключены к общей земле.

Функции:


Servo.attach()

Подключает Servo к указанному выходу, с которого осуществляется управление приводом. На ранних версиях Arduino - 0016 и более ранних, библиотека Servo поддерживала управления только через порты 9 и 10.

Синтаксис

servo.attach(pin)
servo.attach(pin, min, max)

Параметры

  • servo: переменная типа Servo
  • pin: номер выхода, к которому подключаем servo и с которого осуществляется управление приводом
  • min (опциональный): ширина импульса в микросекундах, соответствующий минимальному (угол 0 градусов) положению сервопривода. (по умолчанию 544)
  • max (optional): ширина импульса в микросекундах, соответствующий максимальному (угол 180 градусов) положению сервопривода.

Пример

#include <Servo.h> 
Servo myservo;
    void setup() 
{ 
  myservo.attach(9);
} 
    void loop() {}


Servo.write()

Передает значения для управления приводом. Для стандартного сервопривода это угол поворота. Для привод постоянного вращения, функция задает скорость вращения (0 - для максимальной скорости вращения в одну сторону, 180 - для максимальной скорости в другую сторону и около 90 для неподвижного состояния).

Синтаксис

servo.write(angle)

Параметры

  • servo: переменная типа Servo
  • angle: значение записываемое в servo, от 0 до 180

Пример

#include <Servo.h> 
Servo myservo;
 void setup() 
{ 
  myservo.attach(9);
  myservo.write(90);  // устанавливает сервопривод в среднее положение
} 
  void loop() {}


Servo.writeMicroseconds()

Передает значение для управления сревоприводом в микросекундах (uS), устанавливая угол поворота на это значение. Для стандартного привода значение 1000 максимальный поворот против часовой стрелки, 2000 максимальный поворот по часовой стрелке, 1500 посередине.

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

Приводы постоянного вращения реагируют на данную комманду подобно реакции на функцию write().

Синтаксис

servo.writeMicroseconds(uS)

Параметры

  • servo: переменная типа Servo
  • uS: значение в микросекундах (int)

Пример

#include <Servo.h> 

Servo myservo;

void setup() 
{ 
  myservo.attach(9);
  myservo.writeMicroseconds(1500);  // устанавливает привод в среднее положение
} 

void loop() {}


Servo.read()

Считывает значение текущего положения сервопривода (значение записанное последним вызовом функции write()).

Синтаксис

servo.read()

Параметры

  • servo: a variable of type Servo

Возвращаемое значение

Положение (угол) сервопривода от 0 до 180.


Servo.attached()

Проверяет если переменная Servo подключена к выходу.

Синтаксис

servo.attached()

Параметры

  • servo: переменная типа Servo

Возвращаемое значение

  • true если подключена; false в противном случае.

Servo.detach()

Отсоединяет переменную Servo от указанного выхода. Если все Servo переменные отсоединены, то выходы 9 и 10 могут быть использованы в режиме ШИМ с помощью analogWrite().

Синтаксис

servo.detach()

Параметры

  • servo: переменная типа Servo
]]>
Константы с плавающей запятой (floating point constants) http://f-studio.biz/news/50-konstanty-s-plavayushchei-zapyatoi-floating-point-constants.html Константин Portal-PK 2017-02-13T12:01:15+03:00 Очень похожи на целочисленные константы. Используются в коде программы для более удобного понимания и чтения кода. Значения записываются по зарубежному стандарту только через точку.

Пример

n = .005;

Также принимаются значения, записанные с экспонентой вида «Е» и «е».

Формат записи константы с плавающей запятой Значение константы: либо:
10.0 10
2.34Е5 2.34 * 10^5 234000
67е-12 67.0 * 10^-12 .000000000067
]]>
Целочисленные константы http://f-studio.biz/news/49-celochislennye-konstanty.html Константин Portal-PK 2017-02-13T11:59:07+03:00 Целочисленные константы — это числа используемые напрямую в коде скетча, без определения переменной для их хранения. По умолчанию такие константы трактуются как тип int, но это может быть изменено директивами U и L (см. ниже)

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

Базис Пример Директива Комментарий
10 (decimal- десятеричный 123 нет
2 ( binary - двоичный) B1110111 первая B только для 8-бит значений (0-255), разрешенные знаки 0 и 1
8 (octal) 073 первая "0" разрешенные знаки 0-7
16(hexadecimal) 0x7B первые "0x" разрешенные знаки 0-9, A-F, a-f

Decimal (десятичные) базис 10. Наиболее распространен. Константы без префиксов (директив) по умолчанию считаются десятичными

Пример:

101     // 101 десятичные   ((1 * 10^2) + (0 * 10^1) + 1)

Binary (двоичный или бинарный) базис 2. Только 0 и 1 разрешены для записи.

Пример:

B101    // тоже что 5 десятичных   ((1 * 2^2) + (0 * 2^1) + 1)

Использование двоичного формата допускается только с 8-битными числами, принимающими значение от 0 (B0) до 255(B11111111). Если необходимо задать значение 16-битного целого )int бинарными константами, то это может быть сделано в два шага:

myInt = (B11001100 * 256) + B10101010;

Octal — базис 8. Допустимы 0-7. Форматирующий префикс "0".

Пример:

0101    // то же, что десятичное 65   ((1 * 8^2) + (0 * 8^1) + 1)

Внимание! Включение "0" перед константой по ошибке может привести к очень сложно-диагностируемой ошибке, из-за того, что компилятор будет считать константу в восьмеричной системе.

Hexadecimal (or hex) базис 16. Допустимы знаки 0-9, A-F и a-f. A — это десятеричное 10, B — 11, и т.д до F — 15. Предваряющий "0x" используется как форматирующая директива.

Пример:

0x101   // same as 257 decimal   ((1 * 16^2) + (0 * 16^1) + 1)

U и L директивы.

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

  • 'u' или 'U' для беззнакового целочисленного числа. Пример: 33u
  • 'l' или 'L' для long типа данных. Пример: 100000L
  • 'ul' или 'UL' для беззнакового числа long типа данных. Пример: 32767ul
]]>
Функция analogWrite() http://f-studio.biz/news/47-funkciya-analogwrite.html Константин Portal-PK 2017-02-08T13:53:34+03:00 Описание

Выдает аналоговую величину (ШИМ волну) на порт вход/выхода. Функция может быть полезна для управления яркостью подключенного светодиода или скоростью электродвигателя. После вызова analogWrite() на выходе будет генерироваться постоянная прямоугольная волна с заданной шириной импульса до следующего вызова analogWrite (или вызова digitalWriteили digitalRead на том же порту вход/выхода). Частота ШИМ сигнала приблизительно 490 Hz.

На большинстве плат Arduino (на базе микроконтроллера ATmega168 или ATmega328) ШИМ поддерживают порты 3, 5, 6, 9, 10 и 11, на плате Arduino Mega порты с 2 по 13. На более ранних версиях плат Arduino analogWrite() работал только на портах 9, 10 и 11.

Для вызова analogWrite() нет необходимости устанавливать тип вход/выхода функцией pinMode().

Функция analogWrite никак не связана с аналоговыми входами и с функцией analogRead.

Синтаксис

analogWrite(pin, value)

Параметры
  • pin: порт вход/выхода на который подаем ШИМ сигнал.
  • value: период рабочего цикла значение между 0 (полностью выключено) and 255 (сигнал подан постоянно).
Возвращаемое значение

нет

Замечание

Период ШИМ сигнала на портах вход/выхода 5 и 6 будет несколько длиннее. Это связано с тем, что таймер для данных выходов также задействован функциями millis() и delay(). Данный эффект более заметен при установке коротких периодов ШИМ сигнала (0-10).

Пример

Задание яркости светодиода пропорционально значению, снимаемому с потенциометра

int ledPin = 9;    // Светодиод подключен к выходы 9
int analogPin = 3; // потенциометр подключен к выходу 3
int val = 0;       // переменная для хранения значения

void setup()
{
    pinMode(ledPin, OUTPUT);      // установка порта на выход
}

void loop()
{
    val = analogRead(analogPin);  // считываем значение с порта, подключенному к потенциометру
    analogWrite(ledPin, val / 4); // analogRead возвращает значения от 0 до 1023, analogWrite должно быть в диапозоне от 0 до 255
}
]]>
Функция analogReference() http://f-studio.biz/news/46-funkciya-analogreference.html Константин Portal-PK 2017-02-08T13:51:48+03:00 Описание

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

Возможные настройки:

  • DEFAULT: стандартное опорное напряжение 5 В (на платформах с напряжением питания 5 В) или 3.3 В (на платформах с напряжением питания 3.3 В)
  • INTERNAL: встроенное опорное напряжение 1.1 В на микроконтроллерах ATmega168 и ATmega328, и 2.56 В на ATmega8.
  • INTERNAL1V1: встроенное опорное напряжение 1.1 В (Arduino Mega)
  • INTERNAL2V56: встроенное опорное напряжение 2.56 (Arduino Mega)
  • EXTERNAL: внешний источник опорного напряжения, подключенный к выводу AREF
Синтаксис
analogReference(type)
Параметры

type: определяет используемое опорное напряжение (DEFAULT, INTERNAL или EXTERNAL).

Возвращаемое значение

нет

Внимание

Внешнее напряжение рекомендуется подключать к выводу AREF через резистор 5 кОм.

Таким образом уменьшается риск повреждения микросхемы Atmega если настройки analogReference не совпадают с возможностями платформы. Однако при этом произойдет небольшая просадка напряжения, вследствие того, что имеется встроенный резистор 32 кОм, подключенный к выводу AREF. В этом случае оба резистора работают как делитель напряжения. Подсоединение внешнего резистора позволяет быстро переключаться на напряжение 3.3 В вывода AREF с напряжения 5 В DEFAULT без конфигурации аппаратной части и АЦП.

Использование вывода AREF

Напряжение, подключенное к выводу AREF, конвертируется АЦП и, затем, определяется значение напряжения, при котором АЦП выдает самое высокое цифровое значение, т.е 1023. Другие значения напряжения, поступающие в АЦП, конвертируются пропорционально. Таким образом, при настройке DEFAULT 5 В значение напряжения 2.5 В в АЦП будет конвертироваться в 512.

В стандартной конфигурации платформ Arduino вывод AREF (вывод 21 Atmega) не задействован. В этом случае при настройке DEFAULT к выводу подключается внутреннее напряжение AVCC. Соединение является низко-импедансным и любое напряжение подведенное к выводу в этот момент может повредить микросхему ATMEGA.

Настройкой INTERNAL к выводу AREF подключается внутреннее напряжение 1.1 В (или 2.56 микросхемы ATmega8). При этом напряжение соответствующее или превышающее 1.1 В будет конвертироваться АЦП в 1023. Другие значения напряжения конвертируются пропорционально.

Внутреннее подключение источника 1.1 В к выводу является высоко-импедансным, что означает, что для измерение напряжения на выводе может быть произведено только мультиметром с высоким сопротивлением. Ошибочное подключение напряжения к выводу AREF при этой настройке функции analogReference не повредит микросхему, но превысит значение 1.1 В. В этом случае АЦП будет конвертировать напряжение внешнего источника. Во избежание вышеописанных проблем настоятельно рекомендуется подключать внешнее напряжение через резистор 5 кОм.

Рекомендуемой настройкой для вывода AREF является EXTERNAL. При этом происходит отключение обоих внутренних источников, и внешнее напряжение будет являться опорным для АЦП.

]]>
Функция analogRead() http://f-studio.biz/news/45-funkciya-analogread.html Константин Portal-PK 2017-02-08T13:49:11+03:00 Функция считывает значение с указанного аналогового входа. Большинство плат Arduino имеют 6 каналов (8 каналов у платы Mini и Nano, 16 у Mega) c 10-битным аналого-цифровым преобразователем (АЦП). Напряжение поданное на аналоговый вход, обычно от 0 до 5 вольт будет преобразовано в значение от 0 до 1023, это 1024 шага с разрешением 0.0049 Вольт. Разброс напряжение и шаг может быть изменен функцией analogReference().

Считывание значение с аналогового входа занимает примерно 100 микросекунд (0.0001 сек), т.е. максимальная частота считывания приблизительно 10,000 раз в секунду.

Синтаксис

analogRead(pin)

Параметры

pin: номер порта аналогового входа с которого будет производиться считывание (0..5 для большинства плат, 0..7 для Mini и Nano и 0..15 для Mega)

Возвращаемое значение

int (0 to 1023)

Замечание

Если аналоговый вход не подключен, то значения возвращаемые функцией analogRead() могут принимать случайные значения.

Пример
int analogPin = 3;     // номер порта к которому подключен потенциометр
int val = 0;           // переменная для хранения считываемого значения

void setup()
{
  Serial.begin(9600);              //  установка связи по serial
}

void loop()
{
  val = analogRead(analogPin);     // считываем значение
  Serial.println(val);             // выводим полученное значение
}
]]>
+= , -= , *= , /= http://f-studio.biz/news/43-+=---=--*=---=.html Константин Portal-PK 2017-02-07T11:56:44+03:00 Короткий способ записи арифметических действий над переменной и одним операндом.

Синтаксис
x += y;   // эквивалент записи x = x + y;
x -= y;   // эквивалент записи x = x - y; 
x *= y;   // эквивалент записи x = x * y; 
x /= y;   // эквивалент записи x = x / y;
Параметры
  • x: переменная любого типа
  • y: переменная любого типа или константа
Пример
x = 2;
x += 4;      // x равно 6
x -= 3;      // x равно 3
x *= 10;     // x равно 30
x /= 2;      // x равно 15
]]>
++ (увеличение значения) / -- (уменьшение значения) http://f-studio.biz/news/42-++-uvelichenie-znacheniya------umenshenie-znacheniya.html Константин Portal-PK 2017-02-07T11:54:35+03:00 Унарные (имеющие один операнд) операторы ++, -- увеличивают, уменьшают значение переменной соответственно.

Синтаксис
x++;  // увеличивает значение x на единицу и возвращает старое значение x
++x;  // увеличивает значение x на единицу и возвращает новое значение x

x-- ;   // уменьшает значение x на единицу и возвращает старое значение x
--x ;   // уменьшает значение x на единицу и возвращает новое значение x
Параметры
  • x: переменная типа int или long (может быть беззнаковой)
Возвращаемое значение

Изначальное или новое, увеличенное или уменьшенное на единицу, значение переменной.

Пример
x = 2;
y = ++x;      // x теперь равно 3, y равно 3
y = x--;      // x равно 2, y равно 3
]]>
Логические операторы http://f-studio.biz/news/41-logicheskie-operatory.html Константин Portal-PK 2017-02-07T11:51:39+03:00 Логические операторы чаще всего используются в проверке условия оператора if. Базовые сведения о логических операциях, смотрите в Википедии.

&& (логическое И)

Истина, если оба операнда истина (true).

if (digitalRead(2) == HIGH  && digitalRead(3) == HIGH) { // считывает состояние двух портов
  // ...
}

Истина если оба порта вход/выхода HIGH

|| (логическое ИЛИ)

Истина, если хотя бы один операнд истина, например:

if (x > 0 || y > 0) {
  // ...
}

будет верно (истина) если x или y больше 0.

! (логическое отрицание)

True, если операнд false, и наоборот, например:

if (!x) {
  // ...
}

условие верно, если x - false (x равно 0).

Важно различать логический оператор "И" - && и битовый оператор "И" - &. Тоже самое относится к логическому оператору "ИЛИ" - || и битовому оператору "ИЛИ" - |.

Пример
if (a >= 10 && a <= 20){}   // условие верно, если a больше 10, но меньше 20
]]>
Операторы сравнения http://f-studio.biz/news/40-operatory-sravneniya.html Константин Portal-PK 2017-02-07T11:47:12+03:00 x == y (x равно y) x != y (x не равно y) x < y (x меньше чем y) x > y (x больше чем y) x <= y (x меньше чем или равно y) x >= y (x больше чем или равно y)

Внимание!

Следите, чтобы случайно не использовать знак простого равенства (например, if (x = 10)). Знак простого равенства – это оператор присваивания, и устанавливает значение х равное 10 (заносит значение 10 в переменную х). Вместо этого используйте знак двойного равенства (например, if (x == 10)), который является оператором сравнения и проверяет, х равен 10 или нет. Последнее из двух выражений будет истинно, только если х равен 10, но предыдущее выражение всегда верно.

Это связано с тем, что С вычисляет выражение if (x=10) следующим образом: значение 10 присваивается х (помним, что простой знак равенства – это оператор присваивания), таким образом, х теперь равен 10. Затем условный if вычисляет 10, которое уже равно ИСТИНА, так как любое число, неравное 0, равно ИСТИНА. Поэтому if (x=10) будет всегда иметь логическое значение ИСТИНА, которое не является желательным результатом, когда используется оператор if. Вдобавок, переменной х будет присвоено значение 10, что также не является желаемым действием.

]]>
% оператор http://f-studio.biz/news/39-%-operator.html Константин Portal-PK 2017-02-07T11:44:28+03:00 Возвращает остаток от деления одного целого (int) операнда на другой.

Синтаксис
result = dividend % divisor
Параметры
  • dividend: делимое
  • divisor: делитель
Возвращаемое значение

Остаток от деления.

Пример
x = 7 % 5;   // x имеет значение 2
x = 9 % 5;   // x имеет значение 4
x = 5 % 5;   // x имеет значение 0
x = 4 % 5;   // x имеет значение 4
Советы по использованию %

Нельзя применить к типу float.

]]>
Арифметические операторы http://f-studio.biz/news/38-arifmeticheskie-operatory.html Константин Portal-PK 2017-02-07T11:42:02+03:00 Сложение, вычитание, умножение и деление

Операторы +, -, * и / соответственно, возвращают результат выполнения арифметических действий над двумя операндами. Возвращаемый результат будет зависеть от типа данных операндов, например, 9 / 4 возвратит 2, т.к. операнды 9 и 4 имеют тип int. Также следует следить за тем, чтобы результат не вышел за диапазон допустимых значений для используемого типа данных. Так, например, сложение 1 с переменной типа int и значением 32 767 возвратит -32 768. Если операнды имеют разные типы, то тип с более "широким" диапазоном будет использован для вычислений.

Если один из операндов имеет тип float или double, то арифметика "с плавающей запятой" будет использована для вычислений.

Пример
y = y + 3;
x = x - 7;
i = j * 6;
r = r / 5;

Синтаксис

result = value1 + value2;
result = value1 - value2;
result = value1 * value2;
result = value1 / value2;
Параметры
  • value1: любая переменная или константа
  • value2: любая переменная или константа
]]>
= оператор присваивания http://f-studio.biz/news/37-=-operator-prisvaivaniya.html Константин Portal-PK 2017-02-07T11:39:49+03:00 Присваивает переменной слева от оператора значение переменной или выражения, находящееся справа.

Пример
int sensVal;                 // объявление переменной типа integer
senVal = analogRead(0);       // присваивание переменной sensVal, значения, считанное с аналогового входа 0
Важно

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

Необходимо различать оператор присваивания (=) и оператор сравнения (== двойной знак равенства), который осуществляет проверку на равенство.

]]>
Комментарии http://f-studio.biz/news/36-kommentarii.html Константин Portal-PK 2017-02-07T11:37:59+03:00 Комментарии – это строки в программе, которые используются для информирования вас самих или других о том, как работает программа. Они игнорируются компилятором и не экспортируются в процессор, таким образом, они не занимают место в памяти микроконтроллера Atmega.

Комментарии предназначены только для того, чтобы помочь вам понять (или вспомнить), как работает ваша программа или объяснить это другим. Есть два способа пометить строку как комментарий:

Пример
x = 5; // Это комментарий в одной строке. Все после двойного слэша – комментарий
      // до конца строки

/* это многострочный комментарий – используйте его для закоментирования целых кусков кода

if (gwb == 0){   // комментарий в строке допустим внутри многострочного комментария
                // но не другой многострочный комментарий
}

// не забывайте «закрывать» комментарии – они должны быть парными!
*/
Подсказка

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

]]>
{} (фигурные скобки) http://f-studio.biz/news/35-{}-figurnye-skobki.html Константин Portal-PK 2017-02-07T11:36:23+03:00 Фигурные скобки {} (также называются просто «скобки») – важный элемент языка программирования С. Они используются в нескольких различных конструкциях, приведенных ниже, и это может иногда сбивать с толку начинающих.

Открывающая скобка “{” должна всегда сопровождаться закрывающей скобкой “}”. Это условие, известное как парность (симметричность) фигурных скобок. Arduino IDE (интегрированная среда разработчика) включает подходящий инструмент для проверки парности скобок. Достаточно выделить скобку, или даже поставить курсор сразу же за скобкой, как будет подсвечена её логическая пара.

Сейчас эта возможность работает с ошибкой, так как IDE часто ищет (некорректно) скобку в тексте, который «закомментирован».

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

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

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

Основные способы использования фигурных скобок

Функции

void НазваниеФункции(тип данных аргумента){
   оператор(ы)
}

Циклы

while (логическое выражение)
 {
     оператор(ы)
 }
//////////////////////////
do<p>{
   оператор(ы)</p><p>} while (логическое выражение);
///////////////////////
for (инициализация; условие окончания цикла; приращения цикла)</p><p>{</p><p>   оператор(ы)</p><p>}</p>

Условные операторы

if (логическое выражение)
{
   оператор(ы)
}
else if (логическое выражение)
{
   оператор(ы)
}
else
{
   оператор(ы)
}
]]>
; (точка с запятой) http://f-studio.biz/news/34-;-tochka-s-zapyatoi.html Константин Portal-PK 2017-02-07T11:31:27+03:00 Синтаксис ; (точка с запятой) используется для обозначения конца оператора.

Пример

int a = 13;

Подсказка

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

]]>
Ключевое слово void http://f-studio.biz/news/33-klyuchevoe-slovo-void.html Константин Portal-PK 2017-02-07T06:52:22+03:00 Ключевое слово void используется при объявлении функций, если функция не возвращает никакого значение при ее вызове (в некоторых языках программирования такие функции называют процедурами).

Пример
// в функциях "setup" и "loop" производятся некоторые действия,
// но ничего не возвращается во внешнюю программу

void setup()
{
  // ...
}

void loop()
{
  // ...
}
]]>
Массивы (arrays) http://f-studio.biz/news/32-massivy-arrays.html Константин Portal-PK 2017-02-07T06:50:51+03:00 Массивы (arrays) — именованный набор однотипных переменных, с доступом к отдельным элементам по их индексу.

ОБЪЯВЛЕНИЕ МАССИВОВ

Ниже приведены несколько корректных вариантов объявления массивов:

int myInts[6];
int myPins[] = {2, 4, 8, 3, 6};
int mySensVals[6] = {2, 4, -8, 3, 2};
char message[6] = "hello";

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

Массив myPins был объявлен без явного задания размера. Компилятор сам посчитает фактическое количество элементов и создаcт в памяти массив необходимого размера.

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

Доступ к элементам массива

Индексация массива начинается с 0. Это значит, что для массива с 10-тью элементами, индекс 9 будет последним:

int myArray[10]={9,3,2,4,3,2,7,8,9,11};
     // myArray[0]    первый элемент, содержит 9
     // myArray[9]    последний элемент, содержит 11
     // myArray[10]   это неверно возможно возвращение произвольного значения из области памяти не относящийся к массиву

Присваиваем значение элементу массива

mySensVals[0] = 10;

Возвращаем значение элемента массива:

x = mySensVals[4];
Массивы и FOR циклы

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

int i;
for (i = 0; i < 5; i = i + 1) {
  Serial.println(myPins[i]);
}
]]>
String http://f-studio.biz/news/31-string.html Константин Portal-PK 2017-02-07T06:45:35+03:00 String класс появился в версии Arduino 0019. Этот класс позволяет хранить и манипулировать текстовыми строками, по сравнению с string (массивом символов) класс String предоставляет удобные функции для работы со строками, такие как поиск вхождения в строку, объединение строк и др. Класс String занимает несколько больше места в памяти, чем массив символов string.

Обратите внимание при обращение к классу String — он пишется с заглавной S. Массив символов string — с прописной s. Строковые константы, записанные в "двойных кавычка" интерпретируются компилятором как массив символов, а не объект класса String.

]]>
string - текстовые строки http://f-studio.biz/news/30-string---tekstovye-stroki.html Константин Portal-PK 2017-02-07T06:44:33+03:00 Описание

Текстовые строки в Ардуино объявляются как массив (array) типа char (символов - литер), оканчивающийся символом "конца строки".

Синтаксис

Ниже приведены варианты объявления и присвоения строк:

char Str1[15];
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
char Str4[ ] = "arduino";
char Str5[8] = "arduino";
char Str6[15] = "arduino";

Возможны следующие варианты объявления текстовых строк:

  • Объявить массив символов без присваивания значений — Str1
  • Объявить массив символов и присвоить значения всем элементам, кроме последнего, компилятор Arduino автоматически добавит символ конца строки, как в Str2
  • Явно объявить завершающий символ, как в Str3
  • Инициализировать массив строковой константой в двойных кавычках. Компилятор автоматически задаст требуемый размер на массив, равный количеству символов плюс завершающий символ, как в варианте Str4
  • Инициализировать массив с явным заданием размера и присвоением строковой константы, строка Str5
  • Инициализировать массив с явным заданием дополнительного размера (с запасом), фактически превышающего размер строковой константы при начальном присвоение, как в варианте Str6
Символ окончания строки

Обычно строки оканчиваются нулевым символом (код 0 в ASCII). Это позволяет функциям (таким как Serial.print()) выявлять окончание строки. В противном случае могут считаться байты памяти, не принадлежащие переменной.

Массивы символов, выделяемый под строку, должен иметь один дополнительный элемент для символа конца строки. Именно поэтому Str2 и Str5 должны иметь 8 символом, хотя "arduino" 7 символов — последнему элементу автоматически присваивается символ окончания строки.

Технически возможно объявить строку без символа окончания строки, например, объявить длину массива равной 7 для Str2. Это приведет к некорректной работе функций, оперирующих строками.

Одинарные и двойные кавычки

Строки всегда объявляются внутри двойных кавычек ("Abc"). Символы — внутри одинарных ('A')

Инициализация длинных строк

Длинные строки могут быть объявлены так:

char myString[] = "This is the first line"
" this is the second line"
" etcetera";
Массивы строк

При работе с большими объемами текстовой информации, например в проектах с LCD дисплеем, бывает удобно использовать массивы строк. Так как строки сами по себе массивы, массивы строк будет двумерным массивом.

В примере ниже, символ звездочки после объявления типа "char*" указывает на то, что это массив указателей. Это необходимо для задания двумерного массива. В данном случае не требуется понимания всех тонкостей работы с указателями.

Пример
char* myStrings[]={"This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5","This is string 6"};


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


void loop(){
for (int i = 0; i < 6; i++){
   Serial.println(myStrings[i]);
   delay(500);
   }
}
]]>
double http://f-studio.biz/news/29-double.html Константин Portal-PK 2017-02-07T06:38:59+03:00 Описание типа данных

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

Тип double поддерживается в Arduino для совместимости кода с другими платформами.

]]>
float http://f-studio.biz/news/28-float.html Константин Portal-PK 2017-02-07T06:37:33+03:00 Описание типа

Тип данных float служит для хранения чисел с плавающей запятой. Этот тип часто используется для операций с данными, считываемыми с аналоговых входов. Диапазон значений — от -3.4028235E+38 до 3.4028235E+38. Переменная типа floatзанимает 32 бита (4 байта) в памяти.

Тип float имеет точность 6-7 знаков, имеются ввиду все знаки, а не только мантисса. Обычно для увеличения точности используют другой тип - double, но на платформе Arduino, double и float имеют одинаковую точность.

Хранение в памяти чисел с плавающей точкой в двоичной системе обуславливает потерю точности. Так, например, 6.0 / 3.0 не обязательно равен 2.0. Сравнивая два числа с плавающей точкой следует проверять не точное равенство, а разницу между этими числами, меньше ли она некого выбранной малого порога.

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

Пример
float myfloat;
float sensorCalbrate = 1.117;

Синтаксис

float var = val;
  • var - имя переменной
  • val - присваиваемое значение
Пример использования в коде
int x;
int y;
float z;

x = 1;
y = x / 2;            // y теперь равен 0, тип int не может хранить дробные числа
z = (float)x / 2.0;   // z равна .5 (следует использовать 2.0, а не 2)
]]>
unsigned long http://f-studio.biz/news/27-unsigned-long.html Константин Portal-PK 2017-02-07T06:33:06+03:00 Описание типа

Unsigned long используется для хранения положительных целых чисел в диапазоне от 0 до 4,294,967,295 (2^32 - 1) изанимает 32 бита (4 байта) в памяти.

Пример
unsigned long time;

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

void loop()
{
  Serial.print("Time: ");
  time = millis();
  //выводит время прошедшее с момента начала выполнения программы
  Serial.println(time);
  // ожидаем (делаем пауза) 1 секунду
  delay(1000);
}

Синтаксис

unsigned long var = val;
  • var - имя переменной
  • val - присваиваемое значение
]]>
long http://f-studio.biz/news/26-long.html Константин Portal-PK 2017-02-07T06:30:48+03:00 Описание типа

Тип данных long используется для хранения целых чисел в расширенном диапазоне от -2,147,483,648 до 2,147,483,647.long занимает 4 байта в памяти.

Пример
long speedOfLight = 186000L;  // См. значение постфикса 'L' в теме Целочислесленные константы

Синтаксис

long var = val;
  • var - имя переменной
  • val - присваиваемое значение
]]>
word http://f-studio.biz/news/25-word.html Константин Portal-PK 2017-02-07T06:27:45+03:00 Описание типа

Тип данных word хранит 16-битное, не содержащее знака, число от 0 до 65535. Тоже самое, что unsigned int — (беззнаковое целое число).

Пример
word w = 10000;
]]>
unsigned int http://f-studio.biz/news/24-unsigned-int.html Константин Portal-PK 2017-02-06T09:26:26+03:00 Описание типа

Тип данных unsigned int - беззнаковое целое число, также как и тип int (знаковое) занимает в памяти 2 байта. Но в отличие от int, тип unsigned int может хранить только положительные целые числа в диапазоне от 0 до 65535 (2^16)-1).

Отличие кроется в том как unsigned int использует старший бит, иногда называемый знаковый бит. Если старший бит равен 1, то для типа int компилятор Arduino считает, что это число отрицательное, а остальные 15 bit несут информацию о модуле целого числа в дополнительного кода представления числа, в то время как unsigned int использует все 16 бит для хранения модуля числа.

Пример
unsigned int ledPin = 13;

Синтаксис

unsigned int var = val;
  • var - имя переменной
  • val - присваиваемое значение
Замечание по использованию типа unsigned int

Когда переменная типа int в следствие арифметической операции достигает своего максимального значения, она "перескакивает" на самое минимальное значение и наоборот:

unsigned int x
   x = 0;
   x = x - 1;       // x теперь равна 65535 
   x = x + 1;       // x теперь 0
]]>
int http://f-studio.biz/news/23-int.html Константин Portal-PK 2017-02-06T09:23:35+03:00 Описание типа данных

Тип данных int (от англ. integer - целое число) один их наиболее часто используемых типов данных для хранения чисел. int занимает 2 байта памяти, и может хранить числа от -32 768 до 32 767 (от -2^15 до 2^15-1)

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

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

Пример
int ledPin = 13;
Синтаксис

int var = val;

  • var - имя переменной;
  • val - значение присваиваемое переменной;
Замечание по использованию типа int

Когда переменная типа int в следствие арифметической операции достигает своего максимального значения, она "перескакивает" на самое минимальное значение и наоборот:

int x
x = -32,768;
x = x - 1;       // x теперь равно 32,767 - перескакивает на минимальное значение

x = 32,767;
x = x + 1;       // x теперь равно -32,768
]]>
byte http://f-studio.biz/news/22-byte.html Константин Portal-PK 2017-02-06T09:20:00+03:00 Описание типа

Тип данных byte 8-ми битное беззнаковое целое число, в диапазоне 0..255.

byte c = B10010;  // "B" префикс двоичной системы счисления(B10010 = 18 в десятичной системе счисления)
]]>
char http://f-studio.biz/news/21-char.html Константин Portal-PK 2017-02-06T09:18:54+03:00 Переменная типа char занимает 1 байт памяти и может хранить один алфавитно-цифровой символ (литеру). При объявление литеры используются одиночные кавычки: 'A' (двойные кавычки используется при объявлении строки символов - тип string: "ABC").

Символ хранится в памяти как число, соответствующее коду символа в таблице кодировки символов ASCII. Т.к. символ хранится как число в памяти над ним возможно производить арифметические действия (например, 'A' + 1 будет 66, т.к. ASCII код для 'A' - 65).

Тип char знаковый тип, т.е. число (код) хранящийся в памяти может принимать значения от -128 до 127. Если необходим беззнаковая однобайтовая переменная, используйте тип byte.

char myChar = 'A';
char myChar = 65;      //Варианты эквивалентны


]]>
boolean http://f-studio.biz/news/20-boolean.html Константин Portal-PK 2017-02-06T09:17:19+03:00 Логический (булевый) тип данных — boolean. Может принимать одно из двух значений true или false. boolean занимает в памяти один байт.

int LEDpin = 5;       // Светодиод на входе 5
int switchPin = 13;   // выключатель на порту 13, замыкает на землю


boolean running = false;


void setup()
{
  pinMode(LEDpin, OUTPUT);
  pinMode(switchPin, INPUT);
  digitalWrite(switchPin, HIGH);      // включаем подтягивающий резистор
}


void loop()
{
  if (digitalRead(switchPin) == LOW)
  {  // выключатель нажат, т.к. подтягивающий резистор будет давайть HIGH на входе, если не замкнут напрямую на землю
    delay(100);                        // ждем 0.1сек
    running = !running;                // меняем значение булевой переменной
    digitalWrite(LEDpin, running)      // включаем или выключаем светодиод.
  }
}


]]>
Оператор goto http://f-studio.biz/news/19-operator-goto.html Константин Portal-PK 2017-02-03T06:45:38+03:00 Условное «перемещение» выполнения программы к определенной метке-указателю в самой программе, при этом пропускается весь код до самой метки, а исполняется - после нее.

Синтаксис:
label: 
//
// какой-либо код
//
goto label; // переходим к метке label
Замечание по использованию

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

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

Пример
for(byte r = 0; r < 255; r++){
    for(byte g = 255; g > -1; g--){
        for(byte b = 0; b < 255; b++){
            if (analogRead(0) > 250){ goto bailout;}
            // еще код
        }
    }
}
bailout:


]]>
return http://f-studio.biz/news/18-return.html Константин Portal-PK 2017-02-03T06:43:36+03:00 Прекращает вычисления в функции и возвращает значение из прерванной функции в вызывающую, если это нужно.

Синтаксис

return;

return значение; // обе формы допустимы

Параметры

Значение: переменная или константа любого типа

Примеры:

Функция сравнивает значение на датчике входа с пороговым

int checkSensor(){      
    if (analogRead(0) > 400) {
        return 1;
    else{
        return 0;
    }
}

С помощью ключевого слова return удобно тестировать блоки кода без «закомментирования» больших кусков с возможным ошибочным кодом.

void loop(){

  // здесь блестящая идея тестирования кода

  return;

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

}
]]>
continue http://f-studio.biz/news/17-continue.html Константин Portal-PK 2017-02-03T06:40:30+03:00 Оператор continue пропускает оставшиеся операторы в текущем шаге цикла. Вместо них выполняется проверка условного выражения цикла, которая происходит при каждой следующей итерации.

for (x = 0; x < 255; x ++)
{
    if (x > 40 && x < 120){      // если истина то прыгаем сразу на следующую итерацию цикла
        continue;
    }

    digitalWrite(PWMpin, x);
    delay(50);

}
]]>
break http://f-studio.biz/news/16-break.html Константин Portal-PK 2017-02-03T06:38:49+03:00 Break используется для принудительного выхода из циклов do, for или while, не дожидаясь завершения цикла по условию. Он также используется для выхода из оператора switch

Пример
for (x = 0; x < 255; x ++)
{
    digitalWrite(PWMpin, x);
    sens = analogRead(sensorPin); 
    if (sens > threshold){      // выходим из цикла если есть сигнал с датчика
       x = 0;
       break;
    } 
    delay(50);
}
]]>
do ... while http://f-studio.biz/news/15-do--while.html Константин Portal-PK 2017-02-03T06:37:25+03:00 Цикл do работает так же, как и цикл while, за исключением того, что условие проверяется в конце цикла, таким образом, цикл do будет всегда выполняться хотя бы раз.

do
{
    // последовательность операторов
} while (проверка условия);

Пример

do
{
  delay(50);          // подождать, пока датчики стабилизируются
  x = readSensors(); // проверить датчики 
} while (x < 100);
]]>
Циклы while http://f-studio.biz/news/14-cikly-while.html Константин Portal-PK 2017-02-03T06:35:41+03:00 While будет вычислять в цикле непрерывно и бесконечно до тех пор, пока выражение в круглых скобках, () не станет равно логическому ЛОЖНО. Что-то должно изменять значение проверяемой переменной, иначе выход из цикла whileникогда не будет достигнут. Это изменение может происходить как в программном коде, например, при увеличении переменной, так и во внешних условиях, например, при тестировании датчика.

Синтаксис
while(выражение){
 // оператор(ы)
}
Параметры

выражение - (булевский) C-оператор, который возвращает значение истина или ложь

Пример
var = 0;

while(var < 200){
 // выполнить что-то, повторив 200 раз
 var++;
}
]]>
Функция delay() http://f-studio.biz/news/13-funkciya-delay.html Константин Portal-PK 2017-02-01T09:11:42+03:00 Останавливает выполнение программы на заданное в параметре количество миллисекунд (1000 миллисекунд в 1 секунде).

Синтаксис
delay(ms)
Параметры

ms: количество миллисекунд, на которое приостанавливается выполнение программы.

Возвращаемое значение

Нет

Пример
int ledPin = 13;                 // светодиод подключен на порт 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // устанавливается режим порта - выход
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // включаем светодиод
  delay(1000);                  // ожидаем секунду
  digitalWrite(ledPin, LOW);    // выключаем светодиод
  delay(1000);                  // ожидаем секунду
}
Замечания по использования функции

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

Большинство активности платы останавливается функцией delay(). Тем не менее работа прерываний не останавливается, продолжается запись последовательно (serial) передаваемых данных на RX порту, ШИМ сигнал (analogWrite) продолжает генерироваться на портах.

]]>
Оператор Switch http://f-studio.biz/news/12-operator-switch.html Константин Portal-PK 2017-02-01T09:00:59+03:00 Подобно конструкции if, switch...case управляет процессом выполнения программы, позволяя программисту задавать альтернативный код, который будет выполняться при разных условиях. В частности, оператор switch сравнивает значение переменной со значением, определенном в операторах case. Когда найден оператор case, значение которого равно значению переменной, выполняется программный код в этом операторе.

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

switch (var) {
    case 1:
      //выполняется, когда var равно 1
      break;
    case 2:
      //выполняется когда  var равно 2
      break;
    default: 
      // выполняется, если не выбрана ни одна альтернатива 
      // default необязателен 
  }

Синтаксис:

switch (var) {
 case label:
    // код для выполнения
    break;
 case label:
    // код для выполнения
    break;
 default:
    // код для выполнения
}

Параметры:

  • var: переменная, которая вычисляется для сравнения с вариантами в case
  • label: значение, с которым сравнивается значение переменно


]]>
Оператор For http://f-studio.biz/news/11-operator-for.html Константин Portal-PK 2017-02-01T08:57:00+03:00 Конструкция for используется для повторения блока операторов, заключенных в фигурные скобки. Счетчик приращений обычно используется для приращения и завершения цикла. Оператор for подходит для любых повторяющихся действий и часто используется в сочетании с массивами коллекций данных/выводов.

Заголовок цикла for состоит из трех частей:

for (initialization; condition; increment) {операторы выполняющиеся в цикле}

Инициализация (Initialization) выполняется самой первой и один раз. Каждый раз в цикле проверяется условие (condition), если оно верно, выполняется блок операторов и приращение (increment), затем условие проверяется вновь. Когда логическое значение условия становится ложным, цикл завершается.

Пример
// Затемнение светодиода с использованием ШИМ-вывода
int PWMpin = 10; // Светодиод последовательно с резистором 470 ом на 10 выводов
void setup()
{
 // настройка не нужна 
}
void loop()
{
   for (int i=0; i <= 255; i++){
      analogWrite(PWMpin, i);
      delay(10);
   }
}
Советы по применению

Цикл for в Си гораздо более гибкий, чем циклы for в других языках программирования, например, в Бейсике. Любой из трех или все три элемента заголовка могут быть опущены, хотя точки с запятой обязательны. Также операторы для инициализации, условия и приращения цикла могут быть любым допустимым в Си операторами с независимыми переменными, и использовать любой тип данных Си, включая данные с плавающей точкой (floats). Эти необычные для цикла for типы операторов позволяют обеспечить программное решение некоторых нестандартных проблем.

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

for(int x = 2; x < 100; x = x * 1.5){
    println(x);
}

Генерируется: 2,3,4,6,9,13,19,28,42,63,94

Другой пример, плавное уменьшение или увеличение уровня сигнала на светодиод с помощью одного цикла for:

void loop()
{
  int x = 1;
  for (int i = 0; i > -1; i = i + x){
      analogWrite(PWMpin, i);
      if (i == 255) x = -1;             // переключение управления на максимуме
      delay(10);
   }
}


]]>
Оператор If..else http://f-studio.biz/news/10-operator-ifelse.html Константин Portal-PK 2017-02-01T08:53:29+03:00 Конструкция if..else предоставляет больший контроль над процессом выполнения кода, чем базовый оператор if, позволяя осуществлять несколько проверок, объединенных вместе. Например, аналоговый вход может быть проверен и выполнено одно действие, если на входе меньше 500, или другой действие, если на входе 500 или больше. Код при этом может выглядеть так:

if (pinFiveInput < 500)
{
  // действие A
}
else
{
  // действие B
}

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

Else позволяет делать отличную от указанной в if проверку, чтобы можно было осуществлять сразу несколько взаимоисключающих проверок. Каждая проверка позволяет переходить к следующему за ней оператору не раньше, чем получит логический результат ИСТИНА. Когда проверка с результатом ИСТИНА найдена, запускается вложенная в нее блок операторов, и затем программа игнорирует все следующие строки в конструкции if..else. Если ни одна из проверок не получила результат ИСТИНА, по умолчанию выполняется блок операторов в else, если последний присутствует, и устанавливается действие по умолчанию.

Отметим, что конструкция else if может быть использована с или без заключительного else и наоборот. Допускается неограниченное число таких переходов else if.

if (pinFiveInput < 500)
{
  // выполнять действие A
}
else if (pinFiveInput >= 1000)
{
  // выполнять действие B
}
else
{
  // выполнять действие  C
}

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

]]>
Оператор If http://f-studio.biz/news/9-operator-if.html Константин Portal-PK 2017-02-01T08:50:58+03:00 if (условие) и ==, !=, <, > (операторы сравнения)

if, используется в сочетании с операторами сравнения, проверяет, достигнута ли истинность условия, например, превышает ли входное значение заданное число. Формат оператора if следующий:

if (someVariable > 50)
{
// выполнять действия
}

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

Скобки после оператора if могут быть опущены. Если так сделано, только следующая строка (обозначенная точкой с запятой) становится оператором, выполняемым в операторе if.

if (x > 120) digitalWrite(LEDpin, HIGH);

if (x > 120)
digitalWrite(LEDpin, HIGH);

if (x > 120){ digitalWrite(LEDpin, HIGH); }

if (x > 120){
digitalWrite(LEDpin1, HIGH);
digitalWrite(LEDpin2, HIGH);
}                                 // все правильно

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

Операторы сравнения

x == y (x равно y)

x != y (x не равно y)

x < y (x меньше чем y)

x > y (x больше чем y)

x <= y (x меньше чем или равно y)

x >= y (x больше чем или равно y)

Внимание!

Следите, чтобы случайно не использовать знак простого равенства (например, if (x = 10)). Знак простого равенства – это оператор присваивания, и устанавливает значение х равное 10 (заносит значение 10 в переменную х). Вместо этого используйте знак двойного равенства (например, if (x == 10)), который является оператором сравнения и проверяет, х равен 10 или нет. Последнее из двух выражений будет истинно, только если х равен 10, но предыдущее выражение всегда верно.

Это связано с тем, что С вычисляет выражение if (x=10) следующим образом: значение 10 присваивается х (помним, что простой знак равенства – это оператор присваивания), таким образом, х теперь равен 10. Затем условный if вычисляет 10, которое уже равно ИСТИНА, так как любое число, неравное 0, равно ИСТИНА. Поэтому if (x=10) будет всегда иметь логическое значение ИСТИНА, которое не является желательным результатом, когда используется оператор if. Вдобавок, переменной х будет присвоено значение 10, что также не является желаемым действием.

If также может быть частью разветвленной управляющей конструкции с использованием if...else

]]>
Функция digitalRead() http://f-studio.biz/news/8-funkciya-digitalread.html Константин Portal-PK 2017-01-31T14:01:52+03:00 digitalRead()
Описание

Функция считывает значение с заданного входа - HIGH или LOW.

Синтаксис

digitalRead(pin)

Параметры

pin: номер вход/выхода(pin) который Вы хотите считать

Возвращаемое значение

HIGH или LOW

Пример
int ledPin = 13;                 // Светодиод подключенный к вход/выходу 13
int inPin = 7;                   // кнопка на входе 7
int val = 0;                     // переменная для хранения значения

void setup()
{
  pinMode(ledPin, OUTPUT);       // устанавливает режим работы - выход для 13го вход/выхода (pin)
  pinMode(inPin, INPUT);         //  устанавливает режим работы - вход для 7го вход/выхода (pin)
}

void loop()
{
  val = digitalRead(inPin);      // считываем значение с входа
  digitalWrite(ledPin, val);     // устанавливаем значение на светодиоде равным значению входа кнопки
}
Примечание

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

Аналоговые входы (analog pins) могут быть использованы как цифровые вход/выходы (digital pins). Обращение к ним идет по номерам от 14 (для аналогового входа 0) до 19 (для аналогового входа 5).

]]>
Функция digitalWrite() http://f-studio.biz/news/7-funkciya-digitalwrite.html Константин Portal-PK 2017-01-31T13:58:18+03:00 digitalWrite()

Описание

Подает HIGH или LOW значение на цифровой вход/выход (pin).

Если вход/выход (pin) был установлен в режим выход (OUTPUT) функцией pinMode(), то для значение HIGH напряжение на соответствующем вход/выходе (pin) будет 5В (3.3В для 3.3V плат), и 0В(земля) для LOW.

Если вход/выход (pin) был установлен в режим вход (INPUT), то функция digitalWrite со значением HIGH будет активировать внутренний 20K нагрузочный резистор. Подача LOW в свою очередь отключает этот резистор. Нагрузочного резистра достаточно чтобы светодиод, подключенный к входу, светил тускло. Если вдруг светодиод работает, но очень тускло, возможно необходимо установить режим выход (OUTPUT) функцией pinMode().

Замечание. Вход/выход 13 сложнее использовать как цифровой вход, т.к. он имеет встроенный в плату резистор и светодиод. Если вы активируете еще внутренний нагрузочный резистор 20K, то напряжение на этом входе будет около 1.7В, вместо ожидаемых 5В, т.к. светодиод и добавочный резистор снижает напряжение, т.е. Вы всегда будете получать LOW. Если же Вам все же необходимо использовать 13ый вход/выход, то используйте внешний нагрузочный резистор.

Синтаксис

digitalWrite(pin, value)

Параметры
  • pin: номер вход/выхода(pin)
  • value: значение HIGH или LOW
Возвращаемое значение

нет

Пример
int ledPin = 13;                 // Светодиод подключенный к вход/выходу 13
void setup()
{
  pinMode(ledPin, OUTPUT);      // устанавливает режим работы - выход
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // включает светодиод
  delay(1000);                  // ждет секунду
  digitalWrite(ledPin, LOW);    // выключает светодиод
  delay(1000);                  // ждет секунду
}
Примечание

Аналоговые входы (analog pins) могут быть использованы как цифровые вход/выходы (digital pins). Обращение к ним идет по номерам от 14 (для аналогового входа 0) до 19 (для аналогового входа 5).

]]>
Функция pinMode http://f-studio.biz/news/6-funkciya-pinmode.html Константин Portal-PK 2017-01-31T12:46:45+03:00 pinMode()
Описание

Устанавливает режим работы заданного вход/выхода(pin) как входа или как выхода. Подробнее про цифровые вход/выходы(pins).

Синтаксис

pinMode(pin, mode)

Параметры
  • pin: номер вход/выхода(pin), который Вы хотите установить
  • mode: режим одно из двух значение - INPUT или OUTPUT, устанавливает на вход или выход соответственно.
Возвращаемое значение

нет

Пример
int ledPin = 13;                 // Светодиод, подключенный к вход/выходу 13
void setup()
{
  pinMode(ledPin, OUTPUT);      // устанавливает режим работы - выход
}
void loop()
{
  digitalWrite(ledPin, HIGH);   // включает светодиод
  delay(1000);                  // ждет секунду
  digitalWrite(ledPin, LOW);    // выключает светодиод
  delay(1000);                  // ждет секунду
}
Примечание

Аналоговые входы (analog pins) могут быть использованы как цифровые вход/выходы (digital pins). Обращение к ним идет по номерам от 14 (для аналогового входа 0) до 19 (для аналогового входа 5).

]]>
Константы http://f-studio.biz/news/5-konstanty.html Константин Portal-PK 2017-01-31T12:42:53+03:00 Константами в языке Ардуино называют некоторые предопределенные значения. Они позволяют сделать код программы более легким для восприятия. Константы разделяют на три группы:

Логические константы

В языке Ардуино есть две константы для представления логических значений истина и ложь: true и false.

false

false определяется как 0, в логическом выражении.

true

Обычно говорят, что true — это 1, это корректно, но также корректно то, что для integer любой значение отличное от 0 будет также true в логическом выражение. Т.е -1, -2 и -200 будет также true в логическом выражении.

Обратите внимание, что true и false пишутся строчными буквами, в отличие от HIGH, LOW, INPUT и OUTPUT.

Задание значение на входа/выходе, HIGH и LOW

Возможны только два значения для считывания или записи на цифровой порт вход/выхода: HIGH и LOW.

HIGH

HIGH может обозначать несколько разное в зависимость от уставки режима порта как INPUT или OUTPUT. Когда порт вход/выхода установлен в режим INPUT с помощью функции pinMode, и считывается функцией digitalRead, микроконтроллер отдаст значение HIGH при напряжение 3В или выше на указанном порту.

Также порт может быть установлен как INPUT функцией pinMode, и затем установлен в HIGH значение функцией digitalWrite. Это подключит к порту внутренний подтягивающий резистор 20K, что позволит получать постоянное значение HIGH при чтение этого порта, если только значение не будет приведено к LOW внешней цепью подключенной к этому порту.

Когда порт вход/выхода сконфигурирован как OUTPUT функцией pinMode, и установлено значение HIGH функцией digitalWrite, на порту будет постоянное напряжение 5В. От этого порта может быть запитан светодиод, подключенный через резистор на землю или к другому порту, сконфигурированному как OUTPUT и установленному в LOW.

LOW

Значение LOW также разное для режима INPUT и OUTPUT. Когда порт сконфигурирован как INPUT, и считывается функцие digitalRead, микроконтроллер вернет LOW если напряжение на данном порту меньше или равно 2В.

Если же порт установлен в OUTPUT и LOW, то напряжение на выходе порта будет 0 Вольт. К этому порту можно подключать нагрузку как к земле, как описано выше на примере светодиода.

Задание режима порта вход/выхода, INPUT и OUTPUT

Цифровые порты вход/выхода, могут быть установлены в режимы работы как вход или выход: INPUT или OUTPUT. Установка производится функцией pinMode().

INPUT

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

OUTPUT

Порт установленный в режим выхода — OUTPUT, находится в низкоимпедансном состояние. Он может пропускать через себя довольно большой ток, до 40 mA, достаточный для запитывание внешней цепи, например, светодиода. В этом состоянии порт может быть поврежден как замыкании на землю так и на питание 5В. Тока с порта микроконтроллера не достаточно для питания моторов и сервоприводов напрямую.

]]>
Функция Loop http://f-studio.biz/news/4-funkciya-loop.html Константин Portal-PK 2017-01-31T12:39:38+03:00 loop()

После вызова функции setup(), которая инициализирует и устанавливает первоначальные значения, функция loop() делает точь-в-точь то, что означает её название, и крутится в цикле, позволяя вашей программе совершать вычисления и реагировать на них. Используйте её для активного управления платой Arduino.

int buttonPin = 3;

// setup инициализирует последовательный порт и кнопку
void setup()
{
  beginSerial(9600);
  pinMode(buttonPin, INPUT);
}

// в цикле проверяется состояние кнопки,
// и на последовательный порт будет отправлено сообщение, если она нажата
void loop()
{
  if (digitalRead(buttonPin) == HIGH)
    serialWrite('H');
  else
    serialWrite('L');


  delay(1000);
}
]]>
Функция Setup http://f-studio.biz/news/3-funkciya-setup.html Константин Portal-PK 2017-01-31T12:36:00+03:00 Функция setup() вызывается, когда стартует скетч. Используется для инициализации переменных, определения режимов работы выводов, запуска используемых библиотек и т.д. Функция setup запускает только один раз, после каждой подачи питания или сброса платы Arduino.

Пример

int buttonPin = 3;

void setup()
{
  Serial.begin(9600);
  pinMode(buttonPin, INPUT);
}

void loop()
{
  // ...
}


]]>