Датчик тока на ардуино скетч

Digitrode

цифровая электроника вычислительная техника встраиваемые системы

Arduino и датчик тока ACS712

Датчик Холла для Arduino

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

В этом проекте мы расскажем о датчике тока ACS712, о том, как работает датчик тока на основе эффекта Холла и, наконец, о том, как соединить датчик тока ACS712 с Arduino.

Микросхема датчика тока ACS712

Датчик тока ACS712 является продуктом Allegro MicroSystems, он может использоваться для точного измерения как переменного, так и постоянного тока. Этот датчик основан на эффекте Холла, а ИС имеет встроенное устройство с эффектом Холла. На выходе датчика тока ACS712 выдается аналоговое напряжение, пропорциональное переменному или постоянному току (в зависимости от того, что измеряется).

ACS712 доступна в 8-выводном корпусе SOIC, и на следующем рисунке показана ее схема контактов (распиновка ACS712).

IP+ – это плюсовая клемма для измерения тока, IP- – это минусовая клемма для измерения тока, GND – это сигнальная земля, FILTER – для подключения внешнего конденсатора, VIOUT – аналоговый выход, VCC – питание.

Существует три варианта датчика ACS712 в зависимости от диапазона его измерения тока. Оптимизированные диапазоны: +/- 5А, +/- 20А и +/- 30А. в зависимости от варианта чувствительность на выходе также изменяется следующим образом: ACS712 ELC-05 (+/- 5A) чувствительность 185 мВ/А, ACS712 ELC-20 (+/- 20A) чувствительность 100 мВ/А, ACS712 ELC-30 (+/- 30A) чувствительность 66 мВ/А.

Как упоминалось ранее, ASC712 основана на эффекте Холла. В микросхеме имеется медная полоса, соединяющая контакты IP+ и IP- внутри. Когда некоторый ток протекает через этот медный проводник, создается магнитное поле, которое определяется датчиком Холла.

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

Схема датчика тока на основе ACS712

Стандартная схема применения с использованием датчика тока ASC712 приведена в его техническом описании, и на следующем изображении:

Модуль датчика тока ACS712

Используя один из вариантов ИС ACS712 (5А, 20А или 30А), несколько производителей разработали платы модуля датчика тока ASC712, которые могут быть легко подключены к микроконтроллеру, такому как Arduino. На следующем рисунке показана плата датчика тока ASC712, используемая в этом проекте.

Как видите, это довольно простая плата с несколькими компонентами, включая микросхему ASC712, несколько пассивных компонентов и разъемов. Эта конкретная плата состоит из ASC712 ELC-30, то есть диапазон этой платы +/-30A.

Подключение ACS712 к Arduino (схема)

Измерение напряжения (постоянного напряжения) с помощью Arduino очень просто. Если ваше требование состоит в том, чтобы измерять напряжение меньше или равное 5 В, то вы можете напрямую измерять с помощью аналоговых выводов Arduino. Если вам нужно измерить более 5 В, то вы можете использовать простую сеть делителя напряжения или модуль датчика напряжения.

Когда дело доходит до измерения тока, Arduino (или любой другой микроконтроллер) нуждается в помощи в виде специального датчика тока. Итак, сопряжение датчика тока ACS712 с Arduino помогает нам измерять ток с помощью Arduino. Поскольку ASC712 может использоваться для измерения переменного или постоянного тока, проект с Arduino может быть реализован для измерения того же.

Принципиальная схема подключения датчика тока ACS712 к Arduino показана на следующем рисунке.

Код программы взаимодействия Arduino и датчика тока ACS712

Работа датчика тока ACS712 с Arduino

Подключите все согласно принципиальной схеме и загрузите код в Arduino. В коде есть небольшой расчет для измерения тока. Во-первых, если предположить, что напряжение VCC-ASC712 составляет 5 В, то при отсутствии тока, протекающего через клеммы IP + и IP-, выходное напряжение на VIOUT ACS712 составляет 2,5 В. Это означает, что вам нужно вычесть 2,5 В из напряжения, измеренного на аналоговом выводе.

Теперь, чтобы рассчитать ток, разделите это значение на чувствительность датчика (185 мВ / A для датчика 5A, 100 мВ / A для датчика 20A и 66 мВ / A для датчика 30A). Это все реализовано в коде.

Источник

Датчик тока (Trema-модуль V2.0)

Общие сведения:

Trema-модуль Датчик тока — это аналоговый модуль, позволяющий определять силу как постоянного, так и переменного тока до 5А. Для определения силы тока протекающего по исследуемой цепи, нужно один из её проводов подключить через клеммник на плате модуля. Потенциал на выходе модуля «S» (Signal) будет меняться в соответствии с направлением и силой измеряемого тока.

Видео:

Спецификация:

  • Чип ACS712ELCTR-05B-T.
  • Питание модуля: 5 В постоянного тока.
  • Измеряемый постоянный ток: ±5 А.
  • Измеряемый переменный ток:

5 А.

  • Максимальное напряжение исследуемой цепи: 300 В.
  • Частота измеряемого переменного тока: до 60 Гц.
  • Сопротивление между выводами клеммника: 1,2 мОм.
  • Потенциал на выходе «S» при отсутствии измеряемого тока: Vcc/2 В.
  • Чувствительность модуля: 130,7 мВ/A. (Ток в 1 А смещает потенциал выхода «S» на 130,7 мВ).
  • Рабочая температура: -40 . 85 °C.
  • Габариты модуля 30×30 мм.
  • Все модули линейки «Trema» выполнены в одном формате

    Подключение:

    Trema-модуль Датчик тока (5А) является аналоговым модулем, а значит его выход «S» (Signal) подключается к любому аналоговому входу Arduino.

    В комплекте имеется кабель для быстрого и удобного подключения модуля к Trema Shield .

    Модуль удобно подключать 3 способами, в зависимости от ситуации:

    Способ — 1 : Используя проводной шлейф и Piranha UNO

    Используя провода «Папа — Мама», подключаем напрямую к контроллеру Piranha UNO

    Способ — 2 : Используя Trema Set Shield

    Модуль можно подключить к любому из аналоговых входов Trema Set Shield.

    Способ — 3 : Используя проводной шлейф и Shield

    Используя 3-х проводной шлейф, к Trema Shield, Trema-Power Shield, Motor Shield, Trema Shield NANO и тд.

    Питание:

    Входное напряжение питания 5 В постоянного тока, подаётся на выводы «V» (Vcc) и «G» (GND) модуля.

    Подробнее о модуле:

    Trema-модуль Датчик тока (5А) построен на базе чипа ACS712 (Analog Current Sensor). Выводы чипа подключённые к клеммнику модуля соединены внутри чипа медной дорожкой, расположенной вблизи датчика Холла. При наличии тока протекающего по этой медной дорожке, генерируемое им магнитное поле, воспринимается датчиком Холла и преобразуется в напряжение на выходе чипа, пропорциональное силе тока. Таким образом выводы подключаемые к исследуемой цепи (ток которой измеряется) электрически изолированы от выхода и шины питания модуля. Для улучшения соотношения сигнал-шум, на выходе Trema модуля установлен RC-фильтр.

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

    Ток протекающий через клеммы Trema-модуля Датчик тока (5А) генерирует магнитное поле, которое воспринимается датчиком Холла и преобразуется в напряжение на выходе «S» модуля, пропорциональное силе и направлению измеряемого тока.

    Для работы с модулем предлагаем воспользоваться библиотекой iarduino_ACS712, в которой реализовано по 4 функции для работы с постоянным и переменным током:

    • 4 функции для работы с постоянным током: setZeroVDC(), getZeroVDC(), readDC(), calibrationDC().
    • 4 функции для работы с переменным током: setZeroVAC(), getZeroVAC(), readAC(), calibrationAC().

    Перечисленные функции идентичны по назначению и отличаются лишь окончанием DC (для постоянного тока) / AC (для переменного тока).

    Чтение силы тока осуществляется вызовом функции readDC() или readAC(), например, float i = readDC() // прочитать силу постоянного тока в переменную i. Функция не только возвращает силу тока в амперах, но и автоматически сглаживает выводимые показания (чем чаще вызывается функция, тем сильнее сглаживание показаний — показания меняются плавнее).

    Если показания возвращаемые функцией readDC() или readAC() отличаются от реально измеренных, то их можно откорректировать вызвав функцию calibrationDC() или calibrationAC(), с параметром в виде числа от 0 до 1023 (по умолчанию 511). Данная функция удобна если для корректировки показаний датчика тока используется подстроечный резистор, подключённый к свободному аналоговому входу Arduino, показание АЦП которой как раз лежат в диапазоне от 0 до 1023. Например, calibrationDC(analogRead(A5)); // Показания возвращаемые функцией readDC() корректируются потенциометром подключённым к выводу A5.

    Напряжение на выходе модуля «S» может измениться при подключении модуля к цепи измеряемого тока, даже если цепь обесточена. На это могут повлиять такие факторы как: токи утечки, электромагнитные и магнитные поля создаваемые другими цепями, или устройствами, намагниченные предметы вблизи модуля и т.д. Значит, перед началом работы с модулем, нужно указать напряжение на выходе «S» которое соответствует отсутствию тока в подключённой цепи. Это напряжение указывается через функцию setZeroVDC() или setZeroVAC(), например, setZeroVDC(2.5); // напряжение на выходе модуля при отсутствии измеряемого постоянного тока соответствует значению 2,5 В. Так же эта функция может быть использована если Вам требуется измерить не реальное значение тока, а отклонение показаний от требуемой силы тока.

    Получить среднее значение напряжения на выходе «S» модуля можно вызвав функцию getZeroVDC() или getZeroVAC(), например, float i = getZeroVDC(); // сохранить среднее значение напряжения в переменную i. Функция вернёт усреднённое напряжение в вольтах на выходе модуля, которое соответствует текущему току в измеряемой цепи. Далее это значение можно использовать в качестве параметра для функции setZeroVDC() или setZeroVAC().

    Если Вы желаете использовать модуль для измерения тока в разных цепях, то в коде setup можно указать: float i = getZeroVDC(); setZeroVDC(i); // получить и установить среднее значение напряжения на выходе модуля, например, соответствующее отсутствию постоянного тока в измеряемой цепи. Но тогда при каждом старте скетча, ток в цепи действительно должен отсутствовать.

    Если Вы желаете использовать модуль для измерения тока в одной и той же цепи, то можно считать напряжение на выходе модуля (при отсутствии измеряемого тока) используя функцию getZeroVDC() или getZeroVAC(), только один раз. Запомнить полученное значение. И переписать скетч, где в коде setup вызывать только функцию setZeroVDC() или setZeroVAC() с указанием этого значения, не вызывая функцию getZeroVDC() или getZeroVAC(). Например, setZeroVDC(2.5); Тогда обесточивать цепь при старте скетча не потребуется.

    Подробнее про установку библиотеки читайте в нашей инструкции..

    Примеры:

    Измерение постоянного тока:

    В данном скетче, Trema датчик тока 5A используется для вывода измеренного постоянного тока в монитор последовательного порта. Следующий скетч предназначен для измерения переменного тока и отличается от данного скетча только тем, что в нём изменены окончания функций библиотеки iarduino_ACS712 (вместо DC указано AC).

    Измерение переменного тока:

    В данном скетче, Trema датчик тока 5A используется для вывода измеренного переменного тока в монитор последовательного порта. Данный скетч отличается от предыдущего только тем, что в нём изменены окончания функций библиотеки iarduino_ACS712 (вместо DC указано AC).

    Измерение переменного тока с регулировкой показаний:

    Как видно из предыдущих скетчей, функция calibrationDC() или calibrationAC(), позволяет откорректировать выводимые показания, но её удобно использовать с подстроечным резистором подключённым к свободному аналоговому входу Arduino, что и сделано в следующем скетче:

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

    Описание основных функций библиотеки:

    Библиотека iarduino_ACS712 предназначена для работы только с Trema датчиком тока 5A .

    Источник

    Амперка / Блог

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

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

    Ближе всех лежал сенсор тока ACS758 производства DFROBOT. Амперка называет это изделие «Сенсором», а сам чувствительный элемент «Датчиком», но я бы называл их наоборот. Сам автор в тексте вышеуказанной страницы на сайте Амперки в паре мест путается и меняет систему названий. Я и сам датчик ACS758, и его же с обвязкой, далее буду называть просто датчиком. Датчик для измерения использует эффект Холла.

    Для подключения питания и провода данных предусмотрен как стандартный разъём, так и отверстия на плате под пайку, обозначенные как VCC, GND и два VOUT. Я решил подключить датчик именно через них. Один из двух VOUTов я выбрал случайным образом.

    Всё спаял, собрал, как рекомендует DFROBOT на примере. Не работает. Судя по тому, что считывает Arduino с VOUT, последний просто висит в воздухе. Странно…

    Взял мультиметр и стал «звонить» все ножки и контакты. И действительно «в воздухе»: один из двух VOUT не был ни к чему припаян. Сигнал надо было снимать с другого VOUT. Большое «фи» DF-роботу за «точную» маркировку контактной площадки.

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

    В прошлой своей публикации я писал про корявый китайский код. DFROBOT тоже является китайской компанией. И её код оказался не менее корявым. Но оба вышеупомянутых кода являются рабочими. Что неудивительно, т.к. это напрямую влияет на объёмы продаж. А вот корявость вряд ли влияет. В общем, кнута и Кнута на них не хватает. Но желания коммерческих компаний сэкономить на программистах вполне понятны.

    Непонятно другое: в качестве шаблона для своего кода DFROBOT взял пример с официального сайта arduino.cc. Но это ведь не мелкий китайский производитель датчиков. Это же, в т.ч., обучающий проект. Он должен сеять вечное и доброе.

    А что же он сеет?

    Итак, скетч со страницы «Сглаживание» сайта arduino.cc, которую следовало озаглавить «Как не надо программировать».

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

    Автор в начале страницы прямо декларирует обучающие цели приводимого кода. Он пишет: «Этот пример … также демонстрирует использование массивов для хранения данных».

    Итак, чему же он учит.

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

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

    Это в разы читабельнее.

    Сама идея вынести этот кусок в настроечную область скетча — правильная. Только надо было ещё выше вынести, до объявления рабочих переменных. А реализация — плохая.

    Числа в коде — это неправильно. Надо объявлять в заголовке в помощью #define мнемонические идентификаторы и потом использовать их в тексте программы.

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

    А это уже грубая ошибка. Предположим, что датчик выдал одно значение, равное 0, и девять значений, равных 1. Нет сомнений, что итоговое, «сглаженное» значение, должно быть равно 1. Однако по алгоритму автора мы получим 0 как результат целочисленного деления 9 на 10 с отбрасыванием дробной части.

    И ещё ошибка: пока не будет считано 10 значений, все результаты фактически являются неправильными, т.к. усредняются с инициализирующими буфер нулями. В большинстве практических применений это, наверное, не имеет большого значения. А где имеет — легко поправить код. На раз публикация носит академический характер, то я считаю это недопустимой ошибкой.

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

    В целом, у них такой же стиль, как и у скетча-донора. Поэтому остановимся только на различиях.

    Буфер увеличен до 30. Почему именно до этой величины — непонятно.

    Все величины они сделали float. Это устраняет вышеупомянутую ошибку с неправильным округлением. Но это в корне неверный подход. analogRead() даёт целую величину, в буфере хранятся эти же самые целые величины, операции по корректировке суммы всех величин в буфере тоже являются целочисленными. Следовательно, все переменные для хранения этих величин должны иметь тип int. Целому — целое! А вот когда при делении появляется float, то именно в тот момент и надо сделать коррекцию как я написал выше. Т.е. непосредственно перед делением использовать явное приведение типа int к float.

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

    По умолчанию, Serial.println выведет 2 знака после запятой. Что, учитывая контекст, эквивалентно утверждению производителя «Датчик + Arduino c 10-битным аналоговым портом меряют ток с точностью 0.01″ (10 бит потому, что в коде скетча считанное значение после знакового сдвига делится на 1024). А так ли это?

    DFROBOT пишет про свой датчик: «Sensitivity: 40 mV/A».

    10-битный аналоговый порт с опорным напряжением в 5 вольт (это тоже следует из кода скетча) измеряет напряжение с точностью 5/1024 =

    Таким образом, максимальная теоретическая точность измерений: (5/1024) / 0.04 =

    Т.е. ни о каких сотых долях ампера речи и быть не может.

    Тут 2 ошибки стиля. Во-первых, лучше использовать мнемоническую константу А0. Во-вторых, лучше сделать как в оригинале: завести константный идентификатор, инициализацию которого вынести в верхнюю часть кода, и использовать потом его.

    Это вообще что-то очень странное. Почему именно такая скорость? Скорее всего, у большинства в Arduino IDE в настройках стоит 9600 по умолчанию, чего хватает для отладочных нужд. Чтобы заработал этот скетч, надо лезть в меню и менять скорость. А при отладке другого скетча, наверняка, возвращать в умалчиваемое значение. Или исправлять скорость на 9600 в этом скетче. В любом случае, какие-то совсем ненужные хлопоты. А у неопытного пользователя может возникнуть впечатление, что указанная скорость является рекомендуемой производителем и как-то связана с аппаратными особенностями датчика.

    Может быть 57600 взято потому, что при задержке в 30 мс между измерениями скорости 9600 не хватит для передачи данных? Проверим это.

    Каждые 30 мс скетч будет отправлять максимум 6 байт (например, 17.67 + ‘\n’). Для этого потребуется канал: 6 байт * 8 бит/байт / 0.03 с = 1600 бод. Т.е. 9600 хватает с большим запасом.

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

    К скорости работы датчика и порта «delay(30)» тоже не имеет никакого отношения.

    Наверняка, DFROBOT и Массимо Банци читают блоги Амперки и поправят свои программные косяки.

    total= total — readings[index];

    total= total + readings[index];
    index = index + 1;
    ——————————-

    total -= readings[index];

    total += readings[index];
    index++;
    ———————————

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

    А что, еще есть компиляторы, которые для данных вариантов породят разный исполняемый код даже при отключенной оптимизации?

    Наверное, уже нет. Но помогает же

    int readings[numReadings];
    int index = 0;
    int total = 0;
    int average = 0;
    ———————————

    int readings[_numReadings],
    index = 0,
    total = 0,
    average = 0;
    ———————————
    «Это в разы читабельнее.»

    Это уже религиозное. Для меня все-таки читабельнее первый вариант.

    #define _numReadings 10

    Тоже религиозное: макроопределениям в С и С++ принято давать идентификаторы из прописных букв. Подчеркивание в начале совсем необязательно.

    Я всего лишь хотел сказать, что идентификатор в макроопределении должен визуально отличаться от идентификаторов других типов. И привёл пример. Лично мне подчёркивание очень нравится для визуальных разделений: слова не теряют читабельность, поддаются поиску по началу и т.п. У других известных систем свой набор преимуществ и недостатков. Полный обзор выходит за рамки этой заметки. Моя задача была — дать пищу для размышлений тем, кто ещё сам для себя не выбрал систему и даже не знал, что её нужно выбирать.

    Валерий, Вы действительно верите, что
    #define _x 10
    будет генерировать более короткий и быстрый код, чем
    const int x = 10;
    На чем основана ваша вера, позвольте узнать?

    Намёк ваш понял и посмотрел ассемблерный листинг avr-gcc.
    И действительно: операции с переменными, объявленными const, скомпилированы как будто это было объявлено с помощью #define. Т.е. компилятор вместо переменной просто оперирует тем, чем она была инициализирована. Раньше такого безобразия не было

    Вы уверены, что когда-то было по-другому? Или просто сглаживаете ситуацию?
    С++ компилятор считает все константные выражения до генерации кода.

    Я имею ввиду идеологию языка С.
    Тот же самый компилятор avr-gcc в отношении файла *.c, если он запущен с ключом -O0, прекрасно понимает, что от него хотят: он создаёт полноценную переменную, потом её же и использует, а объявление const использует только на этапе компиляции для проверки.
    В идеологии C++ так управлять компиляцией не удаётся (я этого не знал до публикации).
    В этом смысле «раньше» действительно было по-другому.

    Объяснения про то, что совсем раньше (в прошлом тысячелетии) был C, в котором изначально не было const, принимаются.
    Но, справедливости ради, надо отметить, что в Arduino-среде с самого начала был уже C++. Так что const int x = NNN; можно использовать везде, где должны быть константные выражения. По мне так это лучше, чем #define, поскольку типизировано. Но не буду навязывать свою точку зрения.

    И поправьте, если не трудно, текст. А то новички будут думать, что const int x = y; менее эффективно, чем #define

    Боюсь, что тут такой фичи нет. Будем считать обсуждение публикации неотъемлемой частью самой публикации

    >> был C, в котором изначально не было const
    Не в const дело. Я удивился тому, что оказывается в С++ программист уже не имеет полной власти над компилятором. Это для меня и есть «безобразие».

    Насчёт «поскольку типизировано» — это весомый аргумент.

    Валерий, что Вы подразумеваете под «не имеет власти над компилятором»? Может, просто программисту надо хотя бы прочитать langauge reference, чтобы получить эту власть?

    Может быть. Но я, пожалуй, воздержусь от продолжения нашего диалога, т.к. он не эффективен с точки зрения целей этого блога: маркетинг через обучение, обмен информацией, мнениями и т.п. С точки зрения этих целей, от участников ожидается прямое изложение информации. В случае с const и #define, например, вам просто достаточно было написать, что компилятор сгенерирует одинаковый код. Но вы действуете иначе, ставя какие-то цели, больше относящиеся к области психологии.

    По-моему как раз это вам надо было написать, что будет одинаковый код!

    Вы, ребята, зануды 80-го уровня Сначала всерьёз читал, потом улыбался
    Я — новичок. На меня больше подействовало бы такое:
    «вот, решил испытать два одинаковых кода по скомпилированному размеру и по времени выполнения моего самописного бенчмарка на тему констант vs определений»

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

    average = (alpha * analogRead(inputPin) ) + (1.0 — alpha) * average;

    где alpha подбирается от 0 до 1, в зависимости от numReading.

    Может быть 57600 взято потому, что при задержке в 30 мс между
    измерениями скорости 9600 не хватит для передачи данных?
    —————
    сейчас там у dfrobot скорость 115200 и пауза в loop 10ms.
    может для калибровки нуля это все так быстро ?

    еще они там в конце статьи померили синусоиду тока в сети 220в 50гц(20мс период), снизив паузу в loop до 2мс.

    Каждые 30 мс скетч будет отправлять максимум 6 байт (например, 17.67 + ‘n’). Для этого потребуется канал: 6 байт * 8 бит/байт / 0.03 с = 1600 бод. Т.е. 9600 хватает с большим запасом.

    Это не совсем правильный расчёт, ибо там же 9 бит передаётся: 8 данных и один стоповый

    Источник

    Adblock
    detector