Arduino.ru

Не так, конечно, ну, да Бог с Вами.

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

Ничего не делается "единожды".

Массив символов "ffff*" изначально (при компиляции) располагается в области данных и просто там живёт - это просто кусок памяти. Ничего в нём особенного. Компилятор предполагает, что содержимое этого куска памяти по идее не должно изменяться, а должно быть read-only потому этот элемент имеет квалификатор const.

При первом, втором и любом другом выполнении loop переменной s просто присваивается адрес этого куска памяти. Это всё. Больше не делается ничего. Первый проход от последующих не отличается ничем. Ничего там не делается "единожды", всё делается всегда строго одинаково.

Когда Вы пытаетесь присваивать адрес этого блока памяти обычному (не const) указателю, компилятор понимает. что это может привести к порче read-only данных и предупреждает Вас об этом. Но только предупреждает, а не запрещает, т.к. язык С++ - он "для больших мальчиков", которые знают что делают, и которых не надо постоянно бить по рукам "туда не лезь", "то не трогай".

Да спасибо огромное. Я так и понял просто криво изложил мысль.
"Выполняется единожды" я и имел ввиду при компиляции как вы и сказали.
Спасибо за разъяснения. Буду дальше изучать Ваши Этюды.
Глядишь еще через 2 месяца я научусь мигать наконец то =))

void setup(void) {
	Serial.begin(57600);
	Serial.println("Fun begins!");
	for (int i=0; i<10; i++) {
		const int n = i;
		Serial.print("Result: ");
		char buffer[12];
		itoa(n, buffer, sizeof(buffer));
		Serial.print(buffer);
		Serial.print(" kHz (");
		itoa(n*1000, buffer, sizeof(buffer));
		Serial.print(buffer);
		Serial.println(" Hz)");
	}
}

void loop(void) {}

По-моему здесь ошибка? В функции itoa

itoa (int data, char* string, int radix);     // преобразование int

• data – это конвертируемая переменная;
• char* string – указатель на строку (имя массива);
• radix – система исчисления результата в строке:

НЕ  sizeof(buffer), который равен 12

Да, похоже на то. А работала, скорее всего, потому, что 12 не поняла, а по умолчанию - 10 :)

Здравствуйте знатоки!

Подскажите пожалуйста – как преодолеть недостаток памяти в этом скетче для Ардуино Нано?

«Скетч использует 19354 байт (63%) памяти устройства. Всего доступно 30720 байт.

Глобальные переменные используют 1541 байт (75%) динамической памяти, оставляя 507 байт для локальных переменных. Максимум: 2048 байт.

Недостаточно памяти, программа может работать нестабильно.»

// SavingDataToSD_PVA сохранение данных из Сом-порта Солн Эл-ции через RS232-TTL на SD карту



// В c:\Program Files (x86)\Arduino\hardware\arduino\avr\libraries\SoftwareSerial\src\SoftwareSerial.h

// #define _SS_MAX_RX_BUFF 64 изменил на 100, иначе из Сом-порта Солн Эл-ции помещается НЕ все.



#define pin_SW_SDA 5             // D5 для SDA шины I2C.

#define pin_SW_SCL 6             // D6 для SCL

#include <iarduino_RTC.h> // для Часов

#include <SPI.h> // для SD, I2C

iarduino_RTC time(RTC_DS3231);  // Создаём объект time



#include <SoftwareSerial.h> // для прогр СОМ-порта

#include <string.h>

SoftwareSerial Com_Serial( 2, 3 ); // RX, TX



#include <Wire.h> // для диспл I2C

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2); // Уст дисп через I2C на A4- SDA, A5-SCL



#include <SD.h> // для SD карты

const int chipSelect = 4; // для SD



// глобальные переменные

int delta_T = 0 ;

unsigned int preT = 0 ;

char zapr[8]  = {81, 80, 73, 71, 83, 183, 169, 13}; // запрос в СЭ

int nextTime = 100000;

int interval = 10000;                // будет 65000 Миллисек Периодичность отправки пакетов на сервер

int kol_zap = 0;



void setup() {



  time.begin();                       // Инициируем RTC модуль

  Com_Serial.begin(2400);

  // Тестовый опрос инвертора

  Com_Serial.println("Q");

  delay(2000);

  while (Com_Serial.available()) {

    Com_Serial.read(); // Очищаем порт

  }

}



void loop() {

  if (!SD.begin(chipSelect)) {

    lcd.clear();

    lcd.setCursor(0, 0);

    lcd.print("SD Err");

    while (1);

  }

  char *buf1 = (char*)calloc(81, 1); // запрашиваем 81 байт в "куче" и обнуляем его.



  char *buf = (char*)calloc(100, 1); // запрашиваем 100 байт в "куче" и обнуляем его.

  //Если в сом-порте больший кусок (а у нас 98) чем в SoftwareSerial.h, то конвертер RS232 сильно греется





  lcd.init();

  lcd.backlight();



  if (!buf) {

    lcd.clear();

    lcd.setCursor(0, 0);

    lcd.print("MEM buf need");

    while (1);

  }



  if (!buf1) {

    lcd.clear();

    lcd.setCursor(0, 0);

    lcd.print("MEM buf1 need");

    while (1);

  }

  // Запрос текущих параметров Солнечной станции

  Com_Serial.print(zapr);

  delay(2000);

  if (Com_Serial.available())  {

    delay(100);

    Com_Serial.readBytes(buf, 100); //Загоняем 100б из Сом-порта в буфер



    for (int i = 0; i < 81 && buf[i] != 0; i++)    {

      if (buf[i] == ' ')      {

        buf1[i] = ';';

      }

      else if (buf[i] == '(') {

        buf1[i] = ' ';

      }

      else {

        buf1[i] = buf[i];

      }

      buf1[81] = '\0';

    }

    free(buf);

    // отказался от String для экономии памяти

    //    String(buf) = String(buf).substring(1, 81); // Помещаем в строку с 1 по 81 байт

    //    String(buffer).replace(" ", ";"); // заменяем в этой строке все пробелы(разделители показателей) на ";"

    //    time.settime(0, 26, 15, 26, 07, 19, 5);



    delta_T = millis() - preT ;                    // Время предыдущей итерации

    if ( abs(delta_T) > 604800000 ) {              // Проверка на переполнение millis

      delta_T = 0;

    }

    preT = millis() ;



    // Проверяем вышел ли тайм-аут сервера и если да, то отправляем данные

    if ( millis() - nextTime > (interval - 4215) ) {

      File dataFile = SD.open("datalog.csv", FILE_WRITE);

      if (dataFile) { // если файл есть, то дописываем в него

        dataFile.print(time.gettime("Y.m.d;H:i")); //

        dataFile.println(buf1);

        dataFile.close();

        free(buf1);



        kol_zap = kol_zap + 1;



        lcd.clear();

        lcd.setCursor(0, 0);

        lcd.print(time.gettime("Y.m.d;H:i"));



        lcd.setCursor(0, 1);

        lcd.print("zap= ");

        lcd.print(kol_zap);



      }

      else {

        lcd.clear();

        lcd.setCursor(0, 0);

        lcd.print("Err File");

      }

      nextTime = millis();

    }

  }

  else  {



    lcd.clear();

    lcd.setCursor(0, 0);

    lcd.print("Com_NOT");



  }

}

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

1.
Вы запрашиваете пямять под buf1 в строке №99 всегда, прикаждом проходе loop. А освобождаете её в строке № 219 в зоне действия сразу двух условий: строки №№ 149 и 207. Т.е. при тех прозодах loop, в которых хотя бы одно из этих условий окажется неверным, память под buf1 не освобождается. Стало быть он будет постоянно накапливаться.

2.
Примерно тоже самое про buf. Запрашиваете Вы эту паямть всегда (строка №103), а вот освобождаете в строке №181 в зоне действия условия строки № 149. Опять же память запрошенную при проходах loop, в которых условие неверно, не освобождает никто и никогда.

Спасибо за подсказку. И в самом деле - ляпа ( но для "чайника" не очевидная) ))).

Переделал код, перенеся запрос памяти buf под цикл и разместив buf1 на стеке. НЕ ПОМОГЛО.

Убираю обращения к датчику времени - памяти хватает и скетч работает.

Но мне-то как раз нужно привязать статистику к дате и времени!!!

  if (Com_Serial.available())  {
    
    char buf1[81]; // Разместил на стеке

    //  char *buf1 = (char*)calloc(81, 1); // запрашиваем 81 байт в "куче" и обнуляем его.
    char *buf = (char*)calloc(100, 1); // запрашиваем 100 байт в "куче" и обнуляем его.
    //Если в сом-порте больший кусок (а у нас 98) чем в SoftwareSerial.h, то конвертер RS232 сильно греется

    if (!buf) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("MEM buf need");
      while (1);
    }
    delay(100);
    Com_Serial.readBytes(buf, 100); //Загоняем 100б из Сом-порта в буфер

    for (int i = 0; i < 81 && buf[i] != 0; i++)    {
      if (buf[i] == ' ')      {
        buf1[i] = ';';
      }
      else if (buf[i] == '(') {
        buf1[i] = ' ';
      }
      else {
        buf1[i] = buf[i];
      }
      buf1[81] = '\0';
    }
    free(buf);
    // отказался от String для экономии памяти
    //    String(buf) = String(buf).substring(1, 81); // Помещаем в строку с 1 по 81 байт
    //    String(buffer).replace(" ", ";"); // заменяем в этой строке все пробелы(разделители показателей) на ";"
    //    time.settime(0, 26, 15, 26, 07, 19, 5);

    delta_T = millis() - preT ;                    // Время предыдущей итерации
    if ( abs(delta_T) > 604800000 ) {              // Проверка на переполнение millis
      delta_T = 0;
    }
    preT = millis() ;
    // Проверяем вышел ли тайм-аут сервера и если да, то отправляем данные
    if ( millis() - nextTime > (interval - 4215) ) {
      File dataFile = SD.open("datalog.csv", FILE_WRITE);
      if (dataFile) { // если файл есть, то дописываем в него
        //        dataFile.print(time.gettime("Y.m.d;H:i")); // Убрал вывод времени - памяти хватает
        dataFile.println(buf1);
        dataFile.close();
        kol_zap = kol_zap + 1;
        lcd.clear();
        lcd.setCursor(0, 0);
        //lcd.print(time.gettime("Y.m.d;H:i")); // Убрал вывод времени - памяти хватает 
        lcd.setCursor(0, 1);
        lcd.print("zap= ");
        lcd.print(kol_zap);
      }

ну, ошибок там по-прежнему очень много.

Например, чтрока №37. if ( abs(delta_T) > 604800000 )

delta_T объявлена как int.  С какого перепугу int'у быть больше, чем 604800000? Такого не может быть никогда, а значит этот if не сработает никогда.

Вообще, включите предупреждения компиляьора. Там много интересного. Поправьте очевидные вещи, с апмятью потом поборемся.

И, да, публикуйте скетч всегда целиком. Я копирую его к себе, а Вы заставляете меня ещё и куски склеивать.

Прошу прощение за беспокойство и бестолковость.

Да, там сначала были все long - и. Но я уже начал тыкаться наугад и сокращать что попало.

Вообще-то у меня все работало до тех пор пока я не подключил <iarduino_RTC.h>

// SavingDataToSD_PVA
//19.07.2019 Перелыгин Вадим. Модернизация этого скетча с целью сохранение данных инвертора на SD-карту вместо отсылки на сайт.
// В c:\Program Files (x86)\Arduino\hardware\arduino\avr\libraries\SoftwareSerial\src\SoftwareSerial.h
// #define _SS_MAX_RX_BUFF 64 изменил на 100, иначе из Сом-пора помещается НЕ все.

// ***************** nsk-electro.ru ***** Семерков Николай **** 2018
// OpenMonitoring_V14
// Пример кода осуществляющий чтение данных из инверторов типа SILA, Expert, Stark, Combi, Prosolar и.т.д
// и передачи для визуализации и логгирования на сервис http://open-monitoring.online

#include <SoftwareSerial.h>
#include <string.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2); //pva Устанавливаем дисплей через I2C на аналоговые пины A4- SDA, A5-SCL
#include <SPI.h>
#include <SD.h>
SoftwareSerial Com_Serial( 2, 3 ); // RX, TX

// глобальные переменные
const int chipSelect = 4;
long delta_T = 0 ;
unsigned long preT = 0 ;
float Psolar = 0 ;       // Мощность снимаемая с панелей
float Power_sum = 0 ;    // Переменная, хранящая энергию до ее отправки на сервер и получения подтверждения о ее принятии
float Power_count = 0 ;  // Количество энергии за последнюю итерацию
char zapr[8]  = {81, 80, 73, 71, 83, 183, 169, 13};
long nextTime = 100000;
long interval = 65000;                // Периодичность отправки пакетов на сервер
int kol_zap = 0;

void setup() {
  lcd.init();
  lcd.backlight();
  Com_Serial.begin(2400);
  // Тестовый опрос инвертора
  Com_Serial.println("Q");
  delay(2000);
  while (Com_Serial.available()) {
    Com_Serial.read(); // Очищаем порт
  }
}

void loop() {
  if (!SD.begin(chipSelect)) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("SD Err");
    while (1);
  }
  char *buffer = (char*)calloc(100, 1); // запрашиваем 100 байт в "куче" и обнуляем его.
  //Если в сом-порте больший кусок (а у нас 98), то конвертер RS232 сильно греется

  if (!buffer) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("MEMORY need");
    while (1);
  }

  // Запрос текущих параметров инвертора
  Com_Serial.print(zapr);
  // Если есть данные - читаем
  delay(2000);
  if (Com_Serial.available())
  {
    delay(100);
    Com_Serial.readBytes(buffer, 100); //Загоняем 100б из Сом-порта в буфер
    String str = String(buffer).substring(1, 81); // Помещаем в строку с 1 по 81 байт, исключая 0 байт со "("
    str.replace(" ", ";"); // заменяем в этой строке все пробелы(разделители показателей) на ";"
    free(buffer);

    delta_T = millis() - preT ;                    // Время предыдущей итерации
    if ( abs(delta_T) > 604800000 ) {              // Проверка на переполнение millis
      delta_T = 0;
    }
    Power_count = Psolar * delta_T * .0000002778 ; // Количество энергии за 1 итерацию
    Power_sum += Power_count ;
    preT = millis() ;

    // Проверяем вышел ли тайм-аут сервера и если да, то отправляем данные
    if ( millis() - nextTime > (interval - 4215) ) {
      File dataFile = SD.open("datalog.csv", FILE_WRITE);

      if (dataFile) { // если файл есть, то дописываем в него
        dataFile.println(str);
        dataFile.close();
        kol_zap = kol_zap + 1;

        lcd.setCursor(0, 1);
        lcd.print("zap= ");
        lcd.print(kol_zap);
      }
      else {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Err File");
      }
      nextTime = millis();
    }
    //    }
    //    else
    //    {
    //      lcd.clear();
    //      lcd.setCursor(0, 0);
    //      lcd.print("BUF PUST");
    //    }
  }
  else
  {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Com_NOT");
  }
}

1. Вы по сути используете массивы ВСЕГДА. Сделайте их сразу статическими: одновременно избежите возможных ошибок с распределением памяти и добъетесь более точной оценки распределения памяти со стороны компилятора.

2. Перенесите текстовые строки в PROGMEM - там их не очень много, но все равно чуть-чуть освободите оперативную память.

3. IMHO одновременное использование <SD.h> и <string.h> - это слишком много для МК с двумя кбайтами памяти. Либо используйте контроллер помощнее (MEGA), либо избавляйтесь от <string>.

Нет, Вы перепутали. <string.h> - это про strcpy/strlen и т.п.

Кстати, я вчера просто всё в одну кучу валить не стал.

Вы включили предупреждения компилятора, как я просил? Видели сколько ругани на эту библиотеку? Она очень, ну очень кривая (по крайней мере та версия, что у меня стоит).

И да, чтобы дальше разбираться с памятью, мне нужны Ваши версии библиотек. Соберите всё в архивчик и выложите в облако.

Спасибо за совет.

const dataType variableName[] PROGMEM Хранит данные во флэш-памяти (памяти программ) вместо SRAM.

Т.е. это даже не в "КУЧЕ"? И не все равно, что если рассположить их перед Setup() ?

Например

Можно-то можно, только потом Вы их оттуда читать должны. Вы заете об этом?

Вообще-то ругается только так.

"C:\Disk E\ST80_2007\Arduino_ПВА\SavingDataToSD_PVA_v4\SavingDataToSD_PVA_v4.ino:30:63: warning: narrowing conversion of '183' from 'int' to 'char' inside { } [-Wnarrowing]

А будет проблема с этим? Ни разу не пользовался 

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

Вы там по ссылке все библиотеки сложили? ЧТобы я мог Вашу память посмотреть с Вашими библиотеками, а не со своими.

Всю среду, которой пользуюсь. Она не в в program file а в моем каталоге.

Хорошо, посмотрю.

Запустил в Вашей среде. Ругани гораздо больше. Зайдите в "Настройки" и в поле "Сообщения компилятора" выберите "Все". Пока Вы этого не сделаете - будете слепым. Вам подсказывают, а Вы не видите.

Вот она, Ваша ругань

In file included from C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC.h:33:0,

                 from C:\ttmp\SavingDataToSD_PVA_v4\SavingDataToSD_PVA_v4.ino:8:

C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC_DS1302.h: In member function 'bool iarduino_RTC_DS1302::funcWriteReg(uint8_t, uint8_t)':

C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC_DS1302.h:59:3: warning: no return statement in function returning non-void [-Wreturn-type]

   }                      //

   ^

C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC_DS1302.h: In member function 'void iarduino_RTC_DS1302::funcWriteByte(uint8_t)':

C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC_DS1302.h:62:202: warning: comparison is always true due to limited range of data type [-Wtype-limits]

   void funcWriteByte (uint8_t j)              /* Передача  одного байта  (байт для передачи)         */ {uint8_t i=0, n=500/busRate+1; pinMode(pinDAT, OUTPUT); while(i>=0 && i<8){digitalWrite(pinDAT, (j & _BV(i))); delayMicroseconds(n); digitalWrite(pinCLK, 1); delayMicroseconds(n); digitalWrite(pinCLK, 0); i++;} pinMode(pinDAT, INPUT);}

                                                                                                                                                                                                          ^

C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC_DS1302.h: In member function 'uint8_t iarduino_RTC_DS1302::funcReadByte(bool)':

C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC_DS1302.h:63:301: warning: comparison is always true due to limited range of data type [-Wtype-limits]

   uint8_t funcReadByte (bool j)              /* Получение одного байта  (флаг чтения предустановленного бита с линии DAT) */ {uint8_t i=0, k=0, n=500/busRate+1; pinMode(pinDAT, INPUT); if(j){if(digitalRead(pinDAT)){k |= _BV(i);} i++;} while(i>=0 && i<8){digitalWrite(pinCLK, 1); delayMicroseconds(n); digitalWrite(pinCLK, 0); delayMicroseconds(n); if(digitalRead(pinDAT)){k |= _BV(i);} i++;} return k;}

                                                                                                                                                                                                                                                                                                             ^

In file included from C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC_DS1307.h:4:0,

                 from C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC.h:34,

                 from C:\ttmp\SavingDataToSD_PVA_v4\SavingDataToSD_PVA_v4.ino:8:

C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC_I2C.h: At global scope:

C:\ttmp\libraries\iarduino_RTC-1.2.1\src/iarduino_RTC_I2C.h:64:23: warning: unused parameter 'speed' [-Wunused-parameter]

   void begin(uint32_t speed){            // Аргумент: скорость шины в кГц.

                       ^

C:\ttmp\SavingDataToSD_PVA_v4\SavingDataToSD_PVA_v4.ino:30:63: warning: narrowing conversion of '183' from 'int' to 'char' inside { } [-Wnarrowing]

 const char zapr[8] PROGMEM = {81, 80, 73, 71, 83, 183, 169, 13};

                                                               ^

C:\ttmp\SavingDataToSD_PVA_v4\SavingDataToSD_PVA_v4.ino:30:63: warning: narrowing conversion of '169' from 'int' to 'char' inside { } [-Wnarrowing]

C:\ttmp\SavingDataToSD_PVA_v4\SavingDataToSD_PVA_v4.ino: In function 'void loop()':

C:\ttmp\SavingDataToSD_PVA_v4\SavingDataToSD_PVA_v4.ino:97:23: warning: comparison is always false due to limited range of data type [-Wtype-limits]

     if ( abs(delta_T) > 604800000 ) {              // Проверка на переполнение millis

                       ^

In file included from C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC.h:33:0,

                 from C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC.cpp:1:

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_DS1302.h: In member function 'bool iarduino_RTC_DS1302::funcWriteReg(uint8_t, uint8_t)':

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_DS1302.h:59:3: warning: no return statement in function returning non-void [-Wreturn-type]

   }                      //

   ^

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_DS1302.h: In member function 'void iarduino_RTC_DS1302::funcWriteByte(uint8_t)':

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_DS1302.h:62:202: warning: comparison is always true due to limited range of data type [-Wtype-limits]

   void funcWriteByte (uint8_t j)              /* Передача  одного байта  (байт для передачи)         */ {uint8_t i=0, n=500/busRate+1; pinMode(pinDAT, OUTPUT); while(i>=0 && i<8){digitalWrite(pinDAT, (j & _BV(i))); delayMicroseconds(n); digitalWrite(pinCLK, 1); delayMicroseconds(n); digitalWrite(pinCLK, 0); i++;} pinMode(pinDAT, INPUT);}

                                                                                                                                                                                                          ^

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_DS1302.h: In member function 'uint8_t iarduino_RTC_DS1302::funcReadByte(bool)':

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_DS1302.h:63:301: warning: comparison is always true due to limited range of data type [-Wtype-limits]

   uint8_t funcReadByte (bool j)              /* Получение одного байта  (флаг чтения предустановленного бита с линии DAT) */ {uint8_t i=0, k=0, n=500/busRate+1; pinMode(pinDAT, INPUT); if(j){if(digitalRead(pinDAT)){k |= _BV(i);} i++;} while(i>=0 && i<8){digitalWrite(pinCLK, 1); delayMicroseconds(n); digitalWrite(pinCLK, 0); delayMicroseconds(n); if(digitalRead(pinDAT)){k |= _BV(i);} i++;} return k;}

                                                                                                                                                                                                                                                                                                             ^

In file included from C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_DS1307.h:4:0,

                 from C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC.h:34,

                 from C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC.cpp:1:

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_I2C.h: In member function 'virtual bool iarduino_I2C::readBytes(uint8_t, uint8_t, uint8_t*, uint8_t)':

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_I2C.h:140:24: warning: suggest parentheses around comparison in operand of '&' [-Wparentheses]

      if (sum) { if(TWSR&0xF8!=0x50) {  i=0;}}    // Если после чтения очередного байта пакета значение регистра состояния шины I2C Arduino TWSR с маской 0xF8 не равно 0x50 значит произошла ошибка при чтении

                        ^

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_I2C.h:141:21: warning: suggest parentheses around comparison in operand of '&' [-Wparentheses]

      else  { if(TWSR&0xF8!=0x58) {  i=0;}}    // Если после чтения последного байта пакета значение регистра состояния шины I2C Arduino TWSR с маской 0xF8 не равно 0x58 значит произошла ошибка при чтении

                     ^

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_I2C.h: In member function 'virtual bool iarduino_I2C::readBytes(uint8_t, uint8_t*, uint8_t)':

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_I2C.h:163:24: warning: suggest parentheses around comparison in operand of '&' [-Wparentheses]

      if (sum) { if(TWSR&0xF8!=0x50) {  i=0;}}    // Если после чтения очередного байта пакета значение регистра состояния шины I2C Arduino TWSR с маской 0xF8 не равно 0x50 значит произошла ошибка при чтении

                        ^

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC_I2C.h:164:21: warning: suggest parentheses around comparison in operand of '&' [-Wparentheses]

      else  { if(TWSR&0xF8!=0x58) {  i=0;}}    // Если после чтения последного байта пакета значение регистра состояния шины I2C Arduino TWSR с маской 0xF8 не равно 0x58 значит произошла ошибка при чтении

                     ^

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC.cpp: In member function 'char* iarduino_RTC::gettime(const char*)':

C:\ttmp\libraries\iarduino_RTC-1.2.1\src\iarduino_RTC.cpp:6:26: warning: unused variable 'f' [-Wunused-variable]

    uint8_t j, k, n; bool f;                  // Объявляем локальные переменные

                          ^

In file included from C:\Arduino\hardware\arduino\avr\variants\eightanaloginputs/pins_arduino.h:23:0,

                 from C:\Arduino\hardware\arduino\avr\cores\arduino/Arduino.h:257,

                 from C:\Arduino\hardware\arduino\avr\libraries\SoftwareSerial\src\SoftwareSerial.cpp:43:

C:\Arduino\hardware\arduino\avr\libraries\SoftwareSerial\src\SoftwareSerial.cpp: In member function 'void SoftwareSerial::begin(long int)':

c:\arduino\hardware\arduino\avr\variants\standard\pins_arduino.h:74:39: warning: comparison is always true due to limited range of data type [-Wtype-limits]

 #define digitalPinToPCICR(p)    (((p) >= 0 && (p) <= 21) ? (&PCICR) : ((uint8_t *)0))

                                       ^

C:\Arduino\hardware\arduino\avr\libraries\SoftwareSerial\src\SoftwareSerial.cpp:319:7: note: in expansion of macro 'digitalPinToPCICR'

   if (digitalPinToPCICR(_receivePin)) {

       ^

c:\arduino\hardware\arduino\avr\variants\standard\pins_arduino.h:74:39: warning: comparison is always true due to limited range of data type [-Wtype-limits]

 #define digitalPinToPCICR(p)    (((p) >= 0 && (p) <= 21) ? (&PCICR) : ((uint8_t *)0))

                                       ^

C:\Arduino\hardware\arduino\avr\libraries\SoftwareSerial\src\SoftwareSerial.cpp:360:6: note: in expansion of macro 'digitalPinToPCICR'

     *digitalPinToPCICR(_receivePin) |= _BV(digitalPinToPCICRbit(_receivePin));

      ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:66:39: warning: unused parameter 'cols' [-Wunused-parameter]

 void LiquidCrystal_I2C::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {

                                       ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:307:39: warning: unused parameter 'cmdDelay' [-Wunused-parameter]

 void LiquidCrystal_I2C::setDelay (int cmdDelay,int charDelay) {}

                                       ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:307:52: warning: unused parameter 'charDelay' [-Wunused-parameter]

 void LiquidCrystal_I2C::setDelay (int cmdDelay,int charDelay) {}

                                                    ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:310:50: warning: unused parameter 'graphtype' [-Wunused-parameter]

 uint8_t LiquidCrystal_I2C::init_bargraph(uint8_t graphtype){return 0;}

                                                  ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:311:55: warning: unused parameter 'row' [-Wunused-parameter]

 void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end){}

                                                       ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:311:68: warning: unused parameter 'column' [-Wunused-parameter]

 void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end){}

                                                                    ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:311:84: warning: unused parameter 'len' [-Wunused-parameter]

 void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end){}

                                                                                    ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:311:98: warning: unused parameter 'pixel_col_end' [-Wunused-parameter]

 void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end){}

                                                                                                  ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:312:53: warning: unused parameter 'row' [-Wunused-parameter]

 void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end){}

                                                     ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:312:66: warning: unused parameter 'column' [-Wunused-parameter]

 void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end){}

                                                                  ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:312:82: warning: unused parameter 'len' [-Wunused-parameter]

 void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end){}

                                                                                  ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:312:96: warning: unused parameter 'pixel_row_end' [-Wunused-parameter]

 void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end){}

                                                                                                ^

C:\ttmp\libraries\LiquidCrystal_I2C_V112\LiquidCrystal_I2C.cpp:313:45: warning: unused parameter 'new_val' [-Wunused-parameter]

 void LiquidCrystal_I2C::setContrast(uint8_t new_val){}

                                             ^

Скетч использует 19632 байт (63%) памяти устройства. Всего доступно 30720 байт.
Глобальные переменные используют 1482 байт (72%) динамической памяти, оставляя 566 байт для локальных переменных. Максимум: 2048 байт.

Про память сейчас посмотрю

"...Ругани гораздо больше. ..."

ЁПРСТ! Сколько кривизны-то!

А где ж мне еще взять библиотеку, позволяющую программную реализацию шины I2C

для датчика времени RTC_DS3231?

Аппаратные-то SDA  и SCL у меня уже заняты дисплеем с I2C…

Прочти чонить за i2c наконец. Иначе над твоей последней строкой мы будем глумица

И чо? У него жа адрес не такой, как у часов. Ну и цепляйте в параллель. Всё будет отлично. Только помните, там резисторы есть от SDA и SCL на питание. Так вот, Вы можете прицепить второе (и третье, если надо) устройство, но резисторов новых не ставьте. Одна пара резисторов на все устройства.

Поехали по памяти

Всего у Вас 1482 байта данных.

Из них львиную долю жрёт буфер SD  - 512 байтов. С этим Вы вряд ли что сделаете, т.к. для этого нужно просто переписать библиотеку SD, полагаю, что это для Вас не вариант.

На втором месте (175 байтов) аппаратный Serial, которым Вы не пользуетесь. Зато им пользуется библиотека SD, причем пользуется она им в тех местах, которые Вам не нужны. От этих 175 байтов можно легко избавиться. Для этого в файлах библиотеки SD: SdFile.cpp и SdFatUtil.h найдите ВСЕ вхождения типа “Serial….” И закомментируйте их нафиг (только с умом, чтобы синтаксис не поломать). Из Ваших 1482 байта данных немедленно станет 1307. Уже легче. В конце я выложу файлы с закомментированным использованием сериала.

Также около того, а может даже больше (160-200 байтов, трудно посчитать точно) тянет библиотека iarduinoRTC. Дело в том, что она не только сама жрёт, но ещё и использует самогонную iarduino_I2C. Т.е. Вы используете системную I2C для LCD и ещё одну для часов. Я уже говорил Вам, что эта библиотека очень кривая. Просто выбросьте и пользуйтесь нормальной. Когда я заменил в Вашем коде её на нормальную, объём данных снизился с 1307 до 1110 байтов, т.е. сэкономили ещё 190 байтов!

Пока я смотрел только библиотеки. Я совершенно не смотрел Ваш код. Мне удалось снизить размер данных до 1110 байтов.

Давайте сделаем так.  Проделайте тоже самое. Получите такой же результат. Если при таком раскладе у Вас по-прежнему не будет хватать, перейдём к коду. Оптимизация по библиотекам – самая крупная здесь и начать надо с неё.

Вот файлы из библиотеки SD с закомментированным Serial

SdFile.cpp

/* Arduino SdFat Library
 * Copyright (C) 2009 by William Greiman
 *
 * This file is part of the Arduino SdFat Library
 *
 * This Library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This Library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with the Arduino SdFat Library.  If not, see
 * <http://www.gnu.org/licenses/>.
 */
#include "SdFat.h"
#ifdef __AVR__
#include <avr/pgmspace.h>
#endif
#include <Arduino.h>
//------------------------------------------------------------------------------
// callback function for date/time
void (*SdFile::dateTime_)(uint16_t* date, uint16_t* time) = NULL;

#if ALLOW_DEPRECATED_FUNCTIONS
// suppress cpplint warnings with NOLINT comment
void (*SdFile::oldDateTime_)(uint16_t& date, uint16_t& time) = NULL;  // NOLINT
#endif  // ALLOW_DEPRECATED_FUNCTIONS
//------------------------------------------------------------------------------
// add a cluster to a file
uint8_t SdFile::addCluster() {
  if (!vol_->allocContiguous(1, &curCluster_)) return false;

  // if first cluster of file link to directory entry
  if (firstCluster_ == 0) {
    firstCluster_ = curCluster_;
    flags_ |= F_FILE_DIR_DIRTY;
  }
  return true;
}
//------------------------------------------------------------------------------
// Add a cluster to a directory file and zero the cluster.
// return with first block of cluster in the cache
uint8_t SdFile::addDirCluster(void) {
  if (!addCluster()) return false;

  // zero data in cluster insure first cluster is in cache
  uint32_t block = vol_->clusterStartBlock(curCluster_);
  for (uint8_t i = vol_->blocksPerCluster_; i != 0; i--) {
    if (!SdVolume::cacheZeroBlock(block + i - 1)) return false;
  }
  // Increase directory file size by cluster size
  fileSize_ += 512UL << vol_->clusterSizeShift_;
  return true;
}
//------------------------------------------------------------------------------
// cache a file's directory entry
// return pointer to cached entry or null for failure
dir_t* SdFile::cacheDirEntry(uint8_t action) {
  if (!SdVolume::cacheRawBlock(dirBlock_, action)) return NULL;
  return SdVolume::cacheBuffer_.dir + dirIndex_;
}
//------------------------------------------------------------------------------
/**
 *  Close a file and force cached data and directory information
 *  to be written to the storage device.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include no file is open or an I/O error.
 */
uint8_t SdFile::close(void) {
  if (!sync())return false;
  type_ = FAT_FILE_TYPE_CLOSED;
  return true;
}
//------------------------------------------------------------------------------
/**
 * Check for contiguous file and return its raw block range.
 *
 * \param[out] bgnBlock the first block address for the file.
 * \param[out] endBlock the last  block address for the file.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include file is not contiguous, file has zero length
 * or an I/O error occurred.
 */
uint8_t SdFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock) {
  // error if no blocks
  if (firstCluster_ == 0) return false;

  for (uint32_t c = firstCluster_; ; c++) {
    uint32_t next;
    if (!vol_->fatGet(c, &next)) return false;

    // check for contiguous
    if (next != (c + 1)) {
      // error if not end of chain
      if (!vol_->isEOC(next)) return false;
      *bgnBlock = vol_->clusterStartBlock(firstCluster_);
      *endBlock = vol_->clusterStartBlock(c)
                  + vol_->blocksPerCluster_ - 1;
      return true;
    }
  }
}
//------------------------------------------------------------------------------
/**
 * Create and open a new contiguous file of a specified size.
 *
 * \note This function only supports short DOS 8.3 names.
 * See open() for more information.
 *
 * \param[in] dirFile The directory where the file will be created.
 * \param[in] fileName A valid DOS 8.3 file name.
 * \param[in] size The desired file size.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include \a fileName contains
 * an invalid DOS 8.3 file name, the FAT volume has not been initialized,
 * a file is already open, the file already exists, the root
 * directory is full or an I/O error.
 *
 */
uint8_t SdFile::createContiguous(SdFile* dirFile,
        const char* fileName, uint32_t size) {
  // don't allow zero length file
  if (size == 0) return false;
  if (!open(dirFile, fileName, O_CREAT | O_EXCL | O_RDWR)) return false;

  // calculate number of clusters needed
  uint32_t count = ((size - 1) >> (vol_->clusterSizeShift_ + 9)) + 1;

  // allocate clusters
  if (!vol_->allocContiguous(count, &firstCluster_)) {
    remove();
    return false;
  }
  fileSize_ = size;

  // insure sync() will update dir entry
  flags_ |= F_FILE_DIR_DIRTY;
  return sync();
}
//------------------------------------------------------------------------------
/**
 * Return a files directory entry
 *
 * \param[out] dir Location for return of the files directory entry.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 */
uint8_t SdFile::dirEntry(dir_t* dir) {
  // make sure fields on SD are correct
  if (!sync()) return false;

  // read entry
  dir_t* p = cacheDirEntry(SdVolume::CACHE_FOR_READ);
  if (!p) return false;

  // copy to caller's struct
  memcpy(dir, p, sizeof(dir_t));
  return true;
}
//------------------------------------------------------------------------------
/**
 * Format the name field of \a dir into the 13 byte array
 * \a name in standard 8.3 short name format.
 *
 * \param[in] dir The directory structure containing the name.
 * \param[out] name A 13 byte char array for the formatted name.
 */
void SdFile::dirName(const dir_t& dir, char* name) {
  uint8_t j = 0;
  for (uint8_t i = 0; i < 11; i++) {
    if (dir.name[i] == ' ')continue;
    if (i == 8) name[j++] = '.';
    name[j++] = dir.name[i];
  }
  name[j] = 0;
}
//------------------------------------------------------------------------------
/** List directory contents to Serial.
 *
 * \param[in] flags The inclusive OR of
 *
 * LS_DATE - %Print file modification date
 *
 * LS_SIZE - %Print file size.
 *
 * LS_R - Recursive list of subdirectories.
 *
 * \param[in] indent Amount of space before file name. Used for recursive
 * list to indicate subdirectory level.
 */
void SdFile::ls(uint8_t flags, uint8_t indent) {
  dir_t* p;

  rewind();
  while ((p = readDirCache())) {
    // done if past last used entry
    if (p->name[0] == DIR_NAME_FREE) break;

    // skip deleted entry and entries for . and  ..
    if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') continue;

    // only list subdirectories and files
    if (!DIR_IS_FILE_OR_SUBDIR(p)) continue;

    // print any indent spaces
    //for (int8_t i = 0; i < indent; i++) Serial.print(' ');

    // print file name with possible blank fill
    printDirName(*p, flags & (LS_DATE | LS_SIZE) ? 14 : 0);

    // print modify date/time if requested
    if (flags & LS_DATE) {
       printFatDate(p->lastWriteDate);
       //Serial.print(' ');
       printFatTime(p->lastWriteTime);
    }
    // print size if requested
    if (!DIR_IS_SUBDIR(p) && (flags & LS_SIZE)) {
      //Serial.print(' ');
      //Serial.print(p->fileSize);
    }
    //Serial.println();

    // list subdirectory content if requested
    if ((flags & LS_R) && DIR_IS_SUBDIR(p)) {
      uint16_t index = curPosition()/32 - 1;
      SdFile s;
      if (s.open(this, index, O_READ)) s.ls(flags, indent + 2);
      seekSet(32 * (index + 1));
    }
  }
}
//------------------------------------------------------------------------------
// format directory name field from a 8.3 name string
uint8_t SdFile::make83Name(const char* str, uint8_t* name) {
  uint8_t c;
  uint8_t n = 7;  // max index for part before dot
  uint8_t i = 0;
  // blank fill name and extension
  while (i < 11) name[i++] = ' ';
  i = 0;
  while ((c = *str++) != '\0') {
    if (c == '.') {
      if (n == 10) return false;  // only one dot allowed
      n = 10;  // max index for full 8.3 name
      i = 8;   // place for extension
    } else {
      // illegal FAT characters
      uint8_t b;
#if defined(__AVR__)
      PGM_P p = PSTR("|<>^+=?/[];,*\"\\");
      while ((b = pgm_read_byte(p++))) if (b == c) return false;
#elif defined(__arm__)
      const uint8_t valid[] = "|<>^+=?/[];,*\"\\";
      const uint8_t *p = valid;
      while ((b = *p++)) if (b == c) return false;
#endif
      // check size and only allow ASCII printable characters
      if (i > n || c < 0X21 || c > 0X7E)return false;
      // only upper case allowed in 8.3 names - convert lower to upper
      name[i++] = c < 'a' || c > 'z' ?  c : c + ('A' - 'a');
    }
  }
  // must have a file name, extension is optional
  return name[0] != ' ';
}
//------------------------------------------------------------------------------
/** Make a new directory.
 *
 * \param[in] dir An open SdFat instance for the directory that will containing
 * the new directory.
 *
 * \param[in] dirName A valid 8.3 DOS name for the new directory.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include this SdFile is already open, \a dir is not a
 * directory, \a dirName is invalid or already exists in \a dir.
 */
uint8_t SdFile::makeDir(SdFile* dir, const char* dirName) {
  dir_t d;

  // create a normal file
  if (!open(dir, dirName, O_CREAT | O_EXCL | O_RDWR)) return false;

  // convert SdFile to directory
  flags_ = O_READ;
  type_ = FAT_FILE_TYPE_SUBDIR;

  // allocate and zero first cluster
  if (!addDirCluster())return false;

  // force entry to SD
  if (!sync()) return false;

  // cache entry - should already be in cache due to sync() call
  dir_t* p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
  if (!p) return false;

  // change directory entry  attribute
  p->attributes = DIR_ATT_DIRECTORY;

  // make entry for '.'
  memcpy(&d, p, sizeof(d));
  for (uint8_t i = 1; i < 11; i++) d.name[i] = ' ';
  d.name[0] = '.';

  // cache block for '.'  and '..'
  uint32_t block = vol_->clusterStartBlock(firstCluster_);
  if (!SdVolume::cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) return false;

  // copy '.' to block
  memcpy(&SdVolume::cacheBuffer_.dir[0], &d, sizeof(d));

  // make entry for '..'
  d.name[1] = '.';
  if (dir->isRoot()) {
    d.firstClusterLow = 0;
    d.firstClusterHigh = 0;
  } else {
    d.firstClusterLow = dir->firstCluster_ & 0XFFFF;
    d.firstClusterHigh = dir->firstCluster_ >> 16;
  }
  // copy '..' to block
  memcpy(&SdVolume::cacheBuffer_.dir[1], &d, sizeof(d));

  // set position after '..'
  curPosition_ = 2 * sizeof(d);

  // write first block
  return SdVolume::cacheFlush();
}
//------------------------------------------------------------------------------
/**
 * Open a file or directory by name.
 *
 * \param[in] dirFile An open SdFat instance for the directory containing the
 * file to be opened.
 *
 * \param[in] fileName A valid 8.3 DOS name for a file to be opened.
 *
 * \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
 * OR of flags from the following list
 *
 * O_READ - Open for reading.
 *
 * O_RDONLY - Same as O_READ.
 *
 * O_WRITE - Open for writing.
 *
 * O_WRONLY - Same as O_WRITE.
 *
 * O_RDWR - Open for reading and writing.
 *
 * O_APPEND - If set, the file offset shall be set to the end of the
 * file prior to each write.
 *
 * O_CREAT - If the file exists, this flag has no effect except as noted
 * under O_EXCL below. Otherwise, the file shall be created
 *
 * O_EXCL - If O_CREAT and O_EXCL are set, open() shall fail if the file exists.
 *
 * O_SYNC - Call sync() after each write.  This flag should not be used with
 * write(uint8_t), write_P(PGM_P), writeln_P(PGM_P), or the Arduino Print class.
 * These functions do character at a time writes so sync() will be called
 * after each byte.
 *
 * O_TRUNC - If the file exists and is a regular file, and the file is
 * successfully opened and is not read only, its length shall be truncated to 0.
 *
 * \note Directory files must be opened read only.  Write and truncation is
 * not allowed for directory files.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include this SdFile is already open, \a difFile is not
 * a directory, \a fileName is invalid, the file does not exist
 * or can't be opened in the access mode specified by oflag.
 */
uint8_t SdFile::open(SdFile* dirFile, const char* fileName, uint8_t oflag) {
  uint8_t dname[11];
  dir_t* p;

  // error if already open
  if (isOpen())return false;

  if (!make83Name(fileName, dname)) return false;
  vol_ = dirFile->vol_;
  dirFile->rewind();

  // bool for empty entry found
  uint8_t emptyFound = false;

  // search for file
  while (dirFile->curPosition_ < dirFile->fileSize_) {
    uint8_t index = 0XF & (dirFile->curPosition_ >> 5);
    p = dirFile->readDirCache();
    if (p == NULL) return false;

    if (p->name[0] == DIR_NAME_FREE || p->name[0] == DIR_NAME_DELETED) {
      // remember first empty slot
      if (!emptyFound) {
        emptyFound = true;
        dirIndex_ = index;
        dirBlock_ = SdVolume::cacheBlockNumber_;
      }
      // done if no entries follow
      if (p->name[0] == DIR_NAME_FREE) break;
    } else if (!memcmp(dname, p->name, 11)) {
      // don't open existing file if O_CREAT and O_EXCL
      if ((oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) return false;

      // open found file
      return openCachedEntry(0XF & index, oflag);
    }
  }
  // only create file if O_CREAT and O_WRITE
  if ((oflag & (O_CREAT | O_WRITE)) != (O_CREAT | O_WRITE)) return false;

  // cache found slot or add cluster if end of file
  if (emptyFound) {
    p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
    if (!p) return false;
  } else {
    if (dirFile->type_ == FAT_FILE_TYPE_ROOT16) return false;

    // add and zero cluster for dirFile - first cluster is in cache for write
    if (!dirFile->addDirCluster()) return false;

    // use first entry in cluster
    dirIndex_ = 0;
    p = SdVolume::cacheBuffer_.dir;
  }
  // initialize as empty file
  memset(p, 0, sizeof(dir_t));
  memcpy(p->name, dname, 11);

  // set timestamps
  if (dateTime_) {
    // call user function
    dateTime_(&p->creationDate, &p->creationTime);
  } else {
    // use default date/time
    p->creationDate = FAT_DEFAULT_DATE;
    p->creationTime = FAT_DEFAULT_TIME;
  }
  p->lastAccessDate = p->creationDate;
  p->lastWriteDate = p->creationDate;
  p->lastWriteTime = p->creationTime;

  // force write of entry to SD
  if (!SdVolume::cacheFlush()) return false;

  // open entry in cache
  return openCachedEntry(dirIndex_, oflag);
}
//------------------------------------------------------------------------------
/**
 * Open a file by index.
 *
 * \param[in] dirFile An open SdFat instance for the directory.
 *
 * \param[in] index The \a index of the directory entry for the file to be
 * opened.  The value for \a index is (directory file position)/32.
 *
 * \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
 * OR of flags O_READ, O_WRITE, O_TRUNC, and O_SYNC.
 *
 * See open() by fileName for definition of flags and return values.
 *
 */
uint8_t SdFile::open(SdFile* dirFile, uint16_t index, uint8_t oflag) {
  // error if already open
  if (isOpen())return false;

  // don't open existing file if O_CREAT and O_EXCL - user call error
  if ((oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) return false;

  vol_ = dirFile->vol_;

  // seek to location of entry
  if (!dirFile->seekSet(32 * index)) return false;

  // read entry into cache
  dir_t* p = dirFile->readDirCache();
  if (p == NULL) return false;

  // error if empty slot or '.' or '..'
  if (p->name[0] == DIR_NAME_FREE ||
      p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
    return false;
  }
  // open cached entry
  return openCachedEntry(index & 0XF, oflag);
}
//------------------------------------------------------------------------------
// open a cached directory entry. Assumes vol_ is initializes
uint8_t SdFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
  // location of entry in cache
  dir_t* p = SdVolume::cacheBuffer_.dir + dirIndex;

  // write or truncate is an error for a directory or read-only file
  if (p->attributes & (DIR_ATT_READ_ONLY | DIR_ATT_DIRECTORY)) {
    if (oflag & (O_WRITE | O_TRUNC)) return false;
  }
  // remember location of directory entry on SD
  dirIndex_ = dirIndex;
  dirBlock_ = SdVolume::cacheBlockNumber_;

  // copy first cluster number for directory fields
  firstCluster_ = (uint32_t)p->firstClusterHigh << 16;
  firstCluster_ |= p->firstClusterLow;

  // make sure it is a normal file or subdirectory
  if (DIR_IS_FILE(p)) {
    fileSize_ = p->fileSize;
    type_ = FAT_FILE_TYPE_NORMAL;
  } else if (DIR_IS_SUBDIR(p)) {
    if (!vol_->chainSize(firstCluster_, &fileSize_)) return false;
    type_ = FAT_FILE_TYPE_SUBDIR;
  } else {
    return false;
  }
  // save open flags for read/write
  flags_ = oflag & (O_ACCMODE | O_SYNC | O_APPEND);

  // set to start of file
  curCluster_ = 0;
  curPosition_ = 0;

  // truncate file to zero length if requested
  if (oflag & O_TRUNC) return truncate(0);
  return true;
}
//------------------------------------------------------------------------------
/**
 * Open a volume's root directory.
 *
 * \param[in] vol The FAT volume containing the root directory to be opened.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include the FAT volume has not been initialized
 * or it a FAT12 volume.
 */
uint8_t SdFile::openRoot(SdVolume* vol) {
  // error if file is already open
  if (isOpen()) return false;

  if (vol->fatType() == 16) {
    type_ = FAT_FILE_TYPE_ROOT16;
    firstCluster_ = 0;
    fileSize_ = 32 * vol->rootDirEntryCount();
  } else if (vol->fatType() == 32) {
    type_ = FAT_FILE_TYPE_ROOT32;
    firstCluster_ = vol->rootDirStart();
    if (!vol->chainSize(firstCluster_, &fileSize_)) return false;
  } else {
    // volume is not initialized or FAT12
    return false;
  }
  vol_ = vol;
  // read only
  flags_ = O_READ;

  // set to start of file
  curCluster_ = 0;
  curPosition_ = 0;

  // root has no directory entry
  dirBlock_ = 0;
  dirIndex_ = 0;
  return true;
}
//------------------------------------------------------------------------------
/** %Print the name field of a directory entry in 8.3 format to Serial.
 *
 * \param[in] dir The directory structure containing the name.
 * \param[in] width Blank fill name if length is less than \a width.
 */
void SdFile::printDirName(const dir_t& dir, uint8_t width) {
  uint8_t w = 0;
  for (uint8_t i = 0; i < 11; i++) {
    if (dir.name[i] == ' ')continue;
    if (i == 8) {
      //Serial.print('.');
      w++;
    }
    //Serial.write(dir.name[i]);
    w++;
  }
  if (DIR_IS_SUBDIR(&dir)) {
    //Serial.print('/');
    w++;
  }
  while (w < width) {
    //Serial.print(' ');
    w++;
  }
}
//------------------------------------------------------------------------------
/** %Print a directory date field to Serial.
 *
 *  Format is yyyy-mm-dd.
 *
 * \param[in] fatDate The date field from a directory entry.
 */
void SdFile::printFatDate(uint16_t fatDate) {
  //Serial.print(FAT_YEAR(fatDate));
  //Serial.print('-');
  printTwoDigits(FAT_MONTH(fatDate));
  //Serial.print('-');
  printTwoDigits(FAT_DAY(fatDate));
}
//------------------------------------------------------------------------------
/** %Print a directory time field to Serial.
 *
 * Format is hh:mm:ss.
 *
 * \param[in] fatTime The time field from a directory entry.
 */
void SdFile::printFatTime(uint16_t fatTime) {
  printTwoDigits(FAT_HOUR(fatTime));
  //Serial.print(':');
  printTwoDigits(FAT_MINUTE(fatTime));
  //Serial.print(':');
  printTwoDigits(FAT_SECOND(fatTime));
}
//------------------------------------------------------------------------------
/** %Print a value as two digits to Serial.
 *
 * \param[in] v Value to be printed, 0 <= \a v <= 99
 */
void SdFile::printTwoDigits(uint8_t v) {
  char str[3];
  str[0] = '0' + v/10;
  str[1] = '0' + v % 10;
  str[2] = 0;
 // Serial.print(str);
}
//------------------------------------------------------------------------------
/**
 * Read data from a file starting at the current position.
 *
 * \param[out] buf Pointer to the location that will receive the data.
 *
 * \param[in] nbyte Maximum number of bytes to read.
 *
 * \return For success read() returns the number of bytes read.
 * A value less than \a nbyte, including zero, will be returned
 * if end of file is reached.
 * If an error occurs, read() returns -1.  Possible errors include
 * read() called before a file has been opened, corrupt file system
 * or an I/O error occurred.
 */
int16_t SdFile::read(void* buf, uint16_t nbyte) {
  uint8_t* dst = reinterpret_cast<uint8_t*>(buf);

  // error if not open or write only
  if (!isOpen() || !(flags_ & O_READ)) return -1;

  // max bytes left in file
  if (nbyte > (fileSize_ - curPosition_)) nbyte = fileSize_ - curPosition_;

  // amount left to read
  uint16_t toRead = nbyte;
  while (toRead > 0) {
    uint32_t block;  // raw device block number
    uint16_t offset = curPosition_ & 0X1FF;  // offset in block
    if (type_ == FAT_FILE_TYPE_ROOT16) {
      block = vol_->rootDirStart() + (curPosition_ >> 9);
    } else {
      uint8_t blockOfCluster = vol_->blockOfCluster(curPosition_);
      if (offset == 0 && blockOfCluster == 0) {
        // start of new cluster
        if (curPosition_ == 0) {
          // use first cluster in file
          curCluster_ = firstCluster_;
        } else {
          // get next cluster from FAT
          if (!vol_->fatGet(curCluster_, &curCluster_)) return -1;
        }
      }
      block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
    }
    uint16_t n = toRead;

    // amount to be read from current block
    if (n > (512 - offset)) n = 512 - offset;

    // no buffering needed if n == 512 or user requests no buffering
    if ((unbufferedRead() || n == 512) &&
      block != SdVolume::cacheBlockNumber_) {
      if (!vol_->readData(block, offset, n, dst)) return -1;
      dst += n;
    } else {
      // read block to cache and copy data to caller
      if (!SdVolume::cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) return -1;
      uint8_t* src = SdVolume::cacheBuffer_.data + offset;
      uint8_t* end = src + n;
      while (src != end) *dst++ = *src++;
    }
    curPosition_ += n;
    toRead -= n;
  }
  return nbyte;
}
//------------------------------------------------------------------------------
/**
 * Read the next directory entry from a directory file.
 *
 * \param[out] dir The dir_t struct that will receive the data.
 *
 * \return For success readDir() returns the number of bytes read.
 * A value of zero will be returned if end of file is reached.
 * If an error occurs, readDir() returns -1.  Possible errors include
 * readDir() called before a directory has been opened, this is not
 * a directory file or an I/O error occurred.
 */
int8_t SdFile::readDir(dir_t* dir) {
  int8_t n;
  // if not a directory file or miss-positioned return an error
  if (!isDir() || (0X1F & curPosition_)) return -1;

  while ((n = read(dir, sizeof(dir_t))) == sizeof(dir_t)) {
    // last entry if DIR_NAME_FREE
    if (dir->name[0] == DIR_NAME_FREE) break;
    // skip empty entries and entry for .  and ..
    if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') continue;
    // return if normal file or subdirectory
    if (DIR_IS_FILE_OR_SUBDIR(dir)) return n;
  }
  // error, end of file, or past last entry
  return n < 0 ? -1 : 0;
}
//------------------------------------------------------------------------------
// Read next directory entry into the cache
// Assumes file is correctly positioned
dir_t* SdFile::readDirCache(void) {
  // error if not directory
  if (!isDir()) return NULL;

  // index of entry in cache
  uint8_t i = (curPosition_ >> 5) & 0XF;

  // use read to locate and cache block
  if (read() < 0) return NULL;

  // advance to next entry
  curPosition_ += 31;

  // return pointer to entry
  return (SdVolume::cacheBuffer_.dir + i);
}
//------------------------------------------------------------------------------
/**
 * Remove a file.
 *
 * The directory entry and all data for the file are deleted.
 *
 * \note This function should not be used to delete the 8.3 version of a
 * file that has a long name. For example if a file has the long name
 * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include the file read-only, is a directory,
 * or an I/O error occurred.
 */
uint8_t SdFile::remove(void) {
  // free any clusters - will fail if read-only or directory
  if (!truncate(0)) return false;

  // cache directory entry
  dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
  if (!d) return false;

  // mark entry deleted
  d->name[0] = DIR_NAME_DELETED;

  // set this SdFile closed
  type_ = FAT_FILE_TYPE_CLOSED;

  // write entry to SD
  return SdVolume::cacheFlush();
}
//------------------------------------------------------------------------------
/**
 * Remove a file.
 *
 * The directory entry and all data for the file are deleted.
 *
 * \param[in] dirFile The directory that contains the file.
 * \param[in] fileName The name of the file to be removed.
 *
 * \note This function should not be used to delete the 8.3 version of a
 * file that has a long name. For example if a file has the long name
 * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include the file is a directory, is read only,
 * \a dirFile is not a directory, \a fileName is not found
 * or an I/O error occurred.
 */
uint8_t SdFile::remove(SdFile* dirFile, const char* fileName) {
  SdFile file;
  if (!file.open(dirFile, fileName, O_WRITE)) return false;
  return file.remove();
}
//------------------------------------------------------------------------------
/** Remove a directory file.
 *
 * The directory file will be removed only if it is empty and is not the
 * root directory.  rmDir() follows DOS and Windows and ignores the
 * read-only attribute for the directory.
 *
 * \note This function should not be used to delete the 8.3 version of a
 * directory that has a long name. For example if a directory has the
 * long name "New folder" you should not delete the 8.3 name "NEWFOL~1".
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include the file is not a directory, is the root
 * directory, is not empty, or an I/O error occurred.
 */
uint8_t SdFile::rmDir(void) {
  // must be open subdirectory
  if (!isSubDir()) return false;

  rewind();

  // make sure directory is empty
  while (curPosition_ < fileSize_) {
    dir_t* p = readDirCache();
    if (p == NULL) return false;
    // done if past last used entry
    if (p->name[0] == DIR_NAME_FREE) break;
    // skip empty slot or '.' or '..'
    if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') continue;
    // error not empty
    if (DIR_IS_FILE_OR_SUBDIR(p)) return false;
  }
  // convert empty directory to normal file for remove
  type_ = FAT_FILE_TYPE_NORMAL;
  flags_ |= O_WRITE;
  return remove();
}
//------------------------------------------------------------------------------
/** Recursively delete a directory and all contained files.
 *
 * This is like the Unix/Linux 'rm -rf *' if called with the root directory
 * hence the name.
 *
 * Warning - This will remove all contents of the directory including
 * subdirectories.  The directory will then be removed if it is not root.
 * The read-only attribute for files will be ignored.
 *
 * \note This function should not be used to delete the 8.3 version of
 * a directory that has a long name.  See remove() and rmDir().
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 */
uint8_t SdFile::rmRfStar(void) {
  rewind();
  while (curPosition_ < fileSize_) {
    SdFile f;

    // remember position
    uint16_t index = curPosition_/32;

    dir_t* p = readDirCache();
    if (!p) return false;

    // done if past last entry
    if (p->name[0] == DIR_NAME_FREE) break;

    // skip empty slot or '.' or '..'
    if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') continue;

    // skip if part of long file name or volume label in root
    if (!DIR_IS_FILE_OR_SUBDIR(p)) continue;

    if (!f.open(this, index, O_READ)) return false;
    if (f.isSubDir()) {
      // recursively delete
      if (!f.rmRfStar()) return false;
    } else {
      // ignore read-only
      f.flags_ |= O_WRITE;
      if (!f.remove()) return false;
    }
    // position to next entry if required
    if (curPosition_ != (32u*(index + 1))) {
      if (!seekSet(32u*(index + 1))) return false;
    }
  }
  // don't try to delete root
  if (isRoot()) return true;
  return rmDir();
}
//------------------------------------------------------------------------------
/**
 * Sets a file's position.
 *
 * \param[in] pos The new position in bytes from the beginning of the file.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 */
uint8_t SdFile::seekSet(uint32_t pos) {
  // error if file not open or seek past end of file
  if (!isOpen() || pos > fileSize_) return false;

  if (type_ == FAT_FILE_TYPE_ROOT16) {
    curPosition_ = pos;
    return true;
  }
  if (pos == 0) {
    // set position to start of file
    curCluster_ = 0;
    curPosition_ = 0;
    return true;
  }
  // calculate cluster index for cur and new position
  uint32_t nCur = (curPosition_ - 1) >> (vol_->clusterSizeShift_ + 9);
  uint32_t nNew = (pos - 1) >> (vol_->clusterSizeShift_ + 9);

  if (nNew < nCur || curPosition_ == 0) {
    // must follow chain from first cluster
    curCluster_ = firstCluster_;
  } else {
    // advance from curPosition
    nNew -= nCur;
  }
  while (nNew--) {
    if (!vol_->fatGet(curCluster_, &curCluster_)) return false;
  }
  curPosition_ = pos;
  return true;
}
//------------------------------------------------------------------------------
/**
 * The sync() call causes all modified data and directory fields
 * to be written to the storage device.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include a call to sync() before a file has been
 * opened or an I/O error.
 */
uint8_t SdFile::sync(void) {
  // only allow open files and directories
  if (!isOpen()) return false;

  if (flags_ & F_FILE_DIR_DIRTY) {
    dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
    if (!d) return false;

    // do not set filesize for dir files
    if (!isDir()) d->fileSize = fileSize_;

    // update first cluster fields
    d->firstClusterLow = firstCluster_ & 0XFFFF;
    d->firstClusterHigh = firstCluster_ >> 16;

    // set modify time if user supplied a callback date/time function
    if (dateTime_) {
      dateTime_(&d->lastWriteDate, &d->lastWriteTime);
      d->lastAccessDate = d->lastWriteDate;
    }
    // clear directory dirty
    flags_ &= ~F_FILE_DIR_DIRTY;
  }
  return SdVolume::cacheFlush();
}
//------------------------------------------------------------------------------
/**
 * Set a file's timestamps in its directory entry.
 *
 * \param[in] flags Values for \a flags are constructed by a bitwise-inclusive
 * OR of flags from the following list
 *
 * T_ACCESS - Set the file's last access date.
 *
 * T_CREATE - Set the file's creation date and time.
 *
 * T_WRITE - Set the file's last write/modification date and time.
 *
 * \param[in] year Valid range 1980 - 2107 inclusive.
 *
 * \param[in] month Valid range 1 - 12 inclusive.
 *
 * \param[in] day Valid range 1 - 31 inclusive.
 *
 * \param[in] hour Valid range 0 - 23 inclusive.
 *
 * \param[in] minute Valid range 0 - 59 inclusive.
 *
 * \param[in] second Valid range 0 - 59 inclusive
 *
 * \note It is possible to set an invalid date since there is no check for
 * the number of days in a month.
 *
 * \note
 * Modify and access timestamps may be overwritten if a date time callback
 * function has been set by dateTimeCallback().
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 */
uint8_t SdFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
         uint8_t day, uint8_t hour, uint8_t minute, uint8_t second) {
  if (!isOpen()
    || year < 1980
    || year > 2107
    || month < 1
    || month > 12
    || day < 1
    || day > 31
    || hour > 23
    || minute > 59
    || second > 59) {
      return false;
  }
  dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
  if (!d) return false;

  uint16_t dirDate = FAT_DATE(year, month, day);
  uint16_t dirTime = FAT_TIME(hour, minute, second);
  if (flags & T_ACCESS) {
    d->lastAccessDate = dirDate;
  }
  if (flags & T_CREATE) {
    d->creationDate = dirDate;
    d->creationTime = dirTime;
    // seems to be units of 1/100 second not 1/10 as Microsoft states
    d->creationTimeTenths = second & 1 ? 100 : 0;
  }
  if (flags & T_WRITE) {
    d->lastWriteDate = dirDate;
    d->lastWriteTime = dirTime;
  }
  SdVolume::cacheSetDirty();
  return sync();
}
//------------------------------------------------------------------------------
/**
 * Truncate a file to a specified length.  The current file position
 * will be maintained if it is less than or equal to \a length otherwise
 * it will be set to end of file.
 *
 * \param[in] length The desired length for the file.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.
 * Reasons for failure include file is read only, file is a directory,
 * \a length is greater than the current file size or an I/O error occurs.
 */
uint8_t SdFile::truncate(uint32_t length) {
// error if not a normal file or read-only
  if (!isFile() || !(flags_ & O_WRITE)) return false;

  // error if length is greater than current size
  if (length > fileSize_) return false;

  // fileSize and length are zero - nothing to do
  if (fileSize_ == 0) return true;

  // remember position for seek after truncation
  uint32_t newPos = curPosition_ > length ? length : curPosition_;

  // position to last cluster in truncated file
  if (!seekSet(length)) return false;

  if (length == 0) {
    // free all clusters
    if (!vol_->freeChain(firstCluster_)) return false;
    firstCluster_ = 0;
  } else {
    uint32_t toFree;
    if (!vol_->fatGet(curCluster_, &toFree)) return false;

    if (!vol_->isEOC(toFree)) {
      // free extra clusters
      if (!vol_->freeChain(toFree)) return false;

      // current cluster is end of chain
      if (!vol_->fatPutEOC(curCluster_)) return false;
    }
  }
  fileSize_ = length;

  // need to update directory entry
  flags_ |= F_FILE_DIR_DIRTY;

  if (!sync()) return false;

  // set file to correct position
  return seekSet(newPos);
}
//------------------------------------------------------------------------------
/**
 * Write data to an open file.
 *
 * \note Data is moved to the cache but may not be written to the
 * storage device until sync() is called.
 *
 * \param[in] buf Pointer to the location of the data to be written.
 *
 * \param[in] nbyte Number of bytes to write.
 *
 * \return For success write() returns the number of bytes written, always
 * \a nbyte.  If an error occurs, write() returns 0.  Possible errors
 * include write() is called before a file has been opened, write is called
 * for a read-only file, device is full, a corrupt file system or an I/O error.
 *
 */
size_t SdFile::write(const void* buf, uint16_t nbyte) {
  // convert void* to uint8_t*  -  must be before goto statements
  const uint8_t* src = reinterpret_cast<const uint8_t*>(buf);

  // number of bytes left to write  -  must be before goto statements
  uint16_t nToWrite = nbyte;

  // error if not a normal file or is read-only
  if (!isFile() || !(flags_ & O_WRITE)) goto writeErrorReturn;

  // seek to end of file if append flag
  if ((flags_ & O_APPEND) && curPosition_ != fileSize_) {
    if (!seekEnd()) goto writeErrorReturn;
  }

  while (nToWrite > 0) {
    uint8_t blockOfCluster = vol_->blockOfCluster(curPosition_);
    uint16_t blockOffset = curPosition_ & 0X1FF;
    if (blockOfCluster == 0 && blockOffset == 0) {
      // start of new cluster
      if (curCluster_ == 0) {
        if (firstCluster_ == 0) {
          // allocate first cluster of file
          if (!addCluster()) goto writeErrorReturn;
        } else {
          curCluster_ = firstCluster_;
        }
      } else {
        uint32_t next;
        if (!vol_->fatGet(curCluster_, &next)) return false;
        if (vol_->isEOC(next)) {
          // add cluster if at end of chain
          if (!addCluster()) goto writeErrorReturn;
        } else {
          curCluster_ = next;
        }
      }
    }
    // max space in block
    uint16_t n = 512 - blockOffset;

    // lesser of space and amount to write
    if (n > nToWrite) n = nToWrite;

    // block for data write
    uint32_t block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
    if (n == 512) {
      // full block - don't need to use cache
      // invalidate cache if block is in cache
      if (SdVolume::cacheBlockNumber_ == block) {
        SdVolume::cacheBlockNumber_ = 0XFFFFFFFF;
      }
      if (!vol_->writeBlock(block, src)) goto writeErrorReturn;
      src += 512;
    } else {
      if (blockOffset == 0 && curPosition_ >= fileSize_) {
        // start of new block don't need to read into cache
        if (!SdVolume::cacheFlush()) goto writeErrorReturn;
        SdVolume::cacheBlockNumber_ = block;
        SdVolume::cacheSetDirty();
      } else {
        // rewrite part of block
        if (!SdVolume::cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) {
          goto writeErrorReturn;
        }
      }
      uint8_t* dst = SdVolume::cacheBuffer_.data + blockOffset;
      uint8_t* end = dst + n;
      while (dst != end) *dst++ = *src++;
    }
    nToWrite -= n;
    curPosition_ += n;
  }
  if (curPosition_ > fileSize_) {
    // update fileSize and insure sync will update dir entry
    fileSize_ = curPosition_;
    flags_ |= F_FILE_DIR_DIRTY;
  } else if (dateTime_ && nbyte) {
    // insure sync will update modified date and time
    flags_ |= F_FILE_DIR_DIRTY;
  }

  if (flags_ & O_SYNC) {
    if (!sync()) goto writeErrorReturn;
  }
  return nbyte;

 writeErrorReturn:
  // return for write error
  //writeError = true;
  setWriteError();
  return 0;
}
//------------------------------------------------------------------------------
/**
 * Write a byte to a file. Required by the Arduino Print class.
 *
 * Use SdFile::writeError to check for errors.
 */
size_t SdFile::write(uint8_t b) {
  return write(&b, 1);
}
//------------------------------------------------------------------------------
/**
 * Write a string to a file. Used by the Arduino Print class.
 *
 * Use SdFile::writeError to check for errors.
 */
size_t SdFile::write(const char* str) {
  return write(str, strlen(str));
}
#ifdef __AVR__
//------------------------------------------------------------------------------
/**
 * Write a PROGMEM string to a file.
 *
 * Use SdFile::writeError to check for errors.
 */
void SdFile::write_P(PGM_P str) {
  for (uint8_t c; (c = pgm_read_byte(str)); str++) write(c);
}
//------------------------------------------------------------------------------
/**
 * Write a PROGMEM string followed by CR/LF to a file.
 *
 * Use SdFile::writeError to check for errors.
 */
void SdFile::writeln_P(PGM_P str) {
  write_P(str);
  println();
}
#endif

SdFatUtil.h

/* Arduino SdFat Library
 * Copyright (C) 2008 by William Greiman
 *
 * This file is part of the Arduino SdFat Library
 *
 * This Library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This Library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with the Arduino SdFat Library.  If not, see
 * <http://www.gnu.org/licenses/>.
 */
#ifndef SdFatUtil_h
#define SdFatUtil_h
/**
 * \file
 * Useful utility functions.
 */
#include <Arduino.h>
#ifdef __AVR__
#include <avr/pgmspace.h>
/** Store and print a string in flash memory.*/
//#define PgmPrint(x) SerialPrint_P(PSTR(x))
/** Store and print a string in flash memory followed by a CR/LF.*/
//#define PgmPrintln(x) SerialPrintln_P(PSTR(x))
/** Defined so doxygen works for function definitions. */
#endif
#define NOINLINE __attribute__((noinline,unused))
#define UNUSEDOK __attribute__((unused))
//------------------------------------------------------------------------------
/** Return the number of bytes currently free in RAM. */
static UNUSEDOK int FreeRam(void) {
  extern int  __bss_end;
  extern int* __brkval;
  int free_memory;
  if (reinterpret_cast<int>(__brkval) == 0) {
    // if no heap use from end of bss section
    free_memory = reinterpret_cast<int>(&free_memory)
                  - reinterpret_cast<int>(&__bss_end);
  } else {
    // use from top of stack to heap
    free_memory = reinterpret_cast<int>(&free_memory)
                  - reinterpret_cast<int>(__brkval);
  }
  return free_memory;
}
#ifdef __AVR__
//------------------------------------------------------------------------------
/**
 * %Print a string in flash memory to the serial port.
 *
 * \param[in] str Pointer to string stored in flash memory.
 */
static NOINLINE void SerialPrint_P(PGM_P str) {
  //for (uint8_t c; (c = pgm_read_byte(str)); str++) Serial.write(c);
}
//------------------------------------------------------------------------------
/**
 * %Print a string in flash memory followed by a CR/LF.
 *
 * \param[in] str Pointer to string stored in flash memory.
 */
static NOINLINE void SerialPrintln_P(PGM_P str) {
  //SerialPrint_P(str);
  //Serial.println();
}
#endif  // __AVR__
#endif  // #define SdFatUtil_h

Огромное спасибо Вам за помощь!

Начну переделывать.

Здравстуйте все.

Довел я до рабочего состояния (с вашей помощью) свой скетч SavingDataToSD_PVA.

А как его сюда выкладывать в сжатом виде "показать код"?

Подключил обе I2C (дисплей и Часы) параллельно, работает.

Заменил библиотеку iarduino_RTC-1.2.1 на DS3231_RinkyDinky, работает, но и ее оранжево ругает.

Убрал все String-и. Съэкономить на библиотеке SD: SdFile.cpp и SdFatUtil.h не получилось - жестко ругается, вернул оригиналы.

Но, возникает какая-то ПЛАВАЮЩАЯ ОШИБКА.

Рабочая программа вдруг при включении не заходит под "if (Com_Serial.available()){..." типа не доступен порт

и уходит на " lcd.print("Com_NOT");"

Через некоторое время включаю - работает!

Скажите пожалуйста, могу я использовать вместо программного SoftwareSerial Com_Serial( 2, 3 ); // RX, TX аппаратный UART D0 и D1 ?

Например, сначала при пустых D0,D1 загрузить скетч с Компа в Ардуино Нано (т.к. микроUSB загружает через этот порт), а потом подсоединить RX от RS232_TTL к D0(Rx Нано) и TX к TX ?

Может так будет работать более устойчиво?

void *operator new(size_t size) {
  return malloc(size);
}

void *operator new[](size_t size) {
  return malloc(size);
}

void operator delete(void * ptr) {
  free(ptr);
}

void operator delete[](void * ptr) {
  free(ptr);
}

void setup() {
  char* p = (char *)malloc(1);
  free(p);
}

void loop() {}

void setup() {
  char* p = new char[1];
  delete[] p;
}

void loop() {}

И то я к тому что никакой нет разницы ;) 

void setup() {
  char* p = (char *)malloc(1);
  free(p);
}

void loop() {}

void setup() {
  char* p = new char[1];
  delete[] p;
}

void loop() {}

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

Это я к тому, что при таких сравнениях надо быть аккуратнее.

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

void setup() {
  char* p = (char *)malloc(1);
  Serial.begin(9600);
  *p = Serial.read();
  Serial.println(p);
  free(p);
}

void loop() {}

Скетч использует 2114 байт, переменные 198 байт

void setup() {
  char* p = new char[1];
  Serial.begin(9600);
  *p = Serial.read();
  Serial.println(p);
  delete[] p;
}

void loop() {}

скетч использует 2118 байт, переменные 198 байт

Как видим, разница уже не такая драматичная, как в вашем примере - всего 4 байта. Можно сказать, что ее практически нет.

Такого поворота от компилятора я и не ожидал )

В общем случае new имеет дополнительные (не связанные с выделением памяти) побочные эффекты, поэтому того факта, что запрошенная память не используется, недостаточно для безопасного удаления new. А malloc, кроме выделения, памяти никаких побочных эффектов не имеет.

 Плата Arduino Pro Mini

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

//#include <MemoryFree.h>   ----   ошибка компиляции
#include "MemoryExplorer.h"    -- тоже  ошибка компиляции

#include <avr/pgmspace.h>

Хотел поиграться с экономией памяти. Эти программы должны работать с моей платой? 

Полный скетч и полное сообщение об ошибке секретны?

Arduino: 1.8.2 (Windows 7), Плата:"Arduino Pro or Pro Mini, ATmega328P (5V, 16 MHz)"

E:\ФОТО Рё Р’Р?ДЕО РјРѕРёС… изделий\Sceth_drums_plyer2\Sceth_drums_plyer2.ino:19:28: fatal error: MemoryExplorer.h: No such file or directory

compilation terminated.

Несколько библиотек найдено для "Wire.h"
 Используется: C:\Users\User\Documents\Arduino\libraries\Wire
Не используется: C:\Users\User\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.20\libraries\Wire
Несколько библиотек найдено для "Adafruit_GFX.h"
 Используется: C:\Users\User\Documents\Arduino\libraries\Adafruit_GFX
Не используется: C:\Users\User\Documents\Arduino\libraries\Adafruit-GFX-Library-master
exit status 1
Ошибка компиляции для платы Arduino Pro or Pro Mini.
Неверная библиотека найдена в C:\Users\User\Documents\Arduino\libraries\i2cdevlib-master: C:\Users\User\Documents\Arduino\libraries\i2cdevlib-master
Неверная библиотека найдена в C:\Users\User\Documents\Arduino\libraries\i2cdevlib-master: C:\Users\User\Documents\Arduino\libraries\i2cdevlib-master

Этот отчёт будет иметь больше информации с
включенной опцией Файл -> Настройки ->
"Показать подробный вывод во время компиляции"

Значит, скетч по-прежнему секретен.

Ладно, смотрим на то, что есть. В строке №3 есть такая фраза: "MemoryExplorer.h: No such file or directory". Вам она что-нибудь говорит? Если нет, то я специально, для Вас, вставил её в гугл-переводчик. Получилось: "MemoryExplorer.h: нет такого файла или каталога".

Стало понятнее?

Нет библиотеки MemoryExplorer. Я полагал что он встроен в IDE. Потому что на гугл - ни одной ссылки на нее не выдает.

MemoryFree - аналогичная ошибка, хотя библа скачена, и успешно установилась. 

Она похожа на белого слона? Библиотека приведена в первом посте этой ветки. Чего её искать-то?

Значит, её нет (не туда установилась или ещё что). Если она по Вашему мнению есть, докажите это компилятору.

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

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

Задача такая. Сделал я железяку на Arduino Nano 328 + SD + LCD5110.

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

char myFileDir[16][13];

где 16 - максимальное кол-во видимых файлов, 13  длина в формате 8.3 + \0

char myFileDir[16][13]; // 16 файлов в списке длина 8.3 + '\0'

void Read_SD() {// имитируем заполнение массива при чтении карты
  // как тут объявить массив?
  String FileName;
  Serial.println(F("Read SD"));
  for (int ii = 0; ii < 16; ii++) {
    FileName = String("file") + String(ii, DEC) + ".txt" + '\0'; //  собираем имя файла 
    for (int i = 0; i < 13; i++) {
      if (FileName[i] == '\0') break;
      myFileDir[ii][i] = FileName[i]; // может можно как-то проще string запихнуть в массив char[][], 
    }
  }
}
void PrintFileName(int index) {
  Serial.println(F("Read File from SD"));
  String FileName = "FileNameRead: ";
  for (int i = 0; i < 12; i++) {
    FileName += myFileDir[index][i];
  }
  Serial.println(FileName);
  // как тут удалить весь массив myFileDir ?
}

void setup() {
  Serial.begin(115200);
  Serial.println(memoryFree(), DEC);
  Read_SD(); // имитируем чтение списка файлов с карты
  Serial.println(memoryFree(), DEC); // посмотрим память
  PrintFileName(5); //  печатаем имя файла на выбор
  Serial.println(memoryFree(), DEC); // посмотрим память
}

void loop() {

}

// Переменные, создаваемые процессом сборки,
// когда компилируется скетч
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;
}

Mizar,

Вы либо недостаточно внимательно прочитали материал, либо как-то "не до конца верите" в то, что там написано. Иначе бы у Вас не возникало вопросов типа:

ибо в материале чётко сказано, что "любая переменная, объявленная внутри пары фигурных скобок, видна только от точки объявления и до закрывающей скобки". Из этого правила нет исключений. Вот и ответьте сами, если Вы объявите свой массив внутри любой функции (хоть loop, хоть Read_SD), будет ли он виден из других функций?

Если Вы хотите, чтобы память под массив выделялась когда он нужен, а когда он больше не нужен - освобождалась, то Вам нужно объявлять не сам массив, а только указатель на него и делать явный запрос/освобождение памяти там, где это нужно (см. комментарий ниже).

Как именно объявить указатель на двумерный массив - это вопрос, ибо есть 100500 способов и ни один них не является "просто в лоб". Надо понимать, какой из способов Вам лучше подходит (какой Вы лучше понимаете, что там по ресурсам и т.п.). Мне трудно догадываться, что для Вас проще, а что сложнее. Если Вас интересует, как бы сделал я - я бы вообще не пользовался массивами, встроенными в язык, а определил бы класс с операциями доступа по индексу. На вид бы это выглядело бы неотличимо от двумерного массива. Но можно объявить двумерный массив и как прописано в языке - как массив одномерных. Вам как больше нравится?

И, да, в любом случае при запросе памяти необходимо проверять выделилась ли она.

Комментарий: такую схему (запрос - освобождение памяти) имеет смысл делать только тогда, когда Вы понимаете для чего Вам эта освобождённая память. Например, пока массив не нужен, Вы используете эту память под что-то другое. Если же нет и когда массив не нужен - она остаётся свободной, то нафига её освобождать? Только время на это тратить.

Спасибо за развернутый ответ.

то что объявляется внутри {},  помещается в стек и очищается при выходе, это  я понимаю и кое-что оптимизировал этим фокусом, за что отдельное спасибо.

но задача как раз и состоит в том. что бы в одном месте объявить, в другом очистить.

Процедура выделения памяти требуется единожды.

Далее идет процесс чтения файла с неизвестной длинной принимаемой строки. Тут и накладываются ограничения. Чем больше объявленный массив, тем больше можно построить список. (Возможно сама концепция навигации по карте памяти у меня изначально не верная, собрана на примерах, подумываю как бы это переделать. Экран маленький, список большой, его нужно прокручивать. Проще прокручивать массив, чем каждый раз перечитывать карту, то до середины, то с середины).

Далее идет чтение с карты, в строку String, которая растет с увеличением самой максимальной принимаемой строки. Протестировав разные файлы, я добился баланса между размером принимаемой строки и объявленными переменными. Массив со списком пришлось ограничить, что бы оставить запас (компилятор пишет занято 68%, в процессе работы  диагностика памяти показывает осталось не менее 215, но стоит принять строку большей длинны, память может внезапно закончиться. Поэтому за ненадобностью этого массива в дальнейшей работе, я и хотел его удалить.

С динамической памятью играть сложно, хотелки растут, а контролер нет. Я уже перебрал весь код, убрал все лишние String-и, объявил глобальные динамические переменные в самом конце, удалось высвободить почти 15% ресурсов.

Я так понимаю для моей задачи лучше использовать классы?

Или остается переделать файловый менеджер без массива.

Mizar, в первую очередь для вашей задачи лучше отказать от String и использовать символьные массивы