Ошибка eeprom внутренняя энергонезависимая память

Код ошибки P06B8 звучит как «ошибка энергонезависимой памяти с произвольным доступом внутреннего модуля управления». Часто, в программах, работающих со сканером OBD-2, название может иметь английское написание «Internal Control Module Non-Volatile Random Access Memory (NVRAM) Error».

Сохраненный код P06B8 означает, что модуль управления (PCM) обнаружил внутреннюю ошибку производительности процессора с энергонезависимой памятью доступа. Другие контроллеры также могут обнаружить внутреннюю ошибку работы PCM (с NVRAM) и вызвать сохранение данной неисправности.

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

Входные и выходные сигналы NVRAM подвергаются самотестированию и постоянно контролируются PCM, а также другими контроллерами. Модуль управления трансмиссией (TCM), модуль управления тягой (TCSM) и другие контроллеры также взаимодействуют с NVRAM.

При включении зажигания и подаче напряжения на PCM, запускается самотестирование памяти NVRAM. В дополнение к выполнению внутренних самотестов контроллера, сеть контроллера (CAN) также сравнивает сигналы от каждого отдельного модуля.

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

Если PCM обнаружит внутреннее несоответствие в памяти процессора NVRAM, будет сохранен код P06B8 и может загореться контрольная лампа неисправности (MIL). Для загорания лампы MIL может потребоваться несколько циклов отказов, в зависимости от предполагаемой серьезности неисправности.

Симптомы неисправности

Основным симптомом появления ошибки P06B8 для водителя является подсветка MIL (индикатор неисправности). Также его называют Check engine или просто «горит чек».

Также они могут проявляться как:

1. Загорится контрольная лампа «Check engine» на панели управления (код будет записан в память как неисправность).
2. Также могут присутствовать другие связанные коды неисправностей.
3. Различные симптомы, связанные с работоспособностью двигателя.

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

Причины возникновения ошибки

Код P06B8 может означать, что произошла одна или несколько следующих проблем:

• Обрыв или замыкание в цепи либо разъемах шины CAN.
• Плохое заземление блока управления.
• Иногда причиной является неисправный модуль PCM.

Как устранить или сбросить код неисправности P06B8

Некоторые предлагаемые шаги для устранения неполадок и исправления кода ошибки P06B8:

1. Считайте все сохраненные данные и коды ошибок с помощью сканера OBD-II.
2. Очистите коды ошибок из памяти компьютера.
3. Проведите тест-драйв автомобиля, чтобы выяснить, появляется ли ошибка P06B8 снова.
4. Визуально осмотрите провода и разъемы шины CAN.
5. Проверьте заземление блока управления.
6. Если ошибка не исчезла, проверьте модуль PCM.

Диагностика и решение проблем

Если присутствуют коды питания ECM/PCM, их необходимо устранить, прежде чем пытаться диагностировать ошибку P06B8.

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

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

Проверка контроллера и электрической части

Используйте мультиметр для проверки предохранителей и реле питания контроллера. При необходимости проверьте и замените перегоревшие предохранители. Предохранители следует проверять при нагруженной цепи.

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

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

Если цепи питания и заземления контроллера не повреждены, скорее всего неисправен сам контроллер или существует ошибка программирования. Для замены модуля управления потребуется его перепрограммирование.

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

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

На каких автомобилях чаще встречается данная проблема

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

• Ford (Форд Фокус, Фьюжн, Эксплорер, Эскейп, F-150)
• Mazda (Мазда 3)
• Peugeot

С кодом неисправности Р06В8 иногда можно встретить и другие ошибки. Наиболее часто встречаются следующие: P06B6, P06B7, P2832.

Видео

Вот и добрались мы до третьего типа памяти, доступного на Arduino: EEPROM (англ. Electrically Erasable Programmable Read-Only Memory – электрически стираемое перепрограммируемое постоянное запоминающее устройство (ЭСППЗУ)), она же энергонезависимая память. Вспомним остальные типы памяти, Flash и SRAM, и их возможности по хранению данных:

Простыми словами: EEPROM – память, к которой мы имеем полный доступ из выполняющейся программы, т.е. можем во время выполнения читать и писать туда данные, и эти данные не сбрасываются при перезагрузке МК. Круто? Круто. Зачем?

• Хранение настроек, изменяющихся “из меню” устройства, без перепрошивки;
• Калибровка, сохранение калибровочных данных;
• Использование как дополнительной SRAM памяти в случае её нехватки;
• “Чёрный ящик” – постоянная запись показаний с датчиков для дальнейшей расшифровки сбоев;
• Запись состояния рабочего процесса для восстановления работы после внезапной перезагрузки.

Единственный важный момент: EEPROM имеет ресурс по количеству перезаписи ячеек. Производитель гарантирует 100 000 циклов записи каждой ячейки (AVR Arduino), по факту это количество зависит от конкретного чипа и температурных условий, независимые тесты показали 3-6 миллионов циклов перезаписи при комнатной температуре до появления первой ошибки, т.е. заявленные 100 000 взяты с очень большим запасом. Но есть небольшое уточнение – при заявленных 100 000 циклах перезаписи гарантируется сохранность записанных данных в течение 100 лет при температуре 24°C, если перезаписывать по миллиону – данные испортятся быстрее. В то же время количество чтений каждой ячейки неограниченно.

У МК esp8266/esp32 EEPROM эмулируется из Flash памяти, а её ресурс сильно меньше – производитель гарантирует всего 10 000 циклов записи!

EEPROM представляет собой область памяти, состоящую из элементарных ячеек с размером в один байт (как SRAM). Объём EEPROM разный у разных моделей МК:

• ATmega328 (Arduino UNO, Nano, Pro Mini): 1 кБ
• ATmega2560 (Arduino Mega): 4 кБ
• ATtiny85 (Digispark): 512 Б
• ESP8266 / ESP32: 4096 Б

Основная задача при работе с EEPROM – не напутать с адресами, потому что каждый байт имеет свой адрес. Если вы пишете двухбайтные данные, то они займут два байта, и следующие данные нужно будет писать по адресу как минимум +2 к предыдущему, иначе они “перемешаются”. Рассмотрим пример хранения набора данных разного типа, расположенных в памяти последовательно друг за другом (в скобках я пишу размер текущего типа данных, на размер которого увеличится адрес для следующего “блока”):

• byte – адрес 0 (+1)
• byte – адрес 1 (+1)
• int – адрес 2 (+2) (+4 для esp8266)
• byte – адрес 4 (+1)
• float – адрес 5 (+4)
• int – адрес 9 (+2)
• и так далее

Важный момент: все ячейки имеют значение по умолчанию (у нового чипа) 255.

Скорость работы с EEPROM (время не зависит от частоты системного клока):

• Запись одного байта занимает ~3.3 мс (миллисекунды)
• Чтение одного байта занимает ~0.4 мкс (микросекунды)

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

При использовании внутреннего тактового генератора на 8 МГц, его отклонение не должно быть выше 10% (7.2-8.8 МГц), иначе запись в EEPROM или FLASH скорее всего будет производиться с ошибками. Соответственно все разгоны внутреннего клока недопустимы при записи EEPROM или FLASH.

Для работы с EEPROM в среде Arduino у нас есть целых две библиотеки, вторая является более удобной “оболочкой” для первой. Рассмотрим их обе, потому что в “чужом скетче” может встретиться всё что угодно, да и совместное использование этих двух библиотек делает работу с EEPROM невероятно удобной.

Библиотека avr/eeprom.h

Описание к этой библиотеке я спрятал под спойлер, потому что она не очень актуальна и знать о ней необязательно. Также она не работает на esp8266/32 по понятным причинам.

#include <avr/eeprom.h>

void setup() {
  Serial.begin(9600);
  
  // объявляем данные разных типов
  byte dataB = 120;
  float dataF = 3.14;
  int16_t dataI = -634;  

  // пишем друг за другом
  eeprom_write_byte(0, dataB);  // 1 байт
  eeprom_write_float(1, dataF);  // 4 байта

  // для разнообразия "обновим"
  eeprom_update_word(5, dataI);

  // объявляем переменные, куда будем читать
  byte dataB_read = 0;
  float dataF_read = 0;
  int16_t dataI_read = 0;

  // читаем
  dataB_read = eeprom_read_byte(0);
  dataF_read = eeprom_read_float(1);
  dataI_read = eeprom_read_word(5);

  // выведет 120 3.14 -634
  Serial.println(dataB_read);
  Serial.println(dataF_read);
  Serial.println(dataI_read);
}

void loop() {}

#include <avr/eeprom.h>

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

  // объявляем структуру
  struct MyStruct {
    byte a;
    int b;
    float c;
  };

  // создаём и заполняем структуру
  MyStruct myStruct;
  myStruct.a = 10;
  myStruct.b = 1000;
  myStruct.c = 3.14;

  // записываем по адресу 10, указав размер структуры и приведя к void*
  eeprom_write_block((void*)&myStruct, 10, sizeof(myStruct));

  // создаём новую пустую структуру
  MyStruct newStruct;

  // читаем из адреса 10
  eeprom_read_block((void*)&newStruct, 10, sizeof(newStruct));

  // проверяем
  // выведет 10 1000 3.14
  Serial.println(newStruct.a);
  Serial.println(newStruct.b);
  Serial.println(newStruct.c);
}

void loop() {}

#include <avr/eeprom.h>

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

  // создаём массив
  float dataF[] = {3.14, 60.25, 9132.5, -654.3};

  // записываем по адресу 20, указав размер
  eeprom_write_block((void*)&dataF, 20, sizeof(dataF));

  // создаём новую пустой массив такого же типа и размера!
  float dataF_read[4];

  // читаем из адреса 20
  eeprom_read_block((void*)&dataF_read, 20, sizeof(dataF_read));

  // проверяем
  // выведет 3.14 60.25 9132.5 -654.3
  for (byte i = 0; i < 4; i++)
    Serial.println(dataF_read[i]);
}

void loop() {}

#include <avr/eeprom.h>
struct MyStruct {
  byte val1;
  int val2;
  float int3;
};

uint8_t EEMEM byteAddr;     // 27
uint16_t EEMEM intAddr;     // 25
uint32_t EEMEM longAddr;    // 21
MyStruct EEMEM myStructAddr;// 14
int EEMEM intArrayAddr[5];  // 4
float EEMEM floatAddr;      // 0

#include <avr/eeprom.h>
byte EEMEM dataB_addr;
float EEMEM dataF_addr;
int16_t EEMEM dataI_addr;

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

  // объявляем данные разных типов
  byte dataB = 120;
  float dataF = 3.14;
  int16_t dataI = -634;

  // пишем друг за другом
  eeprom_write_byte(&dataB_addr, dataB);
  eeprom_write_float(&dataF_addr, dataF);

  // для разнообразия "обновим"
  eeprom_update_word(&dataI_addr, dataI);

  // объявляем переменные, куда будем читать
  byte dataB_read = 0;
  float dataF_read = 0;
  int16_t dataI_read = 0;

  // читаем
  dataB_read = eeprom_read_byte(&dataB_addr);
  dataF_read = eeprom_read_float(&dataF_addr);
  dataI_read = eeprom_read_word(&dataI_addr);

  // выведет 120 3.14 -634
  Serial.println(dataB_read);
  Serial.println(dataF_read);
  Serial.println(dataI_read);
}

void loop() {}

#include <avr/eeprom.h>
// получим адрес (тут будет 0)
int EEMEM intArrayAddr[5];

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

  // создаём массив
  int intArrayWrite[5] = {10, 20, 30, 40, 50};

  // пишем по адресу intArrayAddr
  eeprom_write_block((void*)&intArrayWrite, (const void*)&intArrayAddr, sizeof(intArrayWrite));

  // создаём новый массив для чтения
  int intArrayRead[5];

  // читаем по адресу intArrayAddr
  eeprom_read_block((void*)&intArrayRead, (const void*)&intArrayAddr, sizeof(intArrayRead));

  // проверим
  for (byte i = 0; i < 5; i++)
    Serial.println(intArrayRead[i]);
}

void loop() {}

Библиотека EEPROM.h

Библиотека EEPROM.h идёт в комплекте с ядром Arduino и является стандартной библиотекой. По сути EEPROM.h – это удобная оболочка для avr/eeprom.h, чуть расширяющая её возможности и упрощающая использование.

Для AVR Arduino: подключая в скетч EEPROM.h мы автоматически подключаем avr/eeprom.h и можем пользоваться её фишками, такими как EEMEM.

Рассмотрим инструменты, которые нам предлагает библиотека:

• EEPROM.write(адрес, данные) – пишет данные (только byte!) по адресу
• EEPROM.update(адрес, данные) – обновляет (та же запись, но лучше) байт данных, находящийся по адресу. Не реализована для esp8266/32!
• EEPROM.read(адрес) – читает и возвращает байт данных, находящийся по адресу
• EEPROM.put(адрес, данные) – записывает (по факту – обновляет, update) данные любого типа (типа переданной переменной) по адресу
• EEPROM.get(адрес, данные) – читает данные по адресу и сам записывает их в данные – указанную переменную
• EEPROM[] – библиотека позволяет работать с EEPROM памятью как с обычным массивом типа byte (uint8_t)

В отличие от avr/eeprom.h у нас нет отдельных инструментов для работы с конкретными типами данных, отличными от byte, и сделать write/update/read для float/long/int мы не можем. Но зато у нас есть всеядные put и get, которые очень удобно использовать! Рассмотрим пример с чтением/записью байтов:

#include <EEPROM.h>

void setup() {
  Serial.begin(9600);
  //EEPROM.begin(100);   // для esp8266/esp32
  
  // пишем 200 по адресу 10
  EEPROM.update(10, 200);
  //EEPROM.commit();     // для esp8266/esp32
  Serial.println(EEPROM.read(10));  // выведет 200
  Serial.println(EEPROM[10]);       // выведет 200
}

void loop() {}

Логика работы с адресами такая же, как в предыдущем пункте урока! Обратите внимание на работу с EEPROM как с массивом, можно читать, писать, сравнивать, и даже использовать составные операторы, например EEPROM[0] += 10 , но это работает только для элементарных ячеек, байтов.

Теперь посмотрим, как работает put() и get():

#include <EEPROM.h>

void setup() {
  Serial.begin(9600);
  //EEPROM.begin(100);   // для esp8266/esp32

  // объявляем переменные, которые будем писать
  float dataF = 3.14;
  int16_t dataI = -634;
  byte dataArray[] = {10, 20, 30, 40};

  EEPROM.put(0, dataF);
  EEPROM.put(4, dataI);
  EEPROM.put(6, dataArray);
  //EEPROM.commit();     // для esp8266/esp32

  // объявляем переменные, куда будем читать
  float dataF_read = 0;
  int16_t dataI_read = 0;
  byte dataArray_read[4];

  // читаем точно так же, как писали
  EEPROM.get(0, dataF_read);
  EEPROM.get(4, dataI_read);
  EEPROM.get(6, dataArray_read);

  // проверяем
  Serial.println(dataF_read);
  Serial.println(dataI_read);
  Serial.println(dataArray_read[0]);
  Serial.println(dataArray_read[1]);
  Serial.println(dataArray_read[2]);
  Serial.println(dataArray_read[3]);
}

void loop() {}

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

EEPROM.h + структуры

Самый удобный хранить набор данных в EEPROM – структура (разбирали в уроке про типы данных). Структура позволяет объединить любые данные под одним именем, и одной строчкой загонять их в EEPROM и так же читать обратно. А также не придётся думать об адресации! Пример:

#include <EEPROM.h>

struct Data {
  byte bright = 0;
  int counter = 0;
  float fvalue = 0;
};

// глобальный экземпляр для личного использования
Data data;

void setup() {
  EEPROM.get(0, data);   // прочитать из адреса 0
  // меняем
  data.bright = 10;
  data.counter = 1234;
  data.fvalue = 3.14;
  EEPROM.put(0, data);   // поместить в EEPROM по адресу 0
}

void loop() {}

EEPROM.h + avr/eeprom.h

Пример не очень актуален, используй EEPROM + структуры

#include <EEPROM.h>
float EEMEM dataF_addr;
int16_t EEMEM dataI_addr;
byte EEMEM dataArray_addr[5];

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

  // объявляем переменные, которые будем писать
  float dataF = 3.14;
  int16_t dataI = -634;
  byte dataArray[] = {10, 20, 30, 40};

  EEPROM.put((int)&dataF_addr, dataF);
  EEPROM.put((int)&dataI_addr, dataI);
  EEPROM.put((int)&dataArray_addr, dataArray);

  // объявляем переменные, куда будем читать
  float dataF_read = 0;
  int16_t dataI_read = 0;
  byte dataArray_read[4];

  // читаем точно так же, как писали
  EEPROM.get((int)&dataF_addr, dataF_read);
  EEPROM.get((int)&dataI_addr, dataI_read);
  EEPROM.get((int)&dataArray_addr, dataArray_read);
  EEPROM[0] += 10;

  // проверяем
  Serial.println(dataF_read);
  Serial.println(dataI_read);
  Serial.println(dataArray_read[0]);
  Serial.println(dataArray_read[1]);
  Serial.println(dataArray_read[2]);
  Serial.println(dataArray_read[3]);
}

void loop() {}

Реальный пример

Рассмотрим пример, в котором происходит следующее: две кнопки управляют яркостью светодиода, подключенного к ШИМ пину. Установленная яркость сохраняется в EEPROM, т.е. при перезапуске устройства будет включена яркость, установленная последний раз. Для опроса кнопок используется библиотека GyverButton. Для начала посмотрите на первоначальную программу, где установленная яркость не сохраняется. Программу можно чуть оптимизировать, но это не является целью данного урока.

#define BTN_UP_PIN 3    // пин кнопки вверх
#define BTN_DOWN_PIN 4  // пин кнопки вниз
#define LED_PIN 5       // пин светодиода

#include <GyverButton.h>

GButton btnUP(BTN_UP_PIN); // кнопка "яркость вверх"
GButton btnDOWN(BTN_DOWN_PIN); // кнопка "яркость вниз"

int LEDbright = 0;

void setup() {
  pinMode(LED_PIN, OUTPUT); // пин светодиода как выход
}

void loop() {
  // опрос кнопок
  btnUP.tick();
  btnDOWN.tick();

  if (btnUP.isClick()) {
    // увеличение по клику
    LEDbright += 5;
    setBright();
  }

  if (btnDOWN.isClick()) {
    // уменьшение по клику
    LEDbright -= 5;
    setBright();
  }
}

void setBright() {
  LEDbright = constrain(LEDbright, 0, 255); // ограничили
  analogWrite(LED_PIN, LEDbright);    // изменили яркость
}

В этот код нам нужно добавить:

• Подключить библиотеку EEPROM.h
• При запуске: чтение яркости из EEPROM и включение светодиода
• При клике: запись актуального значения в EEPROM

#define BTN_UP_PIN 3    // пин кнопки вверх
#define BTN_DOWN_PIN 4  // пин кнопки вниз
#define LED_PIN 5       // пин светодиода

#include <EEPROM.h>
#include <GyverButton.h>

GButton btnUP(BTN_UP_PIN); // кнопка "яркость вверх"
GButton btnDOWN(BTN_DOWN_PIN); // кнопка "яркость вниз"

int LEDbright = 0;

void setup() {
  pinMode(LED_PIN, OUTPUT); // пин светодиода как выход
  EEPROM.get(0, LEDbright); // прочитали яркость из адреса 0
  analogWrite(LED_PIN, LEDbright);  // включили
}

void loop() {
  // опрос кнопок
  btnUP.tick();
  btnDOWN.tick();

  if (btnUP.isClick()) {
    // увеличение по клику
    LEDbright += 5;
    setBright();
  }

  if (btnDOWN.isClick()) {
    // уменьшение по клику
    LEDbright -= 5;
    setBright();
  }
}

void setBright() {
  LEDbright = constrain(LEDbright, 0, 255); // ограничили
  EEPROM.put(0, LEDbright);           // записали по адресу 0
  analogWrite(LED_PIN, LEDbright);    // изменили яркость
}

Итак, теперь при запуске у нас восстанавливается последняя настроенная яркость, и при изменении она записывается. Напомню, что EEPROM изнашивается от перезаписи. Конечно для того, чтобы “накликать” яркость несколько миллионов раз и убить ячейку, у вас уйдёт очень много времени, но процесс записи нового значения можно и нужно оптимизировать, особенно в более серьёзных проектах, ниже поговорим об этом подробнее. Также в нашем коде есть ещё один неприятный момент: при самом первом запуске после прошивки EEPROM не инициализирована, каждая ячейка хранит в себе число 255, и именно такое значение примет переменная LEDbright после первого запуска, при так называемом “первом чтении”. Здесь это не имеет значения, но в более серьёзном устройстве нужно будет задать нужные значения по умолчанию в EEPROM при первом запуске, об этом мы тоже поговорим ниже. Иначе представьте, какие “настройки по умолчанию” получит ваше устройство для яркости/скорости/громкости/номера режима/прочее!

Запись и чтение строк

У нас есть два типа строк: массивы символов и String-строки. С массивом символов всё более-менее понятно: это массив, он имеет фиксированный размер, его можно записать при помощи put() и прочитать при помощи get(). Также такая строка может входить в структуру, что очень удобно. В этом случае нужно объявить структуру с указанием максимальной длины строки, которая может там храниться. Например для какого-нибудь проекта с WiFi нам хочется хранить логин и пароль от роутера и режим работы:

struct Cfg {
  char ssid[16];
  char pass[16];
  byte mode;
};

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

А как записать и прочитать динамические данные, такие как String-строки? Можно рассмотреть два способа: с массивом ограниченной длины (как в примере выше) и полностью динамическое хранение.

Будем считать, что максимальная длина строки – 20 символов. Простой пример:

#include <EEPROM.h>
#define STR_ADDR 0  // адрес хранения строки в EEPROM


void setup() {
  Serial.begin(115200);

  // читаем
  char str[20];
  EEPROM.get(STR_ADDR, str);

  // выводим
  Serial.print("Read text: ");
  Serial.println(str);
}

void loop() {
  // читаем строку из порта
  if (Serial.available()) {
    char str[20];
    int len = Serial.readBytes(str, 20);

    // завершающий символ, добавляем вручную
    str[len] = 0;

    // записываем
    EEPROM.put(STR_ADDR, str);
    
    Serial.print("Save text: ");
    Serial.println(str);
  }
}

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

#include <EEPROM.h>

#define STR_ADDR 0  // адрес хранения строки в EEPROM

void setup() {
  Serial.begin(115200);
  
  String str;
  int len = EEPROM.read(STR_ADDR);  // читаем длину строки
  str.reserve(len);    // резервируем место (для оптимальности)

  // читаем
  for (int i = 0; i < len; i++) {
    str += (char)EEPROM.read(STR_ADDR + 1 + i);
  }
  
  // выводим
  Serial.print("Read text: ");
  Serial.println(str);
}

void loop() {
  // читаем строку из порта
  if (Serial.available()) {
    String inc = Serial.readString();
    Serial.print("Save text: ");
    Serial.println(inc);
    
    int len = inc.length();   // длина строки
    EEPROM.write(STR_ADDR, len);  // записываем её
    // и далее саму строку посимвольно
    for (int i = 0; i < len; i++) {
      EEPROM.write(STR_ADDR + 1 + i, inc[i]);
    }
  }
}

Полезные трюки

Инициализация

Под инициализацией я имею в виду установку значений ячеек в EEPROM “по умолчанию” во время первого запуска устройства. В рассмотренном выше примере мы действовали в таком порядке:

1. Чтение из EEPROM в переменную
2. Использование переменной по назначению

При первом запуске кода (и при всех дальнейших, в которых в ячейку ничего нового не пишется) переменная получит значение, которое было в EEPROM по умолчанию. В большинстве случаев это значение не подойдёт устройству, например ячейка хранит номер режима, по задумке разработчика – от 0 до 5, а из EEPROM мы прочитаем 255. Непорядок! При первом запуске нужно инициализировать EEPROM так, чтобы устройство работало корректно, для этого нужно определить этот самый первый запуск. Можно сделать это вручную, прошив программу, которая забьёт EEPROM нужными данными. Далее прошить уже рабочую программу. При разработке программы это очень неудобно, ведь количество сохраняемых данных может меняться в процессе разработки, поэтому можно использовать следующий алгоритм:

1. Резервируем какую-нибудь ячейку (например, последнюю) под хранение “ключа” первого запуска
2. Читаем ячейку, если её содержимое не совпадает с ключом – это первый запуск!
3. В обработчике первого запуска пишем в ячейку нужный ключ
4. Пишем в остальные ячейки необходимые значения по умолчанию
5. И после этого уже читаем данные во все нужные переменные

Рассмотрим на всё том же примере со светодиодом и кнопками:

#define INIT_ADDR 1023  // номер резервной ячейки
#define INIT_KEY 50     // ключ первого запуска. 0-254, на выбор

#define BTN_UP_PIN 3    // пин кнопки вверх
#define BTN_DOWN_PIN 4  // пин кнопки вниз
#define LED_PIN 5       // пин светодиода

#include <EEPROM.h>
#include <GyverButton.h>

GButton btnUP(BTN_UP_PIN); // кнопка "яркость вверх"
GButton btnDOWN(BTN_DOWN_PIN); // кнопка "яркость вниз"

int LEDbright = 0;

void setup() {
  pinMode(LED_PIN, OUTPUT); // пин светодиода как выход

  if (EEPROM.read(INIT_ADDR) != INIT_KEY) { // первый запуск
    EEPROM.write(INIT_ADDR, INIT_KEY);    // записали ключ

    // записали стандартное значение яркости
    // в данном случае это значение переменной, объявленное выше
    EEPROM.put(0, LEDbright);
  }
  EEPROM.get(0, LEDbright); // прочитали яркость
  analogWrite(LED_PIN, LEDbright);  // включили
}

void loop() {
  // опрос кнопок
  btnUP.tick();
  btnDOWN.tick();

  if (btnUP.isClick()) {
    // увеличение по клику
    LEDbright += 5;
    setBright();
  }

  if (btnDOWN.isClick()) {
    // уменьшение по клику
    LEDbright -= 5;
    setBright();
  }
}

void setBright() {
  LEDbright = constrain(LEDbright, 0, 255); // ограничили
  EEPROM.put(0, LEDbright);           // записали
  analogWrite(LED_PIN, LEDbright);    // изменили яркость
}

Теперь при первом запуске мы получим инициализацию нужных ячеек. Если нужно переинициализировать EEPROM, например в случае добавления новых данных, достаточно изменить наш ключ на любое другое значение в пределах одного байта (0-254). Я пишу именно до 254, потому что 255 является значением ячейки по умолчанию и наш трюк не сработает.

Сброс до “заводских”

Чтобы вернуть настройки к изначально заданным в программе, нужно “спровоцировать” инициализацию. Очевидный способ сделать это – изменить ключ инициализации, который мы назвали INIT_KEY. Либо можно просто вызвать EEPROM.put(адрес, базовые настройки) в нужном месте программы.

Скорость

Как я писал выше, скорость работы с EEPROM составляет:

• Запись/обновление одного байта занимает ~3.3 мс (миллисекунды)
• Чтение одного байта занимает ~0.4 мкс (микросекунды)

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

analogWrite(LED_PIN, EEPROM.read(0));   // изменили яркость

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

#define GET_MODE EEPROM.read(0)     // получить номер режима
#define GET_BRIGHT EEPROM.read(1)   // получить яркость
#define SET_MODE(x) EEPROM.write(0, (x))  // запомнить режим
#define SET_BRIGHT(x) EEPROM.put(1, (x))  // запомнить яркость

Получим удобные макросы, с которыми писать код будет чуть быстрее и удобнее, т.е. строка SET_MODE(3) запишет 3 в ячейку 0

Уменьшение износа

Важная тема: уменьшение износа ячеек частыми перезаписями. Ситуаций может быть много, интересных решений для них – тоже. Рассмотрим простейший пример – всё тот же код со светодиодом и кнопкой. Делать будем следующее: записывать новое значение будем только в том случае, если после последнего нажатия на кнопку прошло какое-то время. То есть нам понадобится таймер (воспользуемся таймером на millis), при нажатии на кнопку таймер будет сбрасываться, а при срабатывании таймера будем писать актуальное значение в EEPROM. Также понадобится флаг, который будет сигнализировать о записи и позволит записать именно один раз. Алгоритм такой:

• При нажатии на кнопку:
  • Если флаг опущен – поднять флаг
  • Сбросить таймер
• Если сработал таймер и флаг поднят:
  • Опустить флаг
  • Записать значения в EEPROM

Посмотрим на всё том же примере:

#define INIT_ADDR 1023  // номер резервной ячейки
#define INIT_KEY 50     // ключ первого запуска. 0-254, на выбор

#define BTN_UP_PIN 3    // пин кнопки вверх
#define BTN_DOWN_PIN 4  // пин кнопки вниз
#define LED_PIN 5       // пин светодиода

#include <EEPROM.h>
#include <GyverButton.h>

GButton btnUP(BTN_UP_PIN); // кнопка "яркость вверх"
GButton btnDOWN(BTN_DOWN_PIN); // кнопка "яркость вниз"

int LEDbright = 0;
uint32_t eepromTimer = 0;
boolean eepromFlag = false;

void setup() {
  pinMode(LED_PIN, OUTPUT); // пин светодиода как выход

  if (EEPROM.read(INIT_ADDR) != INIT_KEY) { // первый запуск
    EEPROM.write(INIT_ADDR, INIT_KEY);    // записали ключ

    // записали стандартное значение яркости
    // в данном случае это значение переменной, объявленное выше
    EEPROM.put(0, LEDbright);
  }
  EEPROM.get(0, LEDbright); // прочитали яркость
  analogWrite(LED_PIN, LEDbright);  // включили
}

void loop() {
  // проверка EEPROM
  checkEEPROM();

  // опрос кнопок
  btnUP.tick();
  btnDOWN.tick();

  if (btnUP.isClick()) {
    // увеличение по клику
    LEDbright += 5;
    setBright();
  }

  if (btnDOWN.isClick()) {
    // уменьшение по клику
    LEDbright -= 5;
    setBright();
  }
}

void setBright() {
  LEDbright = constrain(LEDbright, 0, 255); // ограничили
  analogWrite(LED_PIN, LEDbright);          // изменили яркость
  eepromFlag = true;                        // поднять флаг
  eepromTimer = millis();                   // сбросить таймер
}

void checkEEPROM() {
  // если флаг поднят и с последнего нажатия прошло 10 секунд (10 000 мс)
  if (eepromFlag && (millis() - eepromTimer >= 10000) ) {
    eepromFlag = false;           // опустили флаг
    EEPROM.put(0, LEDbright);     // записали в EEPROM
  }
}

Вот таким нехитрым способом мы многократно снизили износ EEPROM, я очень часто использую этот “алгоритм” работы с настройками в своих устройствах. Есть другие задачи, в которых данные в EEPROM пишутся не когда пользователь что-то изменит, а постоянно, т.е. память работает в режиме чёрного ящика и постоянно записывает значения. Это может быть например контроллер печи, который держит температурный режим по специальному закону, и после внезапной перезагрузки должен вернуться к тому месту в процессе, на котором прервался. Тут есть глобально два варианта:

• Ёмкий конденсатор по питанию микроконтроллера, позволяющий сохранить работу МК после отключения питания на время, достаточное для записи в EEPROM (~3.3 мс). Также МК должен знать о том, что общее питание отключилось: если это высокое напряжение (выше 5 Вольт), то это может быть делитель напряжения на аналоговый пин. Если это 5 Вольт – можно измерять напряжение МК, и момент отключения (разрядка конденсатора) тоже можно отловить и записать нужные данные. Можно взвести прерывание, которое сработает при падении напряжения питания ниже опасного уровня. Можно 5 Вольт завести напрямую на цифровой пин, а сам МК питать через диод и поставить конденсатор – тогда напряжение на измеряющем пине пропадёт до того, как отключится МК, он будет работать от конденсатора. Вот схема:
• 
• Можно писать данные (необязательно один байт, можно целую структуру) хитро, размазывая их по всему EEPROM. Тут глобально два варианта:
  • Писать данные каждый раз в следующую ячейку, и закольцевать переход на первую. Также понадобится хранить где-то счётчик, указывающий на адрес текущей ячейки, и этот счётчик тоже придётся хранить хитро, чтобы он не износил ячейку. Например счётчик – это структура, состоящая из счётчика перезаписей этой структуры и счётчика адреса для большой структуры.
  • Писать данные, пока не достигнут лимит количества перезаписей, количество текущих перезаписей хранить например в этой же структуре. Скажем структура занимает 30 байт, то есть в перспективе мы можем найти эту структуру по адресу, кратному 30. Программа работает, счётчик считает количество перезаписей, при достижении опасного количества вся структура “переезжает” на следующие 30 адресов.

Вариантов уменьшения износа ячеек EEPROM можно придумать много, уникально под свою ситуацию. Есть даже библиотеки готовые, например EEPROMWearLevel. Есть очень интересная статья на Хабре, там рассмотрено ещё несколько хороших алгоритмов и даны ссылки на ещё большее их количество.

Библиотека EEManager

Я часто использую EEPROM в своих проектах, поэтому обернул все рассмотренные выше конструкции в библиотеку, изучить и скачать можно здесь. Библиотека подходит для всех архитектур, в которых есть стандартная EEPROM.h. В библиотеке реализовано:

• Работа с данными любого типа
• Чтение и запись в указанную переменную
• Функция “ключа первого запуска” для задания начальных значений
• Отложенное обновление по тайм-ауту для уменьшения износа

Я надеюсь вы полностью разобрались с самым последним примером с кнопкой и светодиодом, поэтому покажу работу EEManager на его основе:

#define INIT_KEY 50     // ключ первого запуска. 0-254, на выбор

#define BTN_UP_PIN 3    // пин кнопки вверх
#define BTN_DOWN_PIN 4  // пин кнопки вниз
#define LED_PIN 5       // пин светодиода

#include <GyverButton.h>
GButton btnUP(BTN_UP_PIN); // кнопка "яркость вверх"
GButton btnDOWN(BTN_DOWN_PIN); // кнопка "яркость вниз"

#include <EEManager.h>
int LEDbright = 0;
EEManager memory(LEDbright); // передаём переменную в менеджер

void setup() {
  pinMode(LED_PIN, OUTPUT); // пин светодиода как выход

  // запускаем менеджер, указав адрес и ключ запуска
  // он сам проверит ключ, а также прочитает данные
  // из EEPROM и запишет в переменную
  memory.begin(0, INIT_KEY);

  analogWrite(LED_PIN, LEDbright);  // включили
}

void loop() {
  // здесь произойдёт запись по встроенному таймеру
  memory.tick();

  // опрос кнопок
  btnUP.tick();
  btnDOWN.tick();

  if (btnUP.isClick()) {
    // увеличение по клику
    LEDbright += 5;
    setBright();
  }

  if (btnDOWN.isClick()) {
    // уменьшение по клику
    LEDbright -= 5;
    setBright();
  }
}

void setBright() {
  LEDbright = constrain(LEDbright, 0, 255); // ограничили
  analogWrite(LED_PIN, LEDbright);          // изменили яркость
  memory.update();                          // сообщаем, что данные нужно обновить
}

Таким образом вся работа с еепром по чтению, записи, обеспечению корректного первого запуска и уменьшению износа памяти свелась к трём строчкам кода. Пользуйтесь!

Видео

Полезные страницы

• Набор GyverKIT – большой стартовый набор Arduino моей разработки, продаётся в России
• Каталог ссылок на дешёвые Ардуины, датчики, модули и прочие железки с AliExpress у проверенных продавцов
• Подборка библиотек для Arduino, самых интересных и полезных, официальных и не очень
• Полная документация по языку Ардуино, все встроенные функции и макросы, все доступные типы данных
• Сборник полезных алгоритмов для написания скетчей: структура кода, таймеры, фильтры, парсинг данных
• Видео уроки по программированию Arduino с канала “Заметки Ардуинщика” – одни из самых подробных в рунете
• Поддержать автора за работу над уроками
• Обратная связь – сообщить об ошибке в уроке или предложить дополнение по тексту ([email protected])

Серия Eco, кассетные кондиционеры, не универсальные внешние блоки

Таблица кодов ошибок на панели индикации внутреннего блока:

Таблица кодов ошибок на панели индикации внутреннего блока:

RK-18UHC3N

RK-24UHC3N

RK-36UHC3N

RK-48UHC3N

RK-60UHC3N

Таблица кодов ошибок на панели индикации внутреннего блока:

RK-18CHCN
RK-24CHCN
RK-36CHCN
RK-48CHCN
RK-60CHCN

RK-18CHC3N

RK-24CHC3N

RK-36CHC3N

RK-48CHC3N

RK-60CHC3N

RK-48BHC3N

RK-60BHC3N

RK-18UHCNE
RK-24UHCNE
RK-36UHCNE
RK-48UHCNE
RK-60UHCNE

Таблица кодов ошибок на плате внешнего блока:

RK-18HC3NE-W

RK-24HC3NE-W

RK-36HC3NE-W

RK-48HC3NE-W

RK-60HC3NE-W

Таблица кодов ошибок на плате внешнего блока:

RK-18EUHMN
RK-24UHM2N
RK-36UHM2N
RK-48UHM2N
RK-60UHM2N

* 5 Гц – мигание 5 раз в 1 секунду

RK-18UHM3N

RK-24UHM3N

RK-36UHM3N

RK-48UHM3N

RK-60UHM3N

* 5 Гц – мигание 5 раз в 1 секунду

RK-18СHMN
RK-24CHMN
RK-36CHMN
RK-48CHMN
RK-60CHMN

 * 5 Гц – мигание 5 раз в 1 секунд
 * 0,5 Гц – мигание 1 раз в 2 секунды

Напольно-потолочные кондиционеры

RK-18СHM3N
RK-24CHM3N
RK-36CHM3N
RK-48CHM3N
RK-60CHM3N

* 5 Гц – мигание 5 раз в 1 секунду

RK-18BHMN
RK-24BHMN
RK-36BHMN
RK-48KHM2N
RK-60KHM2N

* 5 Гц – мигание 5 раз в 1 секунду

Канальные кондиционеры

RK-18BHM3N
RK-24BHM3N
RK-36BHM3N
RK-48BHM3N
RK-60BHM3N

* 5 Гц – мигание 5 раз в 1 секунду

Универсальные внешние блоки

RK-36HMNE-W
RK-48HMNE-W
RK-60HMNE-W

Индикация неисправностей на плате внешнего блока:

Примечания:
1. Если все три индикатора LED1- LED3 мигают медленно, значит, система находится в
режиме ожидания;
2. T3: Датчик температуры на выходе конденсатора внешнего блока;
3. T4: Датчик температуры наружного воздуха.

Универсальные внешние блоки

RK-36HM3NE-W
RK-48HM3NE-W
RK-60HM3NE-W

Индикация неисправностей на плате внешнего блока:

Примечания:
1. Если все три индикатора LED1- LED3 мигают медленно, значит, система находится в
режиме ожидания;
2. T3: Датчик температуры на выходе конденсатора внешнего блока;
3. T4: Датчик температуры наружного воздуха.

RK-18UHGN
RK-24UHGN
RK-36UHGN
RK-48UHGN
RK-60UHGN

RK-18UHG2N
RK-24UHG2N
RK-36UHG2N
RK-48UHG2N
RK-60UHG2N

RK-18СHGN
RK-24CHGN
RK-36CHGN
RK-48CHGN
RK-60CHGN

Канальные кондиционеры

RK-18BHGN
RK-24BHGN
RK-36BHGN
RK-48BHGN
RK-60BHGN

Канальные кондиционеры

RK-18BHG2N
RK-24BHG2N
RK-36BHG2N
RK-48BHG2N
RK-60BHG2N

RK-18СHTN
RK-24CHTN
RK-36CHTN
RK-48CHTN
RK-60CHTN

RK-18BHTN
RK-24BHTN
RK-36BHTN
RK-48BHTN
RK-60BHTN

Колонные кондиционеры

RK-48FHM/RK-48FHME

Коды ошибок на панели индикации внутреннего блока:

Коды ошибок на плате управления внешнего блока:

Колонные кондиционеры

RK-60FHM/RK-60FHMЕ

Коды ошибок на панели индикации внутреннего блока:

Коды ошибок на плате управления внешнего блока:

RK-24FHM2/RK-24HM2E

Коды ошибок на панели индикации внутреннего блока:

RK-48FHM2/RK-48HM2E
RK-60FHM2/RK-60HM2E

Коды ошибок на панели индикации внутреннего блока:

Коды ошибок на плате внешних блоков RK-48HM2E, RK-60HM2E

Настенные внутренние блоки:

RK-M07CN RK-M09CN
RK-M12CN RK-M18CN
RK-M24CN

RK-M07Q4-AN
RK-M09Q4-AN
RK-M12Q4-AN
RK-M18Q4-AN

★ Мигание
O Включен
X Выключен.

RK-M07T3
RK-M09T3
RK-M07T3N
RK-M09T3N
RK-M12T3
RK-M18T3

★ Мигание 5 Гц
O Включен
X Выключен.
◎ Мигание 0,5 Гц

RK-M07T4N RK-M09T4N
RK-M12T4N RK-M24T4N

RK-M18T4N

RK-M12DL
RK-M18DL

★Мигание 5 Гц
O Включен
X Выключен.
◎ Мигание 0,5 Гц

RK-M12D4L
RK-M18D4L

RK-2M18HME-W
RK-3M27HME-W
RK-4M27HME-W
RK-4M36HME-W
RK-5M36HME-W

RK-2M18HM2E-W
RK-3M27HM2E-W
RK-4M27HM2E-W
RK-4M36HM2E-W
RK-5M42HM2E-W

Примечание: Отображения кодов ошибок исчезнут в течении 30 секунд, если наружный блок вернется к нормальному состоянию (за исключением кодов ошибок E2 и E3)

Цифровые коды на пульте

Определение неисправности по миганию индикаторов

 Коды ошибок сплит систем серии S-HR

Модели: S07HR S09HR S12HR S18HR S24HR

Модели: S30HR S36HR

Ошибки внутреннего блока

Коды неисправностей трёхфазных кондиционеров

СПЕЦПРЕДЛОЖЕНИЕ!
Для владельцев коммерческих объектов и корпоративных заказчиков выполняем диагностику и составляем план ремонтно-восстановительных мероприятий для вашего инженерного оборудования индивидуально, учитывая Ваши пожелания и рекомендации заводов-изготовителей  техники. Подробнее.

Коды ошибок промышленных кондиционеров LG.

Внутренний блок:

01 – датчик температуры воздуха короткозамкнут или обрыв в цепи;

02 – датчик температуры испарителя короткозамкнут или обрыв в цепи;

03 – плохое соединение внутреннего блока с проводным пультом управления;

04 – ошибка дренажного насоса (помпы) или поплавкового датчика уровня конденсата;

05 – ошибка в межблочном соединении внешнего и внутреннего блоков;

06 – датчик температуры наружного блока короткозамкнут или обрыв в цепи;

07 – внутренние блоки мультиситсемы включены на разные режимы работы;

HL – та же ошибка, что и 04, поплавковый датчик разомкнут;

CL – установлен детский замок, для включения нажмите Timer & Min Buttons 3 секунды;

Po – установлен режим jet cool, для выхода нажмите кнопку jet cool

Внешний блок:

21 – перегрузка компрессора по току;

22 – ток компрессора более 14 А;

23 – напряжение постоянного тока ниже 140 В; (не напряжение питания, а после модуля преобразования)

24 – ошибка по высокому/низкому давлению, датчики давления разомкнуты;

25 – напряжение питания выше/ниже нормального значения;

26 – DC Compressor Position;

27 – ошибка PSC (реактор, катушка индуктивности);

28 – DC Link High Volts;

32 – Высокая температура нагнетательной трубы (INV);

33 – Высокая температура нагнетательной трубы (Cons.);

40 – короткое замыкание CT;

41 – датчик температуры D-Pipe замкнут/оборван (INV);

44 – датчик температуры наружного воздуха замкнут/оборван;

45 – датчик температуры конденсатора замкнут/оборван;

46 – датчик на всасывающей трубке замкнут/оборван;

47 – D-pipe датчик замкнут/оборван;

48 – D-pipe датчик и датчик температуры воздуха отсутствуют/оборваны;

51 – комбинированная перегрузка по мощности;

52 – ошибка соединения (main micom-sub micom);

53 – ошибка соединения (внутренний-наружный блоки);

54 – для систем с 3-хфазным питанием, неправильная последовательность фаз,поменять фазу;

60 -ошибка EEPROM (внутренняя энергонезависимая память)

61 -высокая температура трубки конденсатора (конденсера)

62 -высокая температура радиатора(скорее всего имеется в виду радиатор охлаждения силового модуля инвертора)

63 -низкая температура конденсатора

65 -датчик температуры радиатора замкнут/оборван

67 -заблокирован наружный BLDC (безколлекторный электродвигатель постоянного тока) вентилятор

105 -нет связи между главной платой управления и платой управления вентилятором

Коды ошибок всех настенных кондиционеров LG, в том числе серии Art Cool

C1 или CH1 – внутренний датчик температуры воздуха короткозамкнут или обрыв в цепи;

C2 или CH2 – датчик температуры испарителя короткозамкнут или обрыв в цепи;

C4 или CH4 – температурный датчик конденсатора короткозамкнут или обрыв в цепи;

C5 или CH5 – соединение между внешним и внутренним блоками;

C6 или CH6 – превышен ток в  цепи инверторного модуля;

C7 или CH7 – превышен ток компрессора;

C8 или CH8 – не вращается вентилятор внутреннего блока;

C9 или CH9 – не вращается вентилятор внешнего блока;

C10 или CH-10 – неисправен терморезистор контроля температуры корпуса компрессора сплит системы (обрыв или короткое замыкание)

CA – температура нагнетания выше 130 0С;

CC – ошибка EEPROM (внутренняя энергонезависимая память);

CD – ошибка в инверторном модуле;

CE

Po – система находится в энергосберегающем режиме, ошибки нет;

Lo – система находится в режиме тестирования,ошибки нет;

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

Все коды ошибок кондиционеров LG

Всем доброва времени суток. Вообщем появилась ошибка P1603 EEPROM неисправность энергонезависимой памяти EEPROM контроллера ЭБУ,но не на приборке,а в памяти мозга сидит,пробывал скинуть,появляется сного, кто-нибудь сталкивался с этим,как решается проблема,замена мозга? Предохранители все целые,снял ЭБУ дорожки без повреждений видимых. Поюзов инет все сводится к замене мозгов или перепайки контроллера с последующей его прошивкой.
Код № P1603: Цепь резервного питания
ВОЗМОЖНЫЕ ПРИЧИНЫ НЕИСПРАВНОСТИ
• Обрыв или короткое замыкание в цепи резервного питания или плохой контакт в разъёме.
• Отказ блока управления двигателем <МКП>.
• Отказ блока управления двигателем/коробкой передач <АКП>.

То есть, на ЭБУ не приходят постоянные 12в — либо сдох предохранитель, либо проблема в проводке/разъеме, либо в самом ЭБУ. Начать с простейшего — проверить все преды, потом, вооружившись схемами найти по какому проводу приходят на ЭБУ постоянные 12в (у ЭБУ несколько питаний — рабочее при включенном зажигании, и постоянное, которое есть всегда) — померять, есть ли постоянное питание, если там все ок — тогда уже и правда проблема в ЭБУ. Получается, что при выключении зажигания у ЭБУ пропадает постоянное питание и он у Вас постоянно обнуляется — отсюда и проблемы с оборотами и тп.

P1603

— Ошибка EEPROM

Код Р1603 заносится, если выполняются следующие условия:

— прошла инициализация;

— произошла потеря данных в EEPROM при проведении теста «чтение-запись».

Очистить коды.

Если код заносится повторно, заменить контроллер.

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

Серия Midea LCAC DC Inverter

Внутренние кассетные четырёхпоточные модели:

Для напольно — потолочных внутренних блоков:

Для канальных кондиционеров:

Ошибки внешних блоков:

Модели:

MS11D-07HRN1 MO11D-12HN1

MO11D-07HN1  MS11D-18HRN1

MS11D-09HRN1 MO11D-18HN1

MO11D-09HN1  MS11D-21HRN1

MS11D-12HRN1  MO11D-21HN1

MS11D-24HRN1  MO11D-24HN1

E1 — ошибка EEPROM (внутренняя энергонезависимая память)

E2 — ошибка zero-crossing signal

E3 — ошибка двигателя внутреннего вентилятора

E5 — датчик температуры внутреннего воздуха Т1 замкнут/оборван

E6 — датчик температуры испарителя Т2 замкнут/оборван

E7 — датчик температуры конденсатора Т3 замкнут/оборван

EC — утечка хладагента

E8 — ошибка двигателя вентилятора наружного блока или неправильная фазировка питания внешнего блока

E9 — ошибка соединения внутреннего и внешнего блоков

Модели

MVUH252A-VA3

MVUH280A-VA3

MVUH335A-VA3

MVUH400A-VA3

MVUH450A-VA3

E0 — соединения наружного блока неисправны, только для ведомых (slave) блоков

E1 — неправильная последовательность фаз

E2 — соединение между наружным блоком и внутренним

E3 — reserved

E4 — неисправен температурный датчик

E5 — reserved

E6 — reserved

E7 — reseved

E8 — неправильный адрес наружного блока

E9 — напряжение питания не в норме

H0 — соединение между IR341 и 780034

H1 — соединение между 0537 и 780034

Модели

MCA2-12HRN1-Q MCA2-18HRN1-Q MCC-18HRN1-Q MCC-24HRN1-Q

MCC-36HRN1-R MCC-48HRN1-R MCC-60HRN1-R MUB-12HRN1-Q

MUB-18HRN1-Q MUB-24HRN1-Q MUB-36HRN1-R MUB-48HRN1-R

MUB-60HRN1-R MTB-18HWN1-Q MTB-24HWN1-Q MTB-36HWN1-R

MTB-48HWN1-R MTB-60HWN1-R MHC-24HWN1-Q MHC-36HWN1-R

MHC-48HWN1-R MHC-60HWN1-R MOU-12HN1 MOU-18HN1-Q

MOU-24HN1-Q MOU-36HN1-R MOU-48HN1-R MOUA-60HN1-R

Код ошибки определяется по мигающим индикаторам на панели кондиционера инструкция в сервис мануале

Модели

MS11MU-09HRDN1 MS11MU-12HRDN1

MS11MU-18HRDN1 MS11MU-24HRDN1

MO11MU-09HRDN1 MO11MU-12HRDN1

MO11MU-18HRDN1 MO11MU-24HRDN1

E0 — ошибка EEPROM (энергонезависимая память) внутреннего блока

E1 — ошибка соединения внутреннего и наружного блоков

E2 — ошибка перехода через ноль (zero-crossing signal error)

E3 — ошибка двигателя вентилятора внутреннего блока

E4 — датчик температуры внутреннего воздуха замкнут/оборван

E5 — датчик температуры испарителя замкнут/оборван

EC — утечка хладагента

MSX 07 — MSX 18

MSX 21 — MSX 24

E1 — ошибка EEPROM

E2 — утечка тока по нулю

E3 — ошибка вентилятора внутреннего блока- нет отклика от датчика Холла электродвигателя

E4 — превышен пусковой ток при попытке запуска более четырёх раз подряд

E5 — ошибка датчика температуры воздуха внутреннего блока

E6 — ошибка датчика температуры испарителя

E7 — ошибка датчика температуры конденсатора

E8 — перепутаны фазы

E9 — ошибка соединения внутреннего и внешнего блоков

Для инверторных моделей

E0 — ошибка EEPROM

E1 — неправильное межблочное соединение (между внутренним и внешним блоком)

E2 — неправильное подключение нуль-фаза

E3 — неисправность электродвигателя вентилятора внутреннего блока

E4 — резерв

E5 — закорочен, оборван температурный датчик наружного блока

E6 — закорочен, оборван температурный датчик внутреннего блока

P0 — перегузка по току, неисправен силовой модуль (IPM)

P1 — напряжение питание не в норме (повышенное, пониженное)

P2 — высокая температура нагнетания

P3 — слишком низкая для работы кондиционера температура наружного воздуха

P4 — несправен компрессор

СПЕЦПРЕДЛОЖЕНИЕ!
Для владельцев коммерческих объектов и корпоративных заказчиков выполняем диагностику и составляем план ремонтно-восстановительных мероприятий для вашего инженерного оборудования индивидуально, учитывая Ваши пожелания и рекомендации заводов-изготовителей  техники. Подробнее.