Мои проекты на Ардуино

[leprud]

Формально это трансформатор..
Я в электрике, мягко говоря, не силен, посмотрите сами
http://www.seeedstudio.com/depot/Noninv ... p-547.html
(там ближе к низу разные документы и примеры)
Но подозреваю, что местоположение питающего провода внутри замкнутого контура не важно..

Я просто в свое время искал dc сенсоры тока, с ними как-то проще... (ACS712 как раз я и использовал)

[selenur]

вот статья на хабре http://habrahabr.ru/post/168783/

[Serg]

или
за счет расстояния будет всё крайне неточно ?

Расстояние не влияет. У меня на работе используются аналогичные датчики на 100А - у них внутреннее отверстие порядка 30 милиметров.

Их вообще как-то калибруют, или они с завода имеют некую точность ?

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

[Kopyloff]

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

А теперь разгоним наш осциллограф с 280 микросекунд до 80.

Прочитал статью на хабре по увеличению производительности ардуины (http://habrahabr.ru/post/141442/) и решил попробовать разогнать осциллограф.
Для меня тема увеличения производительности актуальна, т.к. надо анализировать 16 аналоговых входов, а с предыдущей версией программы частота выборки упала до 2500 микросекунд, что очень много. С помощью данного метода удалось увеличить частоту выборки с 2500 до 700 микросекунд, что уже приемлемо.

Суть метода - надо увеличить частоту работы АЦП понизив делитель. Подробно это расписано здесь: http://rc-master.ucoz.ru/publ/19-1-0-39

В итоге получился вот такой скетч:

Код: Выделить всё

#include <Adafruit_GFX.h>    // Core graphics library
#include "SWTFT.h" // Hardware-specific library
#include <TimerOne.h> //используем Timer1 для прерываний по времени

//================================================================
// http://habrahabr.ru/post/141442/
#define FASTADC 1

// defines for setting and clearing register bits
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
//================================================================

// Assign human-readable names to some common 16-bit color values:
#define	BLACK     0x0000
#define	BLUE      0x001F
#define	RED       0xF800
#define	DARKRED   0x2020
#define	GREEN     0x07E0
#define	DARKGREEN 0x2121
#define CYAN      0x07FF
#define MAGENTA   0xF81F
#define YELLOW    0xFFE0
#define WHITE     0xFFFF

SWTFT tft;

//int ACS712 = A8; // select the input pin for an ACS712-20 
int Uopornoe;// = A15; // select the input pin for a reference voltage
const int k=320; // k - кол-во записей в массив.
const int numReadings = 30; // numReadings - кол-во данных в фильтре.
boolean trig, resize;

volatile long PintTic=0; // счетчик периодов
volatile int CurA0; // Ток текущий
volatile int CurA0max; // Ток маскимальный
volatile long CurA0calcMax; // Ток маскимальный за весь период
volatile int CurA0min; // Ток минимальный
volatile long CurA0calcMin; // Ток минимальный за весь период
volatile int ymax=256, ymin=-256; // значения для масштабирования графика и сетки
float CurA0calcMid; // Ток средний (среднеквадратичное от CurA0calcMax и CurA0calcMin)

volatile int val_a[501]; //Массив значений A0 в прерываниях
volatile int val_a2[501]; //Массив значений времени в прерываниях
volatile int val_Uo[501]; //Массив значений опорного напряжения прерываниях
volatile long val_t[501]; //Массив значений времени в прерываниях

volatile int nb[501]; //Массив для учета номера итерации
volatile int i, z, c, v;
int scr_out, x1=0, x2=1, y1=120, y2=120;

// Переменные для фильтра
float readings[numReadings];      // the readings from the analog input
float total = 0;                  // the running total
float average = 0;                // the average

float A0_current;

unsigned long previousMillis = 0;        // will store last time LED was updated
const long interval = 6000;           // interval at which to blink (milliseconds)


void setup(void) {
  Serial.begin(115200); //поднимаем соединение для передачи на терминал   

//================================================================
// http://habrahabr.ru/post/141442/
#if FASTADC
// set prescale to 16
sbi(ADCSRA,ADPS2) ;
cbi(ADCSRA,ADPS1) ;
cbi(ADCSRA,ADPS0) ;
#endif
//================================================================

  // Инициализация данных в массиве фильтра в 0: 
  for (int thisReading = 0; thisReading < numReadings; thisReading++)
    readings[thisReading] = 0;          

  tft.reset();

  uint16_t identifier = tft.readID();

  Serial.print(F("LCD driver chip: "));
  Serial.println(identifier, HEX);

  tft.begin(identifier);

  tft.setRotation(1);
  
//рисуем сетку
  Grid();

   // Запуск таймера
  Timer1.initialize(80);              // Интервал срабатывания таймера в мкс 
  Timer1.attachInterrupt(current_meter);   //будет вызываться каждый раз при отсчете заданного времени
    
}


void loop(void) {
  
  // Закрашиваем чёрным предыдущее значение тока:
  tft.setCursor(96, 4);
  tft.setTextColor(BLACK);  tft.setTextSize(1);
  tft.println(A0_current,2);
  tft.setCursor(222, 4);
  tft.print(average,2);

  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;   

    Grid();
    scr_out = 0;
    x1=0; x2=1; y1=120,y2=120;
    while (scr_out <= k) {
  // Ноль координат - в верхнем левом углу экрана!!! Вынос мозга...
      y2 = map(val_a2[scr_out], ymin, ymax, 240, 0);
      tft.drawLine(x1, y1, x2, y2, GREEN);
      x1 = x2;
      y1 = y2;
      x2 = x2 + (tft.width()/k);

      Serial.print(scr_out);//  
      Serial.print(" , ");//  
      Serial.print(val_a2[scr_out]);//  
      Serial.println("");//  

      scr_out++;
    }
  // Данный триггер сбросится только после заполнения буфера новыми данными в прерывании current_meter
  trig = true;
  }
  
  CurA0calcMid = sqrt((sq(CurA0calcMax)+sq(CurA0calcMin))/2);
/*
Измеряем максимальный и минимальный пики синусоиды. Затем находим их среднеквадратичное значение.
                  пик = sqrt( ( (пик мин)^2 + (пик макс)^2 )/2 )  [маш.ед.]
Далее это значение (в машинных единицах - 0-1023) переводим в напряжение:
                  напряж. = (пик / 1023)*5  [Вольт]
Чувствительность ACS712-20 равна 100 милиВольт/Ампер = 0,1В/А (см. даташит на ACS), отсюда:
                  ток ампл. = напряж. / Чувствит. = напряж / 0,1 = напряж * 10  [Ампер]
Ток средний - это ток ампл., поделенный на корень из 2:
                  ток средний = ток ампл. / sqrt(2) = ток ампл. * 0,707  [Ампер]
Итого:
                  Ток = 0,707*ток ампл. = 0,707 * напряж / чувствит. = 0,707 * напряж. * 10 = 7,07 * напряж. =
                      = 7,07 * пик * 5 / 1023 = 35,35 * пик / 1023
*/  
  A0_current = 35.35 * CurA0calcMid / 1023.0;

//=================== Фильтр сглаживающий: ================
  // передвигаем данные в массиве:
  v = numReadings;
  while (v > 0) {
    readings[v]=readings[v-1];
    v--;
  }
  readings[0] = A0_current; 
//  Serial.print("A0_current = "); Serial.print(A0_current); Serial.print(" ; ");
  c = 0;
  total = 0;
  while (c < numReadings) {
    total += readings[c];
//    Serial.print(readings[c]); Serial.print(" ; ");
//    Serial.print(total); Serial.println("");
    c++;
  }
  // calculate the average:
  average = total / numReadings;         
// ======================================================

  // Выводим на экран значение тока:
  tft.setCursor(60, 4);
  tft.setTextColor(WHITE);  tft.setTextSize(1);
  tft.print("Iact= "); tft.print(A0_current,2); tft.print(" A");
  // Среднее значение тока (после фильтра)
  tft.setCursor(180, 4);
  tft.print("Iaver= "); tft.print(average,2); tft.print(" A");
  
//  Serial.print("Free memory size: "); // печать количества свободной оперативной памяти
//  Serial.println(memoryFree()); // печать количества свободной оперативной памяти
}


//********************обработчики прерываний******************************* 
void current_meter()  //прерывания таймера 
{ 
  PintTic++;  //счетчик периодов  
  Uopornoe = analogRead(A15);
  CurA0 = analogRead(A8)-(Uopornoe/2);
  CurA0max = max(CurA0,CurA0max);
  CurA0min = min(CurA0,CurA0min); 
  val_a[PintTic] = CurA0;
//  val_Uo[PintTic] = Uopornoe;
//  nb[PintTic] = PintTic;
//  val_t[PintTic] = micros();

    if(PintTic==k)
    {   
      if (trig == true) { 
        z = 0;
        while (z <= k) { val_a2[z] = val_a[z]; z++; }
//        ymax = CurA0max; ymin = CurA0min; // Сохраняем макс. и мин. значения в массиве
      }
      trig = false;
      PintTic=0;  //обнуляем счетчик 
      CurA0calcMax=CurA0max;
      CurA0calcMin=CurA0min;
      CurA0max=0;
      CurA0min=0;
   }

}
//************************************************************************* 



void Grid()
{
  tft.fillScreen(BLACK);
  //  tft.drawLine(x1, y1, x2, y2, color);
  // Ноль координат - в верхнем левом углу экрана!!! Вынос мозга...
  tft.drawLine(0, 0, 0, 240, BLUE); // Ось ординат
  // 120*75%=90.
  tft.drawLine(0, (120-(90*(1024/(ymax-ymin)))), 319, (120-(90*(1024/(ymax-ymin)))), DARKGREEN); // 75%
  // 120*50%=60.
  tft.drawLine(0, (120-(60*(1024/(ymax-ymin)))), 319, (120-(60*(1024/(ymax-ymin)))), DARKGREEN); // 50%
  // 120*25%=30.
  tft.drawLine(0, (120-(30*(1024/(ymax-ymin)))), 319, (120-(30*(1024/(ymax-ymin)))), DARKGREEN); // 25%
  // В пикселях по оси Y: 240/2=120 пикселей - это середина экрана.
  tft.drawLine(0,120,319,120, BLUE); // Ноль
  // 120 пикселей - это 100% сигнала. 120*25%=30.
  tft.drawLine(0, (120+(30*(1024/(ymax-ymin)))), 319, (120+(30*(1024/(ymax-ymin)))), DARKGREEN); // -25%
  // 120 пикселей - это 100% сигнала. 120*50%=60.
  tft.drawLine(0, (120+(60*(1024/(ymax-ymin)))), 319, (120+(60*(1024/(ymax-ymin)))), DARKGREEN); // -50%
  // 120 пикселей - это 100% сигнала. 120*75%=90.
  tft.drawLine(0, (120+(90*(1024/(ymax-ymin)))), 319, (120+(90*(1024/(ymax-ymin)))), DARKGREEN); // -75%
}  

// Переменные, создаваемые процессом сборки,
// когда компилируется скетч
// extern int __bss_end;
// extern void *__brkval;
 

/*
// Функция, возвращающая количество свободного ОЗУ (RAM)
int memoryFree()
{
   int freeValue;
   if((int)__brkval == 0)
      freeValue = ((int)&freeValue) - ((int)&__bss_end);
   else
      freeValue = ((int)&freeValue) - ((int)__brkval);
   return freeValue;
}
*/

[selenur]

В свое время программирование ардуино-подобных микроконтроллеров начинал на ассемблере, и когда смотришь на похожий код, удивительно что оно вообще приемлемо работает
Например в процедуре Grid() при рисовании линий очень много раз выполняется математическая операция ymax-ymin, хотя можно было это сделать всего 1 раз, а дальше просто использовать переменную....

[Serg]

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

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

[AndyBig]

очень много раз выполняется математическая операция ymax-ymin

Я даже более того скажу - очень много раз выполняется намного более тяжелая операция деления: 1024/(ymax-ymin), которую можно было бы выполнить один раз, сохранив результат в переменную
А потратив не одну, а три переменные, можно было бы сократить в четыре раза и операции умножения: 30*(1024/(ymax-ymin)), 60*(1024/(ymax-ymin)), и 90*(1024/(ymax-ymin))
И вот эту строчку: A0_current = 35.35 * CurA0calcMid / 1023.0; надеюсь, что компилятор оптимизировал до A0_current = CurA0calcMid * 0.034555223;

У GCC, которым всё это компилится, довольно приличный оптимизатор и подобные ситуации он оптимизит очень хорошо

Я бы все-таки перепроверил бы в ассемблерном листинге этот момент. Куда компилятор сохраняет промежуточные результаты? Если в регистры, то восстанавливаются ли они полностью после вызова tft.drawLine()? Если в стек, то хватает ли стека? Все-таки AVR довольно ограничены по ресурсам...

[SVP]

Очень подозрительно деление на 1023...

[AndyBig]

Очень подозрительно деление на 1023...

Не, с этим все нормально

[Serg]

А потратив не одну, а три переменные, можно было бы сократить в четыре раза и операции умножения: 30*(1024/(ymax-ymin)), 60*(1024/(ymax-ymin)), и 90*(1024/(ymax-ymin))

GCC именно так и сделает, если не мешать ему.

Я бы все-таки перепроверил бы в ассемблерном листинге этот момент. Куда компилятор сохраняет промежуточные результаты?

объектный файл там должен где-то быть - его проще всего дизассемблировать.

Все-таки AVR довольно ограничены по ресурсам...

Думаешь GCC не знает для чего компилит программы?

[AndyBig]

объектный файл там должен где-то быть - его проще всего дизассемблировать.

А что, у GCC нет параметра "вывести ASM-листинг в файл"?

Думаешь GCC не знает для чего компилит программы?

Разумеется знает, поэтому при нехватке стека и регистров он может и не оптимизировать, потому как это будет просто невозможно
ЗЫ: эти три операции 30*(1024/(ymax-ymin)), 60*(1024/(ymax-ymin)), и 90*(1024/(ymax-ymin)) можно оптимизировать в такие:
var60 = 60*(1024/(ymax-ymin));
var30 = var60 >> 1;
var90 = var60 + var30;
Даже при самой лучшей оптимизации это избавляет от двух умножений, вернее заменяет их гораздо более легкими сдвигом и сложением. А при не самой лучшей - еще и два деления долой

[Serg]

А что, у GCC нет параметра "вывести ASM-листинг в файл"?

Есть, я просто не помню можно-ли его как-то в ардуинской среде задать...

Разумеется знает, поэтому при нехватке стека и регистров он может и не оптимизировать, потому как это будет просто невозможно

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

[AndyBig]

Ну можно ж статистику посмотреть

Лучше уж посмотреть ассемблерный результат Будет гораздо однозначнее

[verser]

У меня ещё много подобных графиков есть...

Тема "умного дома" чертовски перспективная. У нее, интересно, есть родственные корни с чпу темой ? Тогда можно было бы здесь, на cnc-club.ru, открыть раздел типа "умный дом - своими чпушными руками"! Лично у меня тоже есть чем поделиться и что по-рассказать.

[Kopyloff]

Все-таки AVR довольно ограничены по ресурсам...

Я тоже уже смотрю в сторону Cortex M3 (Arduino Due). Или какой-нибудь другой проц с 16-ю каналами АЦП. Может посоветуете что? Надо чтобы проц был уже с выводом ног на пины для более лёгкого монтажа (какой-нибудь К155 ЛА3 я ещё в состоянии распаять, а к современным процам уже не знаю с какой стороны с паяльником заходить - всё мелкое такое, даже представления не имею как это дело распаивать ). Ещё надо чтобы UART минимум был и стандартные библиотеки Модбаса для коммуникации. Вообще я программист уровня "Хэллоу Ворлд!", сложное не предлагать

[selenur]

У меня есть arduino duo, проц в нем ARM работает на частоте 86 Мгц, 32-х битный, пробовал его программировать посредством ардуино-среды, большинство библиотек и скетчей разработаные под 8-ми биьные AVR работают нормально.
НО!!!
1) иногда нужны корректировки кода связаные с пинами.
2) так-же напряжение на выходах до 3.3 вольт, и собственно на входы нужно подавать не более 3.3 вольт. если будет больше можно спалить плату. поэтому это немного усложняет подключение других устройств.

[Serg]

Лично у меня тоже есть чем поделиться и что по-рассказать.

Ну открывай уже тему в этом разделе и начинай!

всё мелкое такое, даже представления не имею как это дело распаивать

А распаивать-то зачем?

2) так-же напряжение на выходах до 3.3 вольт, и собственно на входы нужно подавать не более 3.3 вольт. если будет больше можно спалить плату. поэтому это немного усложняет подключение других устройств.

У STM32, да и у многих других большинство входов допускают подачу 5В. IMHO ARM от AVR - самый неудачный представитель этой архитектуры.

[selenur]

У STM32, да и у многих других большинство входов допускают подачу 5В. IMHO ARM от AVR - самый неудачный представитель этой архитектуры.

Тут я абсолютно согласен, что если хочется использовать более мощные мк то лучше всего подойдет готовые платы на стм32 типа дискавери, последняя версия не помню точно модель, при цене около 2-х тыс. рублей имеет проц, работающий на частоте 186 Мгц, имеет собственный встроенный программатор, выводы на плате к которым может подключиться пользователь, все не боятся 5 вольт, только для АЦП если нужно мониторить сигнал больше 3.3 вольт, нужно будет применить делитель на резисторах, или использование внешних АЦП

[AndyBig]

Может посоветуете что?

Не могу посоветовать, так как с конструкторами дел обычно не имею
Могу посоветовать смотреть в сторону STM32, есть у китайцев и платки с ними по 5-6 долларов. Но придется вникать в программирование контроллеров глубже, чем на ардуинах.

[selenur]

Может посоветуете что?

Не могу посоветовать, так как с конструкторами дел обычно не имею
Могу посоветовать смотреть в сторону STM32, есть у китайцев и платки с ними по 5-6 долларов. Но придется вникать в программирование контроллеров глубже, чем на ардуинах.

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