Измерение потребляемой мощности Intel Edison в разных режимах работы16.09.2015 16:37

./highload &

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

Видно, что нагрузка около 50%, что правильно, так как основной процессор Atom имеет два ядра. Итак, потребляемый ток — 92 мА (708 мВт).

Ещё больше вычислений

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

./highload &
./highload &

В топе загрузка 98–100%:

Прибор показывает 107 мА (824 мВт). И как мне кажется, это круто. Потребление платы при полной загрузке процессора всего в 2.5 раза больше чем у Arduino, а это двухъядерный Atom на частоте 500 МГц.

Два ядра плюс WiFi

Нагрузим одновременно два ядра, как в предыдущем примере и запустим передачу файла по WiFi на хост компьютер. Потребление 290 мА (2233 мВт).

Встроенный микроконтроллер (MCU)

Intel Edison внутри себя содержит не только мощный Atom, но ещё и микроконтроллер, выполненный на архитектуре Intel-486, совместимый с Pentium и работающий на частоте 100 МГц. Когда процессор входит в циклы ожидания, частота падает до 38.4 МГц. На нем работает операционная система реального времени и поэтому обеспечивается хорошая временная точность работы.

Этот микроконтроллер можно использовать для разных целей. Гарантированная временная точность его работы может быть использована в критичных по времени задачах. Например, измерение временного интервала, как в статье «Используем встроенный микроконтроллер в Intel Edison». Или можно воспользоваться тем, что потребление этого микроконтроллера меньше, чем основного процессора. Поэтому можно возложить на него какие-то простые задачи, а основной процессор перевести в режим сна, и будить только при необходимости. Как раз, так и можно достичь самой хорошей экономичности устройства.

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

Подключаем микроконтроллер

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

#include "mcu_api.h"
#include "mcu_errno.h"

void mcu_main()
{
    debug_print(DBG_WARNING, "Start\n");

    const int LEDpin = 40; // GPIO-13
    const int DIR_out = 1;

    gpio_setup(LEDpin, DIR_out);

    while(1)
    {
        mcu_sleep(1000); // sleep 10 s.  1 tick = 10 ms
       
        debug_print(DBG_WARNING, "blink\n");

        gpio_write(LEDpin, 1);
        mcu_sleep(10); // sleep 100 ms
        gpio_write(LEDpin, 0);
    }
}

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

./init_DIG.sh -o 13 -d output

Потребление не изменилось от обычной работы без нагрузки — 67 мА (516 мВт).

Нагружаем микроконтроллер

Теперь посмотрим, что будет, если максимально нагрузить микроконтроллер. Сначала я попробовал поступить аналогично как с центральным процессором. Вычислять сумму синусов и отсылать её на отладочный вывод. Но почему-то код не работал. Оказалось, что программа очень не любит, когда используются данные типа float, а особенно при их смешивании с int в операциях. Программа просто останавливается в такой точке. Поэтому тестовая программа просто вычисляет последовательную сумму чисел. Что интересно, полученная сумма нигде не используется, но компилятор весь код оставил, то есть оптимизацию компилятор делает не очень. После изучения документации оказалось, что float использовать нельзя, это приводит к остановке кода. Лучше бы уж не компилировалось.

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

#include "mcu_api.h"
#include "mcu_errno.h"

const int proc_time = 10;// in seconds

void func_highload(int waitTimeSec)
{
        unsigned long startTime = time_us();
        unsigned long delta;

        do
        {
                int sumD = 0, k;
                for( k = 0; k < 1000000; k++ )
                        sumD += k;

                delta = time_us() - startTime;
        } while (delta < waitTimeSec * 1000000 );

}

void mcu_main()
{
        debug_print(DBG_WARNING, "Start\n");

        const int LEDpin = 40;
        const int DIR_out = 1;
        gpio_setup(LEDpin, DIR_out);

        while(1)
        {
                debug_print(DBG_WARNING, "Simple\n");
                mcu_sleep(1000); // 10 s

                debug_print(DBG_WARNING, "Highload\n");
                func_highload(10);
        }
}

Без нагрузки 67 мА. При полной нагрузке получаем 71 мА.Т. е. похоже, что встроенный микроконтроллер на полной нагрузке потребляет около 4 мА (31 мВт).

Экономим по крупному

Чтобы ещё уменьшить энергопотребление, выключим основной процессор и оставим работать только встроенный микроконтроллер. Судя по документам, в данном случае можно ожидать потребление в районе 13 мВт. Это около 1.6 мА. Конечно, это без Arduino платы. Здесь уже можно говорить о работе устройства в течение нескольких дней.

Итак, наша задача запустить некоторый код на MCU, который основное время находится в sleep режиме, изредка просыпаясь. И, самое важное, надо перевести главный процессор в ждущий режим. Есть несколько вариантов экономичного режима: S1, S2, S3.

Нам интересен режим S3 — Suspend to RAM. Питание подаётся только на память, всё остальное выключается. Когда мы переведем основной процессор в такое состояние, он будет находиться в нем до тех пор, пока не придет сигнал на пробуждение. Такой сигнал может быть послан и со встроенного микроконтроллера.

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

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

systemctl stop wpa_supplicant

А так как мы отключаем WiFi, то подключение к Intel Edison должно выполняться через USB. Затем я использовал различные варианты перевода в спящий режим:

echo devices > /sys/power/pm_test
echo mem > /sys/power/state

Это тестовая проверка перевода в спящий режим на 5 секунд. Она иногда работала. Иногда перестала работать совсем и требовалась перезагрузка системы, может даже с выключением питания. А команды для полного перевода:

echo none > /sys/power/pm_test
echo mem > /sys/power/state

почти никогда не работали. Что-то мешало. Судя по dmesg это SC — south complex:

[ 2313.362056] SC device/devices not in d0i3!!

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

Итак, при переводе процессора в спящий режим и запуске легкой программы на MCU получаем потребление 25 мА (192 мВт). И это предел, который мне удалось достичь от Intel Edison, установленного на плате-адаптере Arduino. Ну и самое важное, процессор спит, надо его разбудить. Сделать это можно по приходу данных на последовательный порт, который соединяет CPU и MCU. Вот пример, как сделать пробуждение каждые две минуты, посылаемый текст не важен:

#include "mcu_api.h"
#include "mcu_errno.h"

void mcu_main()
{
    while (1)
    {
        mcu_sleep(12000);   /* wake up CPU every 2 minutes */
        host_send((unsigned char*)"wake up!\n", 10);
    }
}

Для разрешения перехода основного процессора в спящий режим при отсутствии данных на последовательном порту, в Linux надо выполнить команду:

echo auto > /sys/devices/pci0000\:00/0000\:00\:04.3/power/control

Подробнее можно почитать в статье «Waking up the host CPU using the MCU». Но опять же, у меня почему-то процессор не засыпал.

Выводы

Хотя я и не смог достичь потребляемой мощности в 13 мВт, возможно из-за наличия Arduino-адаптера, но всё равно Intel Edison меня приятно удивил. Честно говоря, я ожидал на много большего отличия между Intel Edison и Arduino. И почему-то считал, что Intel Edison совсем не предназначен для автономных систем. Оказалось, что это не так.

Сводные результаты в порядке возрастания:
Выключено всё (shutdown) — 13 мА (100 мВт).
Только MCU, в основном в sleep — 25 мА (193 мВт).
Только MCU, в основном в sleep — 29 мА (223 мВт).
Обычная работа Linux — 67 мА (516 мВт).
Linux. С++ программа в основном в sleep режиме — 67 мА (516 мВт).
Linux. MCU sleep — 67 мА (516 мВт).
Linux. MCU нагружен — 71 мА (547 мВт).
Linux. Bluetooth — 90 мА (693 мВт).
Linux. Один поток основного процессора — 92 мА (708 мВт).
Linux. Два потока основного процессора — 107 мА (824 мВт).
Загрузка ОС Linux — 60–150 мА (462–1155 мВт).
Linux. WiFi приём — 150 мА (1155 мВт).
Linux. WiFi передача — 240 мА (1848 мВт).
Linux. WiFi передача + 2 потока — 290 мА (2233 мВт).

И, для наглядности, диаграммой:

© Geektimes