Arduino:примеры/eepromupdate

Емкость EEPROM

С созданием EEPROM, ROM (ПЗУ) больше не является устройством, доступным только для чтения, а является чем-то, на что вы можете записать снова, подобно RAM (Оперативное запоминающее устройство или Random Access Memory, дословно — случайный доступ к памяти).

EEPROM значительно медленнее оперативной памяти и имеет ограничение по количеству записей (обычно 1 миллион). Но это не должно стать проблемой, так как существует 2 версии EEPROM.

Первая версия — это версия, в которой можно параллельно записывать данные в байтовом формате, а вторая — последовательная с использованием I2C, в которой запись выполняется последовательно. Гарантированный срок хранения данных ограничен, как правило, 10 годами.

Далее появилась флеш-память, способная хранить гораздо больше данных в том же объеме. В то время как EEPROM может записываться байт за байтом или побайтово, флеш-память записывается блоками или большими фрагментами, обычно по 512 байт за раз

Обратите внимание, что количество раз, которое вы можете записать, обычно составляет 100 000, так что вам придется с этим справляться

Размер EEPROM-памяти может ввести в заблуждение, так как обычно она задается в битах, а не в байтах. 256K EEPROM может содержать 256K бит данных или всего 32K байт, около 16 страниц простого текста. Кроме того, она работает как энергонезависимая память, что означает, что она может сохранять свою память даже после повторного включения питания (в отличие от энергозависимой, которая теряет свое содержимое после выключения питания).

Запись целых чисел

Запись целых чисел в энергонезависимую память EEPROM осуществить достаточно просто. Внесение чисел происходит с запуском функции EEPROM.write(). В скобках указываются необходимые данные. При этом числа от 0 до 255 и числа свыше 255 записываются по-разному. Первые вносятся просто – их объем занимает 1 байт, то есть одну ячейку. Для записи вторых необходимо использовать операторов highByte() высший байт и lowByte() низший байт.

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

3 * 256 + 21 = 789

Для воссоединения» большого целого числа применяется функция word(): int val = word(hi, low). Нужно читывать, что максимальное целое число для записи – 65536 (то есть 2 в степени 16). В ячейках, в которых еще не было иных записей, на мониторе будут стоять цифры 255 в каждой.

Запись чисел с плавающей запятой и строк

Числа с плавающей запятой и строк – это форма записи действительных чисел, где они представляются из мантиссы и показателя степени. Запись таких чисел в энергонезависимую память EEPROM производится с активацией функции EEPROM.put(), считывание, соответственно, – EEPROM.get().

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

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

Код

 1 /***
 2     Пример eeprom_get 
 3 
 4     Этот пример показывает, как использовать функцию EEPROM.get().
 5 
 6     Чтобы подготовить EEPROM-память к этому скетчу, сначала запустите 
 7     скетч-пример eeprom_put. 
 8 
 9     Впрочем, eeprom_get можно запустить и без eeprom_put, но будьте 
10     готовы к тому, что в мониторе порта будут отображены не очень
11     смотрибельные данные (это «сырые» данные, которые уже хранятся 
12     в EEPROM-памяти).
13 
14     К примеру, EEPROM.get() может вернуть очень длинную строку 
15     мусорных данных (если в этих строках нет нуля).
16 
17     Автор – Кристофер Эндрюс (Christopher Andrews), 2015 год.
18     Выпущено под лицензией MIT.
19 ***/
20 
21 #include <EEPROM.h>
22 
23 void setup() {
24 
25   float f = 0.00f;   // переменная для хранения данных, считанных из EEPROM-памяти
26   int eeAddress = ; // участок EEPROM-памяти, с которого будет начато считывание
27 
28   Serial.begin(9600);
29   while (!Serial) {
30     ; // ждем подключения последовательного порта (нужно только для Arduino со штатным USB-портом)
31   }
32   Serial.print("Read float from EEPROM: "); // "float-данные, извлеченные из EEPROM-памяти: "
33 
34   // Извлекаем из EEPROM-памяти float-данные, находящиеся по адресу «eeAddress»:
35   EEPROM.get(eeAddress, f);
36   Serial.println(f, 3);    // если извлеченные данные не будут соответствовать типу float, эта функция может вернуть фразу «ovf, nan» 
37 
38   /***
39     Поскольку EEPROM.get() также возвращает отсылку к «f», всю эту конструкцию можно уместить в одной строке:
40     E.g: Serial.print( EEPROM.get( eeAddress, f ) );
41   ***/
42 
43   /***
44     Эту функцию можно использовать и с пользовательскими объектами. 
45     Я решил продемонстрировать это в отдельной функции.
46   ***/
47 
48   secondTest(); // запускаем следующий тест
49 }
50 
51 struct MyObject {
52   float field1;
53   byte field2;
54   char name10];
55 };
56 
57 void secondTest() {
58   int eeAddress = sizeof(float); // перемещаемся к участку EEPROM-памяти, находящемуся вслед за тем, где хранится переменная «f»
59 
60   MyObject customVar; // переменная для хранения данных пользовательского объекта, извлеченных из EEPROM-памяти
61   EEPROM.get(eeAddress, customVar);
62 
63   Serial.println("Read custom object from EEPROM: "); // "Данные пользовательского объекта, извлеченные из EEPROM-памяти: "
64   Serial.println(customVar.field1);
65   Serial.println(customVar.field2);
66   Serial.println(customVar.name);
67 }
68 
69 void loop() {
70   /* пустой цикл */
71 }

Resources and Going Further

Now that you know how to read and write serial EEPROMs, you can have all kinds of fun with your Arduino! Why stop at song lyrics? Why not store journals or bitmaps… or even sensor readings? Actually, to think of it, sensor readings are probably the most practical thing to use it for…

For more information on the Microchip 24-series EEPROM, check out the resources below:

• Datasheet (PDF)
• Ghostbusters (TXT)

• Arduino Sketch Examples

  • Write an EEPROM
  • Read an EEPROM

But wait, if you’re mad with power and want even more storage for your Arduino then you should check out this awesome tutorial on the MicroSD Card Breakout!

Working with AVR EEPROM memory blocks

We have discussed one way of dealing with EEPROM memory blocks – using interrupt-driven writing from the buffer. But if you don’t want to write your own routine, you can use one of the library’s standard functions. There are three functions for this:

void eeprom_write_block (const void *__src, void *__dst, size_t __n);

void eeprom_read_block (void *__dst, const void *__src, size_t __n);

void eeprom_update_block (const void *__src, void *__dst, size_t __n);

You can write, read, and update memory blocks in EEPROM. Functions may not look usual to some of you. They use void pointers instead of usual data-types like uint8_t. The good thing is that these functions are universal, allowing them to deal with any data type. Let’s see how this works. Lets take eeprom_write_block() function it has three arguments:

• const void *__src – pointer to RAM location;
• void *__dst – pointer to EEPROM location;
• size_t __n – number of bytes to be written.

There is no significant difference in what type of pointers are used. The only thing necessary to us is the number of bytes that need to be written. Let’s write a simple program demonstrating block write and read routines.

#include <avr/io.h>
#include <avr/eeprom.h>
//start from first EEPROM cell
#define EEADDR 0
//block size to be copied
#define BLKSIZE 16
//message to be written to EEPROM
uint8_t message[] ="Write to EEPROM";
int main(void)
{
//where block has to be read
uint8_t readblock;
//write block EEPROM
eeprom_write_block((const void *)message, (void *)EEADDR, BLKSIZE);
//read block from EEPROM
eeprom_read_block ((void *)readblock, (const void *)EEADDR, BLKSIZE);
while(1)
{
    //do nothing
}
}

As we see in the example we only need to typecast pointers to the void pointers like (void *)readblock, so they meet function requirements – this action doesn’t affect pointer value itself. Our real concern now is to read and write the correct number of bytes, and that’s it.

Скачать популярные библиотеки Arduino IDE на русском

Пользовательские библиотеки создаются разработчиками модулей и плат расширений для Ардуино. Большинство популярных библиотек Ардуино скачать можно на сайте GitHub. Это сервис для совместной разработки IT-проектов, где можно отследить историю изменений исходного кода. Чтобы пройти уроки Ардуино для начинающих, все необходимые для занятий библиотеки Arduino UNO можно скачать здесь:

Список пользовательских библиотек Arduino:

TroykaCurrent — перевод аналоговых значений в Амперы (скачать TroykaCurrent.h)

RotaryEncoder — работа с модулем энкодера (скачать RotaryEncoder.h)

Adafruit NeoPixel — работа с адресной лентой (скачать Adafruit_NeoPixel.h)

Fast LED — работа с адресной лентой ws2812b (скачать FastLED.h)

TroykaMQ — работа с датчиками газа MQ (скачать TroykaMQ.h)

MQ-2 sensor — работа с датчиком газа MQ2 (скачать MQ2.h)

LCD 1602 I2C — библиотека для дисплея 1602 I2C (скачать LiquidCrystal_I2C.h)

LCD 1602 I2C RUS — русификация дисплея 1602 I2C (скачать LCD_1602_RUS.h)

OLED I2C — библиотека для OLED дисплея (русифицированная) (скачать OLED_I2C.h)

SFE_BMP180 — библиотека для датчика давления BMP180 (скачать SFE_BMP180.h)

SD.h — библиотека для работы с sd картой памяти (скачать SD.h)

Applications in Arduino projects – Remember last state

The EEPROM is useful in Arduino projects that need to keep data even when the Arduino resets or when power is removed.

It is specially useful to remember the last state of a variable or to remember how many times an appliance was activated.

For example, imagine the following scenario:

• You’re controlling a lamp with your Arduino and the lamp is on;
• The Arduino suddenly loses power;
• When the power backs on, the lamp stays off – it doesn’t keep its last change.

You don’t want this to happen. You want the Arduino to remember what was happening before losing power and return to the last state.

To solve this problem, you can save the lamp’s state in the EEPROM and add a condition to your sketch to initially check whether the state of the lamp corresponds to the state previously saved in the EEPROM.

We’ll exemplify this with an example later in this post in the Example: Arduino EEPROM remember stored LED state.

Как работать с EEPROM, чтобы не износить её

Те кто в курсе, можете пропустить этот раздел. Для остальных краткое, чисто мое дилетантское пояснение.

Как я уже сказал, число записей в EEPROM ограничено. Это число варьируется, и может быть 100 000, а может и 1 000 000. Так как же быть, если я хочу записать параметр 10 000 000 раз? И здесь мы должны понять, как внутри EEPROM устроен доступ к ячейкам памяти.

Итак, в общем случае вся EEPROM разделена на страницы. Страницы изолированы друг от друга. Страницы могут быть разного размера, для небольших EEPROM это, скажем, 16, 32 или 64 байта. Каждый раз когда вы записываете данные по какому-то адресу, EEPROM копирует все содержимое страницы, в которой находятся эти данные, во внутренний буфер. Затем меняет данные, которые вы передали в этом буфере и записывает весь буфер обратно. Т.е. по факту, если вы поменяли 1 байт в странице, вы переписываете всю страницу. Но из-за того, что страницы изолированы друг от друга остальные страницы не трогаются.

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

Arduino Hardware Hookup

Okay, now that we know what EEPROM is, let’s hook one up and see what it can do! In order to get our device talking we’ll need to connect power as well as I²C serial lines. This device in particular runs at 5VDC so we’ll connect it to the 5V output of our Arduino UNO. Also, the I²C lines will need pullup resistors for communication to happen correctly. The value of these resistors depends on the capacitance of the lines and frequency you want to communicate at, but a good rule of thumb for non-critical applications is just keep it in the kΩ range. In this example, we’ll use 4.7kΩ pullup resistors.

There are three pins on this device to select the I²C address, this way you can have more than one EEPROM on the bus and address them each differently. You could just ground them all, but we’ll be wiring them so that we can drop in a higher-capacity device later in the tutorial.

We’ll use a breadboard to connect everything together. The diagram below shows the correct hookup for most I²C EEPROM devices, including the Microchip 24-series EEPROM that we sell.

Установка Arduino IDE через Boards Manager

1. Запустить Arduino IDE, далее Файл — Настройки — в поле Additional Boards Manager URLs вставить ссылку на стабильную версию
   http//arduino.esp8266.com/package_esp8266com_index.jsonили для nightly build
   http//arduino.esp8266.com/staging/package_esp8266com_index.json, нажать OK (В это поле вы можете вводить несколько ссылок, разделенных запятой)
2. Инструменты — Плата — Boards Manager
3. В Boards Manager в поле фильтра введите esp8266 или вручную пролистайте список и кликните на ESP8266 by ESP8266 Community Forum
4. Кликните Install и дождитесь окончания загрузки (около 130 Мегабайт). Если загрузка произошла слишком быстро, возможно, что вы уже устанавливали Arduino IDE для ESP8266 и потребуется почистить кэш Boards Manager, иначе у вас останется установленной старая версия. Нужно сначала деинсталлировать старую версию, а потом необходимо удалить файлы кэша. Для Win7 x64 удалите файлы из папки C:\Users\Пользователь\AppData\Roaming\Arduino15 и повторите все, начиная с п.2
5. Закройте Boards Manager и в меню Инструменты выберите Плата — Generic ESP8266
6. Установите частоту вашего модуля 80 или 160Mhz, размер флеш памяти и выберите последовательный порт, к которому подключен ваш USB-TTL адаптер

Предотвращение повреждения EEPROM

Если напряжение питания VCC слишком низкое (например, во время включения питания), данные в EEPROM можно повредить, потому что нарастание напряжения может оказаться слишком медленным для процессора и EEPROM, что не позволит им работать правильно. Эти вопросы такие же, как для систем, использующих память EEPROM, и должны быть применены такие же проектные решения.

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

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

Поддерживайте активный (низкий) сброс AVR во время недостаточного напряжения питания. Это можно сделать, включив внутренний детектор (Brown-out Detector (BOD)). Если уровень напряжения BOD не соответствует необходимому уровню напряжения, то можно использовать внешнюю цепь сброса, поддерживающую низкий уровень на выводе сброса и предохраняющую EEPROM от порчи. Если сброс происходит во время выполнения операции записи, операция записи будет завершена при условии, что напряжение питания достаточно.

ПРИМЕЧАНИЕ
Обычно все типовые схемы предусматривают такую защиту без дополнительного программирования (без использования BOD). Самое простое решение — подключить вход сброса микроконтроллера к плюсу источника питания через резистор, а к минусу — через конденсатор. При подаче питания на входе сброса будет низкий уровень, пока не зарядится конденсатор. То есть микроконтроллер не запустится, пока не зарядится конденсатор. Остаётся только рассчитать номиналы резистора и конденсатора, но это уже другая тема…

Воспроизведение звука

Создадим проект, в котором устройство Arduino используется для генерации звука. Мелодии хранятся в памяти EEPROM и выводятся на динамик. Для этого на динамик следует подать сигнал соответствующей частоты. В качестве динамика используем динамическую головку 8 Ом, подключаемую к выводу D8. Схема подключения представлена на рисунке.

Схема включения

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

Схема включения с транзистором

Громкость при этом получается весьма большой, поэтому в схему в качестве регулятора громкости добавлен потенциометр R2. Транзистор включен по схеме с общим эмиттером, и в данном случае выступает не в роли усилителя, а в качестве электронного ключа для согласования нагрузок. Дело в том, что у динамической головки сопротивление очень маленькое, и при подаче на нее напряжения +5 В через нее станет протекать ток около 625 мА. Однако максимальный ток, который могут обеспечить все выводы микроконтроллера, составляет всего 150 мА, т. е. в 4 раза меньше. И таким образом, подключая динамик к микроконтроллеру не напрямую, а через транзистор, способный пропускать через себя большее напряжение и ток большей силы, мы обеспечиваем электрическое согласование — в данном случае согласование по току.

Сначала составим скетч для воспроизведения одной мелодии. Мелодия состоит из двух массивов: массива с последовательным списком нот и массива со значениями длительности воспроизведения каждой ноты. Для воспроизведения одной ноты подаем на динамик сигнал определенной частоты и длительности. Затем воспроизводим следующую ноту. И так далее до окончания мелодии. Переменная tempo отвечает за скорость воспроизведения. Расчет тонов для нот одной октавы представлен в таблице.

Для подачи частотного сигнала на динамик воспользуемся функцией tone(). Скетч для воспроизведения мелодии представлен в примере сопровождающего книгу электронного архива.

Таблица расчета тонов для нот одной октавы

// ноты мелодии

char notes[]=»GECgabCaCg DGECabCDED EFEDGEDC CECaCag gCEDgCEDEFGECDgC «; // пробел — это пауза

// длительность для каждой ноты и паузы

int beats[] = { 4, 4, 4, 4, 1, 1, 1, 2, 1, 4, 2, 4, 4, 4, 4, 1, 1, 1, 2,

1,4, 2, 1, 1, 1, 1, 2, 1, 1, 4, 2, 1, 2, 1, 2, 1, 1, 4, 2, 1,

2, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 4, 4, 4} ;

// подключить динамик к pin 8 int speakerPin = 8;

int length = sizeof(beats); // число нот

// темп воспроизведения int tempo = 400;

// проиграть ноту

void playNote(char note, int duration)

{

// массив для наименований нот (до ре ми … и т. д. в пределах двух

// октав)

char names[]={‘c’,’d’,’e’,’f’,’g’,’a’,’b’,’C’,’D’,’E’,’F’,’G’,’A’,’B’}; int tones[]={3830,3400,3038,2864,2550,2272,2028,1912,1700,

1518,1432,1276,1136,1014 };

// проиграть тон, соответствующий ноте for (int i = 0; i < sizeof(tones); i++)

{

if (names == note) tone(speakerPin,tones,duration * 1000L);

}

}

void setup()

{pinMode(speakerPin, OUTPUT);}

void loop()

{

for (int i = 0; i < length; i++)

{

if (notes == ‘ ‘)

tone(speakerPin,0, beats*tempo* 1000L); // пауза else

playNote(notes, beats * tempo);

}

// пауза между нотами delay(tempo / 2);

}

delay(3000);

}

License

The MIT License (MIT)

Copyright (c) 2016 Diogo Miguel Rodrigues

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the «Software»), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED «AS IS», WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Настройка оборудования

В этом примере мы будем использовать микросхему 24LC256 от Microchip. Если вы используете другую микросхему, убедитесь, что требования к выводам и питанию соответствующие, чтобы не повредить микросхему.

Микросхему Microchip 24LC256 можно приобрести в 8-контактном DIP-корпусе. Распиновка 24LC256 довольно проста:

• вывод питания (8)
• вывод GND (4)
• вывод защиты от записи (7)
• вывод SCL (6)
• вывод SDA (5)
• выводы адреса (1,2,3)

Прежде чем мы перейдем к программной части, давайте подключим микросхему 24LC256 к нашей Ардуино.

Используя вышеприведенный рисунок, давайте приступим к подключению микросхемы. Сначала подключите GND и VCC к контактам 4 и 8 соответственно. Далее подключите выводы данных к плате Ардуино. Поскольку мы используем I2C шину, мы будем использовать контакты A4 и A5. Подключите контакт SDA 24LC256 (контакт 5) к контакту A4 Ардуино. Затем подключите SCL (контакт 6) к контакту A5 на Ардуино. Дважды убедитесь, что все подключено правильно, иначе могут произойти странные вещи, если вы их перепутаете.

После того, как выводы данных и питание подключены, у 24LC256 осталось еще четыре неподключенных вывода: вывод WP и три вывода адреса.

Электрический паяльник с регулировкой температуры
Мощность: 60/80 Вт, температура: 200’C-450’C, высококачествен…

Подробнее

Контакт WP обеспечивает защиту от записи. Это позволяет вам контролировать процесс записи данных в EEPROM. Если на этом выводе низкий логический уровень (0), то запись разрешена. Если же на выводе WP будет высокий логический уровень (1), то запись запрещена, но при этом чтение всегда доступно. В рамках этого руководства мы будем записывать в EEPROM, так что вывод WP подключим к GND.

Последние три контакта устанавливают адрес 24LC256, который позволяет идентифицировать конкретную микросхему на I2C шине. Микросхема 24LC256 поставляется с уже установленными четырьмя битами адреса (1010), которые нельзя изменить. Однако последние три бита адреса можно изменять, и это позволяет нам подключать до восьми микросхем 24LC256 на одну шину I2C. Давайте посмотрим на рисунок ниже, чтобы поподробнее разобраться, как формируется этот адрес:

Для простоты понимания как работает I2C адрес, мы можем игнорировать биты начала (Start) и подтверждения (Acknowledge). Шина I2C работает так: 7-битный адрес передается вместе с битом чтения / записи, который сообщает микросхеме, должна ли она записывать входящие данные или читать.

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

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

Итак, если мы соединим контакты 1, 2 и 3 микросхемы 24LC256 с GND, то микросхема будет иметь I2C адрес 0x50, а если все эти выводы подключить к Vcc, тогда микросхема будет иметь I2C адрес 0x57. Перебирая все комбинации, мы можем получить 8 адресов от 0x50 до 0x57.

Для упрощения просто соединим все контакты с GND, чтобы получился адрес 0x50.

После подключения адресных выводов аппаратная часть этого руководства завершена. Пора переходить к программному обеспечению!

Некоторые используют подтягивающие резисторы на выводах SCL и SDA Ардуино. Хотя это не повредит схеме, но в них нет необходимости, потому что при инициализации библиотеки Wire.h Ардуино знает, что выводы 4 и 5 будут использоваться для I2C, и в связи с этим активируются встроенные подтягивающие резисторы.

Документация функций

Считывает
блок из n байт
по адресу EEPROM pointer_eepromв буфер pointer_ram. Для
константы n <= 256
байт
библиотечная
функция
используется.
Для
неизвестного
размеров
блока во
времени
компиляции
или размерах
блока > 256
встроенный
цикл расширен.

Пример
использования:#include<stdio.h>

#include
<avr/eeprom.h>

char
pointer_ram ;

void
main(void)

{

eeprom_read_block(pointer_ram, 0x01, 10);

}

Считывает
один байт по
адресу EEPROM addr

Пример
использования:#include <stdio.h>

#include
<avr/eeprom.h>

unsigned
char b;

void
main(void)

{

b
= eeprom_read_byte(0x01);

}

Считывает
16-тиразрядное
слово по
адресу EEPROM addr.

Пример
использования:#include<stdio.h>

#include<avr/eeprom.h>

unsignedintw;

void
main(void)

{

w
= eeprom_read_word(0x01);

}

Записывает
блок из n
байт из
буфера pointer_ramпо адресу EEPROM pointer_eeprom.

Пример
использования:#include<stdio.h>

#include<avr/eeprom.h>

charpointer_ram =»0123456789″;

void
main(void)

{

eeprom_write_block(pointer_ram,0x01,5);

}

Записывает
байт value по
адресу EEPROM addr.

Пример
использования:#include<stdio.h>

#include<avr/eeprom.h>

unsignedcharb=10;

void
main(void)

{

eeprom_write_byte(0x01,b);

}

Записывает16-тиразрядноесловоvalueпоадресуEEPROM addr.

Пример
использования:#include<stdio.h>

#include
<avr/eeprom.h>

unsigned
int w=60000;

void
main(void)

{

eeprom_write_word(0x01,
w) ;

}

Библиотеки для работы с датой и временем ардуино

Библиотека RTClib

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

Пример использования:

#include <RTClib.h>

RTC_DS1307 RTC; – выбор датчика (в данном случае DS1307).

rtc.adjust(DateTime( Date, Time)); – настройка времени и календаря.

dayOfTheWeek () – вывод дня недели. Аргумент от 0 до 6, 0 – воскресенье.

Библиотека Timelib

Позволяет Ардуино получать информацию о дате и времени в данный момент.

Пример использования:

#include <TimeLib.h>

Time(); – создание экземпляра.

setTime (t); – установка времени. Аргумент t – час, минута, секунда, день, месяц и год.

timeStatus(); – показывает, установлено ли время.

adjustTime(adjustment); – настройка времени.

Библиотека Ds1307

Библиотека для удобного взаимодействия часов DS1307 с Ардуино c использованием библиотеки Wire.

Пример использования:

#include <DS1307RTC.h>

class DS1307RTC – создание объекта DS1307.

SetTime() – установка времени.

get() – считывает RTC, возвращает полученную дату в формате POSIX.

Set(time_t t) – запись даты в RTC

Библиотека DS 3231

Предназначена для управления датой и временем в модуле ds3231.

#include “ds3231.h”

DS3231  Clock(SDA, SCL); – создание объекта DS3231, подключение к линии тактирования и линии данных.

getTime(); – считывание даты и времени с часов.

setDate(date, mon, year); – установка даты.

Introduction

Arduino External EEPROM Library

This library will work with most I2C serial EEPROM chips between 2k bits and 2048k bits (2M bits) in size. Multiple EEPROMs on the bus are supported as a single address space. I/O across block, page and device boundaries is supported. Certain assumptions are made regarding the EEPROM device addressing. These assumptions should be true for most EEPROMs but there are exceptions, so read the datasheet and know your hardware.

The library should also work for EEPROMs smaller than 2k bits, assuming that there is only one EEPROM on the bus and also that the user is careful to not exceed the maximum address for the EEPROM.

The extEEPROM Library has been tested with:

• Microchip 24AA02E48 (2k bit)
• 24xx32 (32k bit, thanks to Richard M)
• Microchip 24LC256 (256k bit)
• Microchip 24FC1026 (1M bit, thanks to Gabriele B on the Arduino forum)
• ST Micro M24M02 (2M bit)

The extEEPROM Library will NOT work with Microchip 24xx1025 as its control byte does not conform to the following assumptions.

Device addressing assumptions:

• The I2C address sequence consists of a control byte followed by one address byte (for EEPROMs <= 16k bits) or two address bytes (for EEPROMs > 16k bits).
• The three least-significant bits in the control byte (excluding the R/W bit) comprise the three most-significant bits for the entire address space, i.e. all chips on the bus. As such, these may be chip-select bits or block-select bits (for individual chips that have an internal block organization), or a combination of both (in which case the block-select bits must be of lesser significance than the chip-select bits).
• Regardless of the number of bits needed to address the entire address space, the three most-significant bits always go in the control byte. Depending on EEPROM device size, this may result in one or more of the most significant bits in the I2C address bytes being unused (or «don’t care» bits).
• An EEPROM contains an integral number of pages.

Note that the Arduino Wire library has a buffer size of 32 bytes. This limits the size of physical I/Os that can be done to EEPROM. For writes, one or two bytes are used for the address, so writing is therefore limited to 31 or 30 bytes. Because the extEEPROM Library will handle I/O across block, page and device boundaries, the only consequence this has for the user is one of efficiency; arbitrarily large blocks of data can be written and read; however, carefully chosen block sizes may reduce the number of physical I/Os needed.

Похожие записи:

Паяльная станция сделанная своими руками Чем резать керамогранит: формирование отверстий и кромок Онлайн расчет характеристик трехфазных электродвигателей Обжим витой пары 8 жил: схема цветов, фото, видео Измеритель потребления электроэнергии в розетку: преимущества и характеристики Простой генератор звука на 12 вольт своими руками