/* Вариант беспроводного соединения блока управления с исполнительным устройством. За основу взят последний проводной вариант Exolot_Var_2_2_3. Ардуино занимается только выводом информации на экран. Вся обработка импульсов производится WeMos, связанной с Исполнительным Устройством, передаётся по протоколу ESP-NOW на WeMos, связанную с Ардуино и далее по шине I2C на Ардуино. */ #include // библиотека для работы с дисплеем #include "Free_Fonts.h" // подключаемый файл #include // библиотека Arduino #include // библиотека #include #include // библиотека #include // библиотека TFT_HX8357 tft = TFT_HX8357(); // вызов пользовательской библиотеки #define CS 53 // вывод выбора карты памяти int ctrl0Pin = 54; // назначение вывода ctrl0Pin 4 импульса int ctrl1Pin = 55; // назначение вывода ctrl1Pin 8 импульсов int ctrl2Pin = 56; // назначение вывода ctrl2Pin 16 импульсов int ctrl3Pin = 57; // назначение вывода ctrl3Pin 0 - 12 В, 1 - 24 В int ctrl4Pin = 59; // назначение вывода ctrl4Pin коэф. усил х1 int ctrl5Pin = 60; // назначение вывода ctrl5Pin коэф. усил х6 int ctrl6Pin = 61; // назначение вывода ctrl6Pin коэф. усил х36 int ctrl7Pin = 62; // назначение вывода ctrl7Pin 0 - воздух, 1 - вода int ctrl8Pin = 63; // назначение вывода ctrl8Pin канал L4 int ctrl9Pin = 64; // назначение вывода ctrl9Pin канал L3 int ctrl10Pin = 65; // назначение вывода ctrl10Pin канал L2 int ctrl11Pin = 66; // назначение вывода ctrl11Pin канал L1 int ctrl12Pin = 67; // назначение вывода ctrl12Pin канал авто int ctrl13Pin = 68; // назначение вывода ctrl13Pin экран int analogPin = 69; // назначение вывода analogPin Uпит Ардуино int ind0Pin = 10; // назначение вывода ind0Pin 4 импульса int ind1Pin = 9; // назначение вывода ind1Pin 8 импульсов int ind2Pin = 8; // назначение вывода ind2Pin 16 импульсов int ind3Pin = 7; // назначение вывода ind3Pin коэф. усил х1 int ind4Pin = 6; // назначение вывода ind4Pin коэф. усил х6 int ind5Pin = 5; // назначение вывода ind5Pin коэф. усил х36 int ind6Pin = 4; // назначение вывода ind6Pin канал A L4 int ind7Pin = 3; // назначение вывода ind7Pin канал B L3 int ind8Pin = 2; // назначение вывода ind8Pin канал C L2 int ind9Pin = 14; // назначение вывода ind9Pin канал D L1 int ind10Pin = 15; // назначение вывода ind10Pin канал авто int Requout = 16; // назначение вывода запрос выход int indAPin = 13; // назначение вывода indA L4 (3500 mV) int indBPin = 12; // назначение вывода indB L3 (2500 mV) int indCPin = 18; // назначение вывода indC L2 (1000 mV) int indDPin = 19; // назначение вывода indD L1 (200 mV) int oscv; // указание верхней позиции y int oscn; // указание нижней позиции y int v(v=85); // указание счётчика строк v (начальное значение 85) int x = 0; // указатель предельного расстояния float m; // указание переменной с плавающей точкой m float mauto; // указание переменной с плавающей точкой m int mn; // указание предельного расстояния mn float md; // указание переменной с плавающей точкой md int mnA; // указание предельного расстояния mnA int mnB; // указание предельного расстояния mnB int mnC; // указание предельного расстояния mnC int mnd; // указание предельного расстояния mnd int mndauto; // указание предельного расстояния mndauto int vmn; // указание коэффициента vmn int dispm; // указание количества точек dispm int disp; // указание количества точек disp int dispp; // указание количества точек dispp uint16_t kolfile = 0; // количество файлов в каталоге uint16_t namefile = 0; // имя текущего файла uint16_t numzap = 0; // имя записываемого файла uint16_t numkat = 0; // имя каталога uint16_t maxfile = 0; // имя последнего записываемого файла uint16_t maxkat = 0; // имя последнего каталога float cm; // объявление переменной cm (расстояние в см) uint16_t duration; // объявление переменной duration - время до фронта uint16_t durmax; // объявление переменной durmax - максимальное время float voltage = 0.0; // объявление переменной voltage float analog = 0.0; // объявление переменной analog float voltage1 = 0.0; // объявление переменной voltage1 float analog1 = 0.0; // объявление переменной analog1 byte regkn1 = 0xFF; // регистр чтения кнопок управления исполнительным устройством byte regm1 = 0xC6; // регистр хранения режима управления исполнительным устройством byte regkn2 = 0xFF; // регистр чтения кнопок управления каналами byte regm2 = 0x3C; // регистр храннения режима управления каналами byte regkn = 0xFF; // рабочий регистр byte regout = 0x3A; // регистр выдачи на исполнительное устройство byte reg_IN = 0xFD; // регистр пина индикации byte rec_IN = 0xFF; // регистр пина индикации, принятый от ISP #define LOG_SIZE 10 // размер лога (LOG_SIZE ячеек) #define CHN_SIZE 4 // размер лога (CHN_SIZE массивов) #define KUS_SIZE 3 // размер лога (CHN_SIZE массивов) uint16_t durus[LOG_SIZE]; // массив измерений. Для текущего времени в момент изменения uint16_t durusauto[KUS_SIZE][CHN_SIZE][LOG_SIZE+5]; // массив измерений uint16_t durusread[KUS_SIZE][CHN_SIZE][LOG_SIZE+5]; // массив измерений int mnair[5] = {1, 2, 4, 8, 20}; int vmnair[5] = {18, 37, 73, 146, 370}; int mngraund[5] = {5, 10, 20, 40, 80}; int vmngraund[5] = {21, 42, 83, 167, 333}; uint32_t start; // Время старта uint32_t now; // Текущее машинное время в мкс uint32_t prevUs; // Предыдущее время изменения состояния пина uint32_t ekrnow; // Текущее машинное время в мкс uint32_t ekrpush; // время нажатия кнопки Экран uint32_t delnow; // Текущее машинное время в мкс uint32_t delpush; // время нажатия кнопок 0 и 1 uint32_t delfilenow; // Текущее машинное время в мкс uint32_t delfilepush; // время нажатия кнопок 0 и 2 uint32_t delkatnow; // Текущее машинное время в мкс uint32_t delkatpush; // время нажатия кнопки 2 uint32_t dispnow; // Текущее машинное время в мкс uint32_t disppush; // время нажатия кнопки 4 uint32_t newkatnow; // Текущее машинное время в мкс uint32_t newkatpush; // время нажатия кнопки 3 и 5 uint32_t decrnow; // Текущее машинное время в мкс uint32_t decrpush; // время нажатия кнопки 3 uint32_t mndecrnow; // Текущее машинное время в мкс uint32_t mndecrpush; // время нажатия кнопок 3 и 4 uint32_t incrnow; // Текущее машинное время в мкс uint32_t incrpush; // время нажатия кнопки 5 uint32_t mnincrnow; // Текущее машинное время в мкс uint32_t mnincrpush; // время нажатия кнопок 4 и 5 int IN_PIN; // Пин входа текущего канала int IND_PIN; // Пин индикации текущего канала uint16_t count = 0; // Счётчик циклов измерения bool first,prevS,flag,flerr = 0; // Первое, предыдущее состояние пина, флаг не первого измерения, флаг ошибки bool flagn = 0; // если 1, то пин в этом цикле прочитан bool airgnd; // 0 - пин на земле, 1 - висит в воздухе bool djmp; // бит переключателя DC bool zap = 0; // флаг режима записи (кнопка Экран) bool ekran; // флаг нажатия кнопки Экран bool screen; // флаг режима чтения каналов bool autonom; // флаг автономного режима bool delfileknt,delfileknp,delfilefl = 0; // предыдущее, текущее состояние кнопок 0 и 2 bool delknt,delknp,delfl = 0; // предыдущее, текущее состояние кнопки, флаг нажатия кнопок 0 и 1 bool delkatknt,delkatknp,delkatfl = 0; // предыдущее, текущее состояние кнопки, флаг нажатия кнопки 2 bool dispknt,dispknp,dispfl = 0; // предыдущее, текущее состояние кнопки, флаг нажатия кнопки 4 bool decrknt,decrknp,decrfl = 0; // предыдущее, текущее состояние кнопки, флаг нажатия кнопки 3 bool mndecrknt,mndecrknp,mndecrfl = 0; // предыдущее, текущее состояние кнопки, флаг нажатия кноп0к 3 и 4 bool incrknt,incrknp,incrfl = 0; // предыдущее, текущее состояние кнопки, флаг нажатия кнопки 5 bool mnincrknt,mnincrknp,mnincrfl = 0; // предыдущее, текущее состояние кнопки, флаг нажатия кнопок 4 и 5 bool newkatknt,newkatknp,newkatfl=0; // предыдущее, текущее состояние, флаг нажатия кнопок 3 и 5 bool flpush = 0; // флаг нажатия bool fluzap = 0; // флаг коэффициента усиления перед записью bool nocard = 0; // флаг отсутствия карты памяти bool readAUTO = 0; // флаг чтения из карты памяти всех каналов bool oscknp, oscknt, osc = 0; // предыдущее, текущее состояние кнопки, флаг режима осциллографа bool zapknp, zapknt, zapisy = 0; // предыдущее, текущее состояние кнопки, флаг процесса записи на карту памяти bool readknp,readknt,reading = 0; // предыдущее, текущее состояние кнопки, флаг режима чтения из карты памяти всех каналов bool readknpA,readkntA,readingA = 0; // предыдущее, текущее состояние кнопки, флаг чтения из карты памяти канала A bool readknpB,readkntB,readingB = 0; // предыдущее, текущее состояние кнопки, флаг чтения из карты памяти канала B bool readknpC,readkntC,readingC = 0; // предыдущее, текущее состояние кнопки, флаг чтения из карты памяти канала C bool readknpD,readkntD,readingD = 0; // предыдущее, текущее состояние кнопки, флаг чтения из карты памяти канала D volatile bool flagrec = 0; // флаг подтверждения приёма данных volatile bool flagrequ = 0; // флаг отправки запроса int k = 0; // Указатель текущего канала для чтения volatile uint16_t l = 0; // Указатель текущего номера передаваемого канала volatile uint16_t s = 0; // Указатель текущего номера принятого канала volatile uint16_t u = 0; // Указатель текущего коэффициента усиления uint16_t uzap = 0; // Указатель коэффициента усиления перед записью uint16_t p = 0; // Указатель длительности пачки импульсов uint16_t g = 0; // Указатель номера файла File myFile; File root; int f = 0; // создаём переменную-итератор char Bytes[10]; // создаём переменную для хранения байтов в формате char, char y = ""; void setup() { pinMode(ctrl0Pin, INPUT_PULLUP); // назначение вывода ctrl0 входом pinMode(ctrl1Pin, INPUT_PULLUP); // назначение вывода ctrl1 входом pinMode(ctrl2Pin, INPUT_PULLUP); // назначение вывода ctrl2 входом pinMode(ctrl3Pin, INPUT_PULLUP); // назначение вывода ctrl3 входом pinMode(ctrl4Pin, INPUT_PULLUP); // назначение вывода ctrl4 входом pinMode(ctrl5Pin, INPUT_PULLUP); // назначение вывода ctrl5 входом pinMode(ctrl6Pin, INPUT_PULLUP); // назначение вывода ctrl6 входом pinMode(ctrl7Pin, INPUT_PULLUP); // назначение вывода ctrl7 входом pinMode(ctrl8Pin, INPUT_PULLUP); // назначение вывода ctrl8 входом pinMode(ctrl9Pin, INPUT_PULLUP); // назначение вывода ctrl9 входом pinMode(ctrl10Pin, INPUT_PULLUP); // назначение вывода ctrl10 входом pinMode(ctrl11Pin, INPUT_PULLUP); // назначение вывода ctrl11 входом pinMode(ctrl12Pin, INPUT_PULLUP); // назначение вывода ctrl12 входом pinMode(ctrl13Pin, INPUT_PULLUP); // назначение вывода ctrl13 входом pinMode(analogPin, INPUT); // назначение вывода analogPin входом pinMode(ind0Pin, OUTPUT); // назначение вывода ind0 выходом pinMode(ind1Pin, OUTPUT); // назначение вывода ind1 выходом pinMode(ind2Pin, OUTPUT); // назначение вывода ind2 выходом pinMode(ind3Pin, OUTPUT); // назначение вывода ind3 выходом pinMode(ind4Pin, OUTPUT); // назначение вывода ind4 выходом pinMode(ind5Pin, OUTPUT); // назначение вывода ind5 выходом pinMode(ind6Pin, OUTPUT); // назначение вывода ind6 выходом pinMode(ind7Pin, OUTPUT); // назначение вывода ind7 выходом pinMode(ind8Pin, OUTPUT); // назначение вывода ind8 выходом pinMode(ind9Pin, OUTPUT); // назначение вывода ind9 выходом pinMode(ind10Pin, OUTPUT); // назначение вывода ind10 выходом pinMode(Requout, OUTPUT); // назначение вывода Reqout выходом pinMode(indAPin, OUTPUT); // назначение вывода indAPin выходом pinMode(indBPin, OUTPUT); // назначение вывода indBPin выходом pinMode(indCPin, OUTPUT); // назначение вывода indCPin выходом pinMode(indDPin, OUTPUT); // назначение вывода indDPin выходом // запись начального состояния digitalWrite(ind0Pin, LOW); // запись нуля в ind0 digitalWrite(ind1Pin, HIGH); // запись единицы в ind1 digitalWrite(ind2Pin, HIGH); // запись единицы в ind2 digitalWrite(ind3Pin, LOW); // запись нуля в ind3 digitalWrite(ind4Pin, HIGH); // запись единицы в ind4 digitalWrite(ind5Pin, HIGH); // запись единицы в ind5 digitalWrite(ind6Pin, LOW); // запись нуля в ind6 digitalWrite(ind7Pin, HIGH); // запись единицы в ind7 digitalWrite(ind8Pin, HIGH); // запись единицы в ind8 digitalWrite(ind9Pin, HIGH); // запись единицы в ind9 digitalWrite(ind10Pin, HIGH); // запись единицы в ind10 digitalWrite(Requout, HIGH); // запись единицы в Requout analogReference(INTERNAL2V56); Wire.begin(8); // задаем на шине i2c 8 адрес Wire.onReceive(receiveEvent); // регистрируем полученное событие Wire.onRequest(requestEvent); // регистрируем запрошенное событие //Serial.begin(115200); // открываем серийный порт для дебаггинга tft.begin(); // инициализациz TFT-экрана tft.setRotation(3); // альбомное расположение экрана tft.fillScreen(TFT_BLACK); // очистка экрана, цвет чёрный tft.setTextColor(TFT_YELLOW,TFT_BLACK); // жёлтый шрифт на чёрном фоне tft.setFreeFont(FSB24); // выбор фонта "Serif Bold 24pt" //Serial.print("Initializing SD card..."); // "Инициализация SD-карты..." if (!SD.begin(53)) { //Serial.println("initialization failed!"); // "инициализация не удалась!" nocard = 1; // флаг отсутствия карты памяти return; } //Serial.println("initialization done."); // "инициализация выполнена." autonom = !digitalRead(ctrl13Pin); // Чтение кнопки "экран" if (autonom == 1 ) { // если установлен процесс чтения всего массива zap = 1 ; // включение режима записи reading = 1; // включение режима чтения root = SD.open("/"); // открываем корневой каталог findemaxkat(root); // определяем имя последнего каталога root.close(); // закрываем корневой каталог numkat = maxkat; // текущее имя = имя последнего каталога root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла } impuls(); // обработка кнопок findkanal(); } void loop() { if (autonom == 1 ) { // если установлен процесс чтения всего массива zap = 1 ; // включение режима записи reading = 1; // включение режима чтения } // запрос на передачу и передача данных if (reading == 1 ) { // если установлен процесс чтения всего массива flagrequ = 1; // установка флага отправки запроса } if(flagrequ == 0){ // если запроса не было digitalWrite(Requout, HIGH); // запись единицы в Requout flagrequ = 1; // установка флага отправки запроса //printSendDate(); } // приём данных и запись их в массив //durusauto[KUS_SIZE=u][CHN_SIZE=l][LOG_SIZE+5] //за четыре прохода при различных l = номер канала if (reading == 1 ) { // если установлен процесс чтения всего массива flagrec = 0; // сброс флага приёма данных от ISP } if(flagrec == 1){ // ожидание приёма от WeMosArd delay (10); //printIncomingReadings(); if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO for (int i = 0; i < LOG_SIZE; i++) { durusauto[u][s][i] = durus[i]; } // переписываем принятый массив в durusauto[u][l] durusauto[u][s][LOG_SIZE] = duration; // записываем duration durusauto[u][s][LOG_SIZE+1] = count; // записываем count durusauto[u][s][LOG_SIZE+2] = l; // записываем канал durusauto[u][s][LOG_SIZE+3] = u; // записываем усиление durusauto[u][s][LOG_SIZE+4] = p; // записываем количество импульсов и DC flagrec = 0; // установка флага отправки запроса if (l == 3) { // проверяем канал, если 3 - вывод // запись файла на карту памяти массива // durusauto[KUS_SIZE=u][CHN_SIZE=l][LOG_SIZE+5] // три раза по четыре прохода при различных l = номер канала // при различных u = козффициент усиления if (zap == 1 ) { // Если установлен режим записи, if (zapisy == 1 ) { // Если установлен процесс записи, if (u < 2) { // если коэффициент не 36 - увеличиваем u = u + 1; // увеличиваем козффициент усиления flagrequ = 0; // сброс флага отправки запроса impuls(); // обработка кнопок } else { // если коэффициент 36 u = uzap; // восстанавливаем коэффициент усиления перед записью fluzap = 1; // установка флага записи k = 0; // канал A zapisy = 0 ; // сброс флага процесса записи flagrequ = 0; // сброс флага отправки запроса //printIncom(); //Serial.println("Запись на карту "); namefile = numzap; writeArrey(); // запись файла на карту памяти numzap = namefile + 1; impuls(); // обработка кнопок } } } flagrequ = 0; // сброс флага отправки запроса DispOut(); // вывод на дисплей } else { // если канал не 3 flagrequ = 0; // сброс флага отправки запроса DispOut(); } // вывод на дисплей } else { // если режим не AUTO flagrequ = 0; // сброс флага отправки запроса DispOut(); } // вывод на дисплей } // чтение всех файлов в каталоге карты памяти в память Ардуино // и вывод их на дисплей if (reading == 1 ) { // если установлен процесс чтения всего массива CardReading (); // чтение массива из карты памяти DispOut(); } } // Функция чтения массива из карты памяти и отпраки на дисплей void CardReading () { //Serial.println("void CardReading "); if ((!readAUTO && !readingA && !readingB && !readingC && !readingD) == 0 ) { // если установлен хотя бы один флаг чтения //Serial.println("Чтение карты "); tft.fillScreen(TFT_BLACK); // очистка экрана, цвет чёрный tft.setTextColor(TFT_YELLOW,TFT_BLACK); // жёлтый шрифт на чёрном фоне tft.setFreeFont(FSB24); // выбор фонта "Serif Bold 24pt" for (g = 0; g < maxfile ; g++) { // перебор файлов на карте памяти namefile = g; // имя текущего файла readArrey(); // чтение одного файла с карты памяти v = 85 + g; //printArrey(); if(screen == 0 ) { // если прошли последний файл for ( u = 0; u < 3; u++) { // перебор коэффициентов усиления OutReading(); // вывод на дисплей } } else { usildef(); // определение коэффициента усиления OutReading(); // вывод на дисплей } } } } // Функция для извлечения любых принимаемых данных от мастера на шину void receiveEvent (int howMany) { if (howMany >= (sizeof count) + (sizeof voltage1) + (sizeof duration) + (sizeof durus[LOG_SIZE])) { rec_IN = Wire.read(); count = Wire.read(); I2C_readAnything (voltage1); I2C_readAnything (duration); for (int i = 0; i < LOG_SIZE; i++) { I2C_readAnything(durus[i]); // принимаем каждый из LOG_SIZE элементов массива } initial(); if (reading == 0 ) { // если не установлен процесс чтения всего массива flagrec = 1; // установка флага приёма данных от ISP } } } // Функция для извлечения любых отправляемых данных от мастера на шину void requestEvent() { digitalWrite(Requout, LOW); // запись нуля в Requout Wire.write(regkn2); Wire.write(regm1); Wire.write(regm2); Wire.write(reg_IN); Wire.write(regout); } // Запись одного файла на карту памяти в память Ардуино // Массив содержит измерения расстояний для четырёх каналов // при трёх вариантах коэффициента усиления. Всего 12 измерений. void writeArrey(){ // если файла с именем "namefile.txt" - нет, то он будет создан. myFile = SD.open(String(numkat)+"/"+String(namefile)+".txt",FILE_WRITE); if(myFile){ // если файл доступен (открыт для записи), то ... for (int u = 0; u < 3; u++) { // перебираем коэффициент усиления for (int l = 0; l < 4; l++) { // перебираем каналы for (int i = 0; i < LOG_SIZE+5; i++) { myFile.println(durusauto[u][l][i]); // записываем массив на карту памяти } } } myFile.flush(); // закрываем файл myFile.close(); // закрываем файл } } // Функция для чтения одного файла с карты памяти в память Ардуино в массив durusread[h][i][j]. void readArrey(){ //Serial.println("Чтение с карты"); // Выводим текст в последовательный порт. myFile = SD.open(String(numkat)+"/"+String(namefile)+".txt"); // открываем файл для чения while(myFile.available()) for (int u = 0; u < 3; u++) { // перебираем коэффициент усиления for (int l = 0; l < 4; l++) { // перебираем каналы for (int i = 0; i < LOG_SIZE+5; i++) { while(myFile.available()&& // пока файл не закончился, ((Bytes[f] = myFile.read()) != '\n')) ++f; // читаем байты дальше до следующего символа новой строки, durusread[u][l][i] = atoi(Bytes); // конвертируем в int, f = 0; // сбрасываем итератор, } } } myFile.close(); // закрываем файл } // Функция для вывода на монитор данных, отправляемых Ардуино на WeMos, связанную с Исполнительным Устройством. /* void printSendDate(){ // Отображаем показания в мониторе порта Serial.println("SendDate "); Serial.print("regkn2 = "); Serial.println(regkn2); Serial.print("regm1 = "); Serial.println(regm1); Serial.print("regm2 = "); Serial.println(regm2); Serial.print("reg_IN = "); Serial.print(reg_IN); Serial.print(" = "); Serial.println(reg_IN, BIN); Serial.print("regout = "); Serial.println(regout); } // Функция для вывода на монитор данных, принимаемых Ардуино от WeMos, связанной с Исполнительным Устройством. void printIncomingReadings(){ Serial.println("ПРИЁМ_ОТ_ISP "); Serial.print("rec_IN = "); Serial.print(rec_IN); Serial.print(" = "); Serial.println(rec_IN, BIN); Serial.print("Канал "); Serial.println(s); Serial.print("count: "); Serial.println(count); Serial.print("voltage1: "); Serial.println(voltage1); Serial.print("duration: "); Serial.println(duration); Serial.println("durus"); for (int i = 0; i < LOG_SIZE; i++) { Serial.println(durus[i]); } } // Функция для вывода на монитор массива данных, записанных с карты памяти. void printArrey(){ Serial.println("Прочитанный массив "); for (int u = 0; u < 3; u++) { for (int l = 0; l < 4; l++) { Serial.print("Усиление: "); Serial.println(u); Serial.print("Канал "); Serial.println(l); Serial.println("durus: "); for (int i = 0; i < LOG_SIZE; i++) { Serial.println( durusread[u][l][i]); } Serial.print("duration "); Serial.println( durusread[u][l][LOG_SIZE]); Serial.print("count "); Serial.println( durusread[u][l][LOG_SIZE+1]); Serial.print("Канал "); Serial.println( durusread[u][l][LOG_SIZE+2]); Serial.print("Усиление "); Serial.println( durusread[u][l][LOG_SIZE+3]); Serial.print("Импульсов "); Serial.println( durusread[u][l][LOG_SIZE+4]); } } Serial.println(" "); Serial.println("Массив прочитан "); Serial.println(" "); } void printIncom(){ Serial.println("Принятый массив "); for (int u = 0; u < 3; u++) { for (int l = 0; l < 4; l++) { Serial.print("Усиление: "); Serial.println(u); Serial.print("Канал "); Serial.println(l); Serial.println("durus: "); for (int i = 0; i < LOG_SIZE; i++) { Serial.println( durusauto[u][l][i]); } Serial.print("duration "); Serial.println( durusauto[u][l][LOG_SIZE]); Serial.print("count "); Serial.println( durusauto[u][l][LOG_SIZE+1]); Serial.print("Канал "); Serial.println( durusauto[u][l][LOG_SIZE+2]); Serial.print("Усиление "); Serial.println( durusauto[u][l][LOG_SIZE+3]); Serial.print("Импульсов "); Serial.println( durusauto[u][l][LOG_SIZE+4]); } } Serial.println(" "); Serial.println("Массив прочитан "); Serial.println(" "); } */ // Функция для определения расстояния до точки отражения и предела шкалы на дисплее. void countcm() { airgnd = digitalRead(ctrl7Pin); // Чтение переключателя воздух / вода if (airgnd == 0){ // Если 0, то воздух cm = duration / 58; // Вычисление расстояния до объекта в воздухе в см и запись его в регистр if (cm <= 100) {(mn = 1); (vmn = 18);} // если расстояние меньше или равно 100, записываем 1 в mn else if (cm > 100 && cm <= 200) {(mn = 2); (vmn = 37);} // если расстояние больше 100, но меньше или равно 200, записываем 2 в mn else if (cm > 200 && cm <= 400) {(mn = 4); (vmn = 73);} // если расстояние больше 200, но меньше или равно 400, записываем 4 в mn else if (cm > 400 && cm <= 800) {(mn = 8); (vmn = 146);} // если расстояние больше 400, но меньше или равно 800, записываем 8 в mn else if (cm > 800 && cm <= 2000) {(mn = 20); (vmn = 370);} // если расстояние больше 800, но меньше или равно 2000, записываем 20 в mn m=(float)cm/100.0; // Запись в регистр m расстояния, делённого на 100 (перевод в метры) } else { // Если не 0, то вода cm = duration / 13; // Вычисление расстояния до объекта в воде и запись его в регистр if (cm <= 500) {(mn = 5); (vmn = 21);} // если расстояние меньше или равно 500, записываем 5 в mn else if (cm > 500 && cm <= 1000) {(mn = 10); (vmn = 42);} // если расстояние больше 500, но меньше или равно 1000, записываем 10 в mn else if (cm > 1000 && cm <= 2000) {(mn = 20); (vmn = 83);} // если расстояние больше 1000, но меньше или равно 2000, записываем 20 в mn else if (cm > 2000 && cm <= 4000) {(mn = 40); (vmn = 167);} // если расстояние больше 2000, но меньше или равно 4000, записываем 40 в mn else if (cm > 4000 && cm <= 8000) {(mn = 80); (vmn = 333);} // если расстояние больше 4000, но меньше или равно 8000, записываем 80 в mn m=(float)cm/100.0; // запись в регистр m расстояния, делённого на 100 (перевод в метры) } } // Функция для перебора каналов в режиме Auto при выводе на дисплей void OutReading() { if (readAUTO == 1 ){ // если установлен процесс чтения всего массива l = 0; // Устанавливаем канал D digitalWrite(ind9Pin, LOW); // запись единицы в indDPin reg_IN = 0xCF; // устанавливаем регистр пина D IND_PIN = indDPin; // Устанавливаем пин индикации канала A DispOut (); // вывод на дисплей digitalWrite(indDPin, HIGH); // запись единицы в indDPin digitalWrite(ind9Pin, HIGH); // запись единицы в indDPin l = 1; // Устанавливаем следующий канал digitalWrite(ind8Pin, LOW); // запись единицы в indDPin reg_IN = 0xD7; // устанавливаем бит канала C IND_PIN = indCPin; // Устанавливаем пин индикации канала A DispOut (); // вывод на дисплей digitalWrite(indCPin, HIGH); // запись единицы в indCPin digitalWrite(ind8Pin, HIGH); // запись единицы в indDPin l = 2; // Устанавливаем следующий канал digitalWrite(ind7Pin, LOW); // запись единицы в indDPin reg_IN = 0xDB; // устанавливаем бит канала B IND_PIN = indBPin; // Устанавливаем пин индикации канала A DispOut (); // вывод на дисплей digitalWrite(indBPin, HIGH); // запись единицы в indBPin digitalWrite(ind7Pin, HIGH); // запись единицы в indDPin l = 3; // Устанавливаем следующий канал digitalWrite(ind6Pin, LOW); // запись единицы в indDPin reg_IN = 0xDD; // устанавливаем бит канала A IND_PIN = indAPin; // Устанавливаем пин индикации канала A DispOut (); // вывод на дисплей digitalWrite(indAPin, HIGH); // запись единицы в indAPin digitalWrite(ind6Pin, HIGH); // запись единицы в indDPin } else { if (readingD == 1 ){ // если установлен процесс чтения всего массива l = 0; // Устанавливаем канал D digitalWrite(ind9Pin, LOW); // запись единицы в indDPin reg_IN = 0xCF; // устанавливаем регистр пина D IND_PIN = indDPin; // Устанавливаем пин индикации канала A DispOut (); // вывод на дисплей digitalWrite(indDPin, HIGH); // запись единицы в indDPin digitalWrite(ind9Pin, HIGH); } // запись единицы в indDPin if (readingC == 1 ) { // если установлен процесс чтения всего массива l = 1; // Устанавливаем следующий канал digitalWrite(ind8Pin, LOW); // запись единицы в indDPin reg_IN = 0xD7; // устанавливаем бит канала C IND_PIN = indCPin; // Устанавливаем пин индикации канала A DispOut (); // вывод на дисплей digitalWrite(indCPin, HIGH); // запись единицы в indCPin digitalWrite(ind8Pin, HIGH); } // запись единицы в indDPin if (readingB == 1 ) { // если установлен процесс чтения всего массива l = 2; // Устанавливаем следующий канал digitalWrite(ind7Pin, LOW); // запись единицы в indDPin reg_IN = 0xDB; // устанавливаем бит канала B IND_PIN = indBPin; // Устанавливаем пин индикации канала A DispOut (); // вывод на дисплей digitalWrite(indBPin, HIGH); // запись единицы в indBPin digitalWrite(ind7Pin, HIGH); } // запись единицы в indDPin if (readingA == 1 ) { // если установлен процесс чтения всего массива l = 3; // Устанавливаем следующий канал digitalWrite(ind6Pin, LOW); // запись единицы в indDPin reg_IN = 0xDD; // устанавливаем бит канала A IND_PIN = indAPin; // Устанавливаем пин индикации канала A DispOut (); // вывод на дисплей digitalWrite(indAPin, HIGH); // запись единицы в indAPin digitalWrite(ind6Pin, HIGH); } // запись единицы в indDPin } } // Обработка каналов в зависимости от режимов перед выводом на дисплей. // Вывод информации на дисплей. void DispOut() { analog = analogRead(analogPin); voltage = (analog*6.2) / 400; countcm(); if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO if (reading == 0 ){ // если не установлен процесс чтения всего массива // определяем максимальную длительность последнего импульса durmax = max(durusauto[u][0][LOG_SIZE],durusauto[u][1][LOG_SIZE]); durmax = max(durmax,durusauto[u][2][LOG_SIZE]); durmax = max(durmax,durusauto[u][3][LOG_SIZE]); duration = durmax; countcm(); mndauto = mn; // указание предельного расстояния mauto = m; // указание переменной с плавающей точкой for (int i = 0; i < LOG_SIZE; i++) { durus[i] = durusauto[u][l][i]; // переписываем принятый массив в durus[l] } duration = durusauto[u][l][LOG_SIZE]; // читаем duration count = durusauto[u][l][LOG_SIZE+1]; // читаем count } else { duration = durusread[u][l][LOG_SIZE]; // читаем duration countcm(); if (airgnd == 0){ // если воздух mn = mnair[x]; vmn = vmnair[x]; } else { // если грунт mn = mngraund[x]; vmn = vmngraund[x]; } mndauto = mn; // указание предельного расстояния mauto = m; // указание переменной с плавающей точкой for (int i = 0; i < LOG_SIZE; i++) { durus[i] = durusread[u][l][i]; // переписываем принятый массив в durus[l] durusread } duration = durusread[u][l][LOG_SIZE]; // читаем duration count = durusread[u][l][LOG_SIZE+1]; // читаем count } } if (duration != 0) { // если duration не рано нулю digitalWrite(IND_PIN, LOW); // Включаем светодиод текущего канала } if (bitRead(reg_IN, 5) == 1) { // проверяем пятый бит если 1 - SEPAR md = m; // указание переменной с плавающей точкой md mnd = mn; // указание предельного расстояния mnd } else { if (bitRead(reg_IN,1) == 0){ // если текущий канал A mnA = mndauto; } // указание предельного расстояния mnA else if (bitRead(reg_IN,2) == 0){ // если текущий канал B mnB = mndauto; } // указание предельного расстояния mnB else if (bitRead(reg_IN,3) == 0){ // если текущий канал C mnC = mndauto; } // указание предельного расстояния mnC else if (bitRead(reg_IN,4) == 0){ // если текущий канал D mnd = mndauto; } // указание предельного расстояния mnd if (reading == 1 ) { // если установлен процесс чтения всего массива mnd = mndauto; } // сброс флага приёма данных от ISP md = mauto; // указание переменной с плавающей точкой } // Вывод на дисплей tft.setTextColor(TFT_YELLOW,TFT_BLACK); // жёлтый шрифт на чёрном фоне tft.fillRect(0,0,82,50,TFT_BLACK); // запись на экран чёрного квадрата tft.setCursor(0,40); // установка курсора на указанные позиции {tft.print(md); } // вывод на экран содержимого регистра (m) tft.fillRect(0,270,82,50,TFT_BLACK); // запись на экран чёрного квадрата tft.setCursor(16,310); // установка курсора на указанные позиции {tft.print(mnd); } // вывод на экран содержимого регистра (mn) tft.drawLine(0,160,84,160,TFT_YELLOW ); // вывод на экран средней линии if (zap == 1 ) { // если установлен режим записи, if (reading == 1 ) { // если установлен режим чтения if (screen == 0 ) { // если не установлен флаг режима чтения tft.fillRect(0,156,84,7,TFT_GREEN); // запись на экран зелёного квадрата } else { // если установлен флаг режима чтения tft.fillRect(0,156,84,7,TFT_BLUE); // запись на экран синего квадрата } } else { // если не установлен режим чтения tft.fillRect(0,156,84,7,TFT_RED); // запись на экран красного квадрата } } else { tft.fillRect(0,156,84,7,TFT_BLACK); // запись на экран чёрного квадрата tft.drawLine(0,160,84,160,TFT_YELLOW); // вывод на экран средней линии } tft.drawLine(84, 0, 84,320,TFT_YELLOW); // вывод на экран вертикальной линии) tft.fillRect(0,100,82,50,TFT_BLACK); // запись на экран чёрного квадрата tft.setCursor(0,140); // установка курсора на указанные позиции if (voltage >= 7){ // если напряжение больше или равно 7 В tft.setTextColor(TFT_GREEN,TFT_BLACK); // зелёный шрифт на чёрном фоне tft.println(voltage,1); // вывод на экран напряжения зелёным цветом }else { // иначе - выводим красным цветом tft.setTextColor(TFT_RED,TFT_BLACK); // красный шрифт на чёрном фоне tft.println(voltage,1);} // вывод на экран напряжения красным цветом tft.fillRect(0,170,82,50,TFT_BLACK); // запись на экран чёрного квадрата tft.setCursor(0,210); // установка курсора на указанные позиции if (voltage1 >= 10.5){ // если напряжение больше или равно 10.5 В tft.setTextColor(TFT_GREEN,TFT_BLACK); // зелёный шрифт на чёрном фоне tft.println(voltage1,1); // вывод на экран напряжения зелёным цветом }else { // иначе - выводим красным цветом tft.setTextColor(TFT_RED,TFT_BLACK); // красный шрифт на чёрном фоне tft.println(voltage1,1); } // вывод на экран напряжения красным цветом tft.fillRect(0,50,82,50,TFT_BLACK); // запись на экран чёрного квадрата tft.fillRect(0,220,82,50,TFT_BLACK); // запись на экран чёрного квадрата if (zap == 1 ) { // Если установлен режим записи, tft.setTextColor(TFT_WHITE,TFT_BLACK); // жёлтый шрифт на чёрном фоне tft.setCursor(0,90); // установка курсора на указанные позиции {tft.print(numkat); } // вывод на экран имени каталока {tft.print("/"); } // вывод на экран черты каталока tft.setCursor(0,260); // установка курсора на указанные позиции {tft.print("/"); } // вывод на экран черты каталока if (kolfile == 0) { // если файлов больше нет {tft.print("0"); } // вывод на экран имени файла } else { if (reading == 0 ){ // если не установлен процесс чтения всего массива {tft.print(maxfile + 1); } // вывод на экран количества файлов } else { if ((!readAUTO && !readingA && !readingB && !readingC && !readingD) == 0 ) { // если установлен хотя бы один флаг чтения {tft.print(g + 1); } // вывод на экран номера выводимого файла } else { {tft.print(maxfile + 1); } // вывод на экран количества файлов } } } } if (osc == 1){ // если включён осциллограф tft.drawLine(85,240,460,240,TFT_YELLOW ); // вывод на экран нижней линии if (bitRead(reg_IN, 5) == 1) { // проверяем пятый бит 0 - AUTO, 1 - SEPAR tft.fillRect(85,242,460,78,TFT_BLACK); } // запись на экран чёрного квадрата vmn = vmn*1.3; } // укорачиваем вертикальную выдачу в1,3 раза for (int j = 0; j < count;) { if (j == 0){ disp = durus[j]/vmn; dispp = disp +2; if (bitRead(reg_IN,1) == 0){ // если текущий канал A if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO disp = disp*mnA/mndauto; dispp = disp +2; } tft.drawLine(v,dispp, v,disp,TFT_RED); // вывод на экран графика содержимого регистра (dispp) } else if (bitRead(reg_IN,2) == 0){ // если текущий канал B if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO disp = disp*mnB/mndauto; dispp = disp +2; } tft.drawLine(v,dispp, v,disp,TFT_YELLOW); // вывод на экран графика содержимого регистра (dispp) } else if (bitRead(reg_IN,3) == 0){ // если текущий канал C if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO disp = disp*mnC/mndauto; dispp = disp +2; } tft.drawLine(v,dispp, v,disp,TFT_GREEN); // вывод на экран графика содержимого регистра (dispp) } else if (bitRead(reg_IN,4) == 0){ // если текущий канал D if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO disp = disp*mnd/mndauto; dispp = disp +2; } tft.drawLine(v,dispp, v,disp,TFT_BLUE); // вывод на экран графика содержимого регистра (dispp) } if (osc == 1){ // если включён осциллограф disp = disp*1.5 + 85; dispp = dispp*1.5 + 85; oscv = 243; // указание верхней позиции y oscn = 317; // указание нижней позиции y if (bitRead(reg_IN,1) == 0){ // если текущий канал A if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит 0 - AUTO, 1 - SEPAR oscv = 243; // указание верхней позиции y oscn = 260; // указание нижней позиции y tft.fillRect(85,241,460,22,TFT_BLACK); } // запись на экран чёрного квадрата tft.drawLine(disp,oscn,85,oscn,TFT_RED); // вывод на экран нуля первого импульса tft.drawLine(disp,oscv,disp,oscn,TFT_RED); // вывод на экран фронта первого импульса tft.drawLine(dispp,oscv,disp,oscv,TFT_RED); // вывод на экран полочки первого импульса tft.drawLine(dispp,oscv,dispp,oscn,TFT_RED); // вывод на экран спада первого импульса if (count == 2) { // если счётчик равен 2 tft.drawLine(460,oscn,dispp,oscn,TFT_RED); } // вывод на экран нулевой линии до конца } else if (bitRead(reg_IN,2) == 0){ // если текущий канал B oscv = 263; // указание верхней позиции y if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит 0 - AUTO, 1 - SEPAR oscv = 263; // указание верхней позиции y oscn = 280; // указание нижней позиции y tft.fillRect(85,oscv,460,20,TFT_BLACK); } // запись на экран чёрного квадрата tft.drawLine(disp,oscn,85,oscn,TFT_YELLOW); // вывод на экран нуля первого импульса tft.drawLine(disp,oscv,disp,oscn,TFT_YELLOW); // вывод на экран фронта первого импульса tft.drawLine(dispp,oscv,disp,oscv,TFT_YELLOW); // вывод на экран полочки первого импульса tft.drawLine(dispp,oscv,dispp,oscn,TFT_YELLOW); // вывод на экран спада первого импульса if (count == 2) { // если счётчик равен 2 tft.drawLine(460,oscn,dispp,oscn,TFT_YELLOW); } // вывод на экран нулевой линии до конца } else if (bitRead(reg_IN,3) == 0){ // если текущий канал C oscv = 283; // указание верхней позиции y if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит 0 - AUTO, 1 - SEPAR oscv = 283; // указание верхней позиции y oscn = 300; // указание нижней позиции y tft.fillRect(85,oscv,460,20,TFT_BLACK); } // запись на экран чёрного квадрата tft.drawLine(disp,oscn,85,oscn,TFT_GREEN); // вывод на экран нуля первого импульса tft.drawLine(disp,oscv,disp,oscn,TFT_GREEN); // вывод на экран фронта первого импульса tft.drawLine(dispp,oscv,disp,oscv,TFT_GREEN); // вывод на экран полочки первого импульса tft.drawLine(dispp,oscv,dispp,oscn,TFT_GREEN); // вывод на экран спада первого импульса if (count == 2) { // если счётчик равен 2 tft.drawLine(460,oscn,dispp,oscn,TFT_GREEN); } // вывод на экран нулевой линии до конца } else if (bitRead(reg_IN,4) == 0){ // если текущий канал D oscv = 298; // указание верхней позиции y if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит 0 - AUTO, 1 - SEPAR oscv = 303; // указание верхней позиции y oscn = 317; // указание нижней позиции y tft.fillRect(85,oscv,460,20,TFT_BLACK); } // запись на экран чёрного квадрата tft.drawLine(disp,oscn,85,oscn,TFT_BLUE); // вывод на экран нуля первого импульса tft.drawLine(disp,oscv,disp,oscn,TFT_BLUE); // вывод на экран фронта первого импульса tft.drawLine(dispp,oscv,disp,oscv,TFT_BLUE); // вывод на экран полочки первого импульса tft.drawLine(dispp,oscv,dispp,oscn,TFT_BLUE); // вывод на экран спада первого импульса if (count == 2) { // если счётчик равен 2 tft.drawLine(460,oscn,dispp,oscn,TFT_BLUE); } // вывод на экран нулевой линии до конца } } j = j+2; } else { disp = durus[j]/vmn; dispp = disp +2; if (bitRead(reg_IN,1) == 0){ // если текущий канал A if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO disp = disp*mnA/mndauto; dispp = disp +2; } tft.drawLine(v,dispp, v,disp,TFT_RED); // вывод на экран графика содержимого регистра (disp) } else if (bitRead(reg_IN,2) == 0){ // если текущий канал B if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO disp = disp*mnB/mndauto; dispp = disp +2; } tft.drawLine(v,dispp, v,disp,TFT_YELLOW); } else if (bitRead(reg_IN,3) == 0){ // если текущий канал C if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO disp = disp*mnC/mndauto; dispp = disp +2; } tft.drawLine(v,dispp, v,disp,TFT_GREEN); } else if (bitRead(reg_IN,4) == 0){ // если текущий канал D if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO disp = disp*mnd/mndauto; dispp = disp +2; } tft.drawLine(v,dispp, v,disp,TFT_BLUE); } if (osc == 1){ // если включён осциллограф dispm = dispm*1.5 + 85; disp = disp*1.5 + 85; dispp = dispp*1.5 + 85; if (bitRead(reg_IN,1) == 0){ // если текущий канал A tft.drawLine(disp,oscn,dispm,oscn,TFT_RED); // вывод на экран нуля текущего импульса tft.drawLine(disp,oscv,disp,oscn,TFT_RED); // вывод на экран фронта первого импульса tft.drawLine(dispp,oscv,disp,oscv,TFT_RED); // вывод на экран полочки первого импульса tft.drawLine(dispp,oscv,dispp,oscn,TFT_RED); // вывод на экран спада первого импульса if (j == count - 2) { // если последнее измерение tft.drawLine(460,oscn,dispp,oscn,TFT_RED); } // вывод на экран нулевой линии до конца } else if (bitRead(reg_IN,2) == 0){ // если текущий канал B tft.drawLine(disp,oscn,dispm,oscn,TFT_YELLOW); // вывод на экран нуля текущего импульса tft.drawLine(disp,oscv,disp,oscn,TFT_YELLOW); // вывод на экран фронта первого импульса tft.drawLine(dispp,oscv,disp,oscv,TFT_YELLOW); // вывод на экран полочки первого импульса tft.drawLine(dispp,oscv,dispp,oscn,TFT_YELLOW); // вывод на экран спада первого импульса if (j == count - 2 ) { // если последнее измерение tft.drawLine(460,oscn,dispp,oscn,TFT_YELLOW); } // вывод на экран нулевой линии до конца } else if (bitRead(reg_IN,3) == 0){ // если текущий канал C tft.drawLine(disp,oscn,dispm,oscn,TFT_GREEN); // вывод на экран нуля текущего импульса tft.drawLine(disp,oscv,disp,oscn,TFT_GREEN); // вывод на экран фронта первого импульса tft.drawLine(dispp,oscv,disp,oscv,TFT_GREEN); // вывод на экран полочки первого импульса tft.drawLine(dispp,oscv,dispp,oscn,TFT_GREEN); // вывод на экран спада первого импульса if (j == count - 2 ) { // если последнее измерение tft.drawLine(460,oscn,dispp,oscn,TFT_GREEN); } // вывод на экран нулевой линии до конца } else if (bitRead(reg_IN,4) == 0){ // если текущий канал D tft.drawLine(disp,oscn,dispm,oscn,TFT_BLUE); // вывод на экран нуля текущего импульса tft.drawLine(disp,oscv,disp,oscn,TFT_BLUE); // вывод на экран фронта первого импульса tft.drawLine(dispp,oscv,disp,oscv,TFT_BLUE); // вывод на экран полочки первого импульса tft.drawLine(dispp,oscv,dispp,oscn,TFT_BLUE); // вывод на экран спада первого импульса if (j == count - 2 ) { // если последнее измерение tft.drawLine(460,oscn,dispp,oscn,TFT_BLUE); } // вывод на экран нулевой линии до конца } } j = j+2; } } if (reading == 0 ){ // если не установлен процесс чтения всего массива if (bitRead(reg_IN, 5) == 0) { // проверяем пятый бит если 0 - AUTO if (l == 3) { // проверяем канал, если 3 v = v + 1; // переход графика на следующую позицию } } else { v = v + 1; // переход графика на следующую позицию } } if (v == 460){ (v = 85); tft.fillScreen(TFT_BLACK); // очистка экрана, цвет чёрный tft.setTextColor(TFT_YELLOW,TFT_BLACK); // жёлтый шрифт на чёрном фоне tft.setFreeFont(FSB24); // выбор фонта "Serif Bold 24pt" } if (reading == 0 ){ // если не установлен процесс чтения всего массива impuls(); // обработка кнопок findkanal(); } else { knreadSD(); knreadSD(); impuls(); // обработка кнопок } } // Обработка нажатия кнопок и вывод на светодиодную индикацию. void impuls() { // Обработка кнопок // проверка кнопоки 10 на нажатие if (zap == 1 ) { // Если установлен режим записи, zapknt = digitalRead(ctrl12Pin); // Читаем текущее состояние пина if (zapknt == 0 ) { // Если 0, смотрим, первое чтение, или нет if (zapknp == 1 ) { // Если 1, первое чтение, if (reading == 0 ) { // если не режим чтения k = 0; // Устанавливаем PinD uzap = u; // запоминаем коэффициент усиления перед записью u = 0; // текущий коэффициент усиления = 1 root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла zapisy = 1; // устанавливаем флаг процесса записи на карту памяти } else { readAUTO = !readAUTO; // инвертируем флаг чтения всех каналов } } } zapknp = zapknt; // записываем текущее состояние кнопки в предыдущее } // проверка кнопок 0 - 10 на нажатие regkn1 = PINF; // чтение кнопок управления исполнительным устройством regkn2 = PINK; // чтение кнопок управления каналами // проверка кнопок 0 - 5 на нажатие, формирование регистра regout regkn = regkn1 | 0b00011000; // маскировка ненужных битов regkn = ~regkn; // инвертируем if (zap == 1 ) { // Если установлен режим записи, if (zapisy == 1 || fluzap == 1 ) { // Если установлен процесс записи, if (u == 0 ) { // Если установлен коэффициент 0, regkn = 0x20; // устанавливаем козффициент усиления х1 } else if (u == 1 ) { // Если установлен коэффициент 1, regkn = 0x40; // устанавливаем козффициент усиления х6 } else if (u == 2 ) { // Если установлен коэффициент 2,, regkn = 0x80; // устанавливаем козффициент усиления х36 } fluzap = 0; // сброс флага коэффициента усиления перед записью root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла } } if (regkn != 0) { // если есть нажатие кнопки if (bitRead(regkn, 0) == 1) { // проверяем нулевой бит - если есть нажатие кнопки 0 bitClear(regm1, 0); // запись нуля в ind0 bitSet(regm1, 1); // запись единицы в ind1 bitSet(regm1, 2); // запись единицы в ind2 bitSet(regout, 3); // запись единицы в A1T bitSet(regout, 5); // запись единицы в A0T p = 0; // длительность пачки импульсов 4 импульса } else // если нет нажатия кнопки 0 if (bitRead(regkn, 1) == 1) { // проверяем первый бит - если есть нажатие кнопки 1 bitSet(regm1, 0); // запись единицы в ind0 bitClear(regm1, 1); // запись нуля в ind1 bitSet(regm1, 2); // запись единицы в ind2 bitSet(regout, 3); // запись единицы в A1T bitClear(regout, 5); // запись нуля в A0T p = 1; // длительность пачки импульсов 8 импульсов } else // если нет нажатия кнопки 1 if (bitRead(regkn, 2) == 1) { // проверяем второй бит - если есть нажатие кнопки 2 bitSet(regm1, 0); // запись единицы в ind0 bitSet(regm1, 1); // запись единицы в ind1 bitClear(regm1, 2); // запись нуля в ind2 bitClear(regout, 3); // запись нуля в A1T bitSet(regout, 5); // запись единицы в A0T p = 2; // длительность пачки импульсов 16 импульсов } else // если нет нажатия кнопки 2 if (bitRead(regkn, 5) == 1) { // проверяем пятый бит - если есть нажатие кнопки 3 bitClear(regm1, 5); // запись нуля в ind3 bitSet(regm1, 6); // запись единицы в ind4 bitSet(regm1, 7); // запись единицы в ind5 bitSet(regout, 1); // запись единицы в A1R bitClear(regout, 2); // запись нуля в A0R u = 0; // текущий коэффициент усиления = 1 } else // если нет нажатия кнопки 3 if (bitRead(regkn, 6) == 1) { // проверяем шестой бит - если есть нажатие кнопки 4 bitSet(regm1, 5); // запись единицы в ind3 bitClear(regm1, 6); // запись нуля в ind4 bitSet(regm1, 7); // запись единицы в ind5 bitClear(regout, 1); // запись нуля в A1R bitSet(regout, 2); // запись единицы в A0R u = 1; // текущий коэффициент усиления = 6 } else // если нет нажатия кнопки 4 if (bitRead(regkn, 7) == 1) { // проверяем седьмой бит - если есть нажатие кнопки 5 bitSet(regm1, 5); // запись единицы в ind3 bitSet(regm1, 6); // запись единицы в ind4 bitClear(regm1, 7); // запись нуля в ind5 bitSet(regout, 1); // запись единицы в A1R bitSet(regout, 2); // запись единицы в A0R u = 2; // текущий коэффициент усиления = 36 } // включение светодиодов индикации режима digitalWrite(ind0Pin, bitRead(regm1, 0)); // запись состояния в ind0 digitalWrite(ind1Pin, bitRead(regm1, 1)); // запись состояния в ind1 digitalWrite(ind2Pin, bitRead(regm1, 2)); // запись состояния в ind2 digitalWrite(ind3Pin, bitRead(regm1, 5)); // запись состояния в ind3 digitalWrite(ind4Pin, bitRead(regm1, 6)); // запись состояния в ind4 digitalWrite(ind5Pin, bitRead(regm1, 7)); // запись состояния в ind5 } // если нет нажатия кнопок 0 - 5, сразу идём сюда djmp = bitRead(regkn1, 3); // чтение переключателя DC bitWrite(regout,4,!djmp); // запись состояния переключателя DC в DC bitWrite(regm1,4,djmp); // запись состояния переключателя DC в regm1 bitWrite(p,3,djmp); // запись состояния переключателя DC в p // проверка кнопоки 11 на нажатие oscknt = digitalRead(ctrl13Pin); // читаем текущее состояние пина if (oscknt == 0 ) { // если 0 - нажатие, смотрим, первое чтение, или нет if (oscknp == 1 ) { // если 1, первое чтение, ekrpush = millis(); // читаем текущее машинное время нажатия кнопки Экран ekran = 1; // установка флага нажатия кнопки Экран } else { // если не первое чтение, ekrnow = millis(); // читаем текущее машинное время в мс if (ekran && ekrnow - ekrpush >= 700) { // если есть флаг нажатия и время нажатия больше 0,7 сек if (reading == 1 ){ // если не установлен процесс чтения всего массива screen = !screen; // инвертируем флаг режима чтения ekran = 0; // сброс флага нажатия кнопки Экран } else { zap = !zap; // инвертируем флаг режима записи ekran = 0; // сброс флага нажатия кнопки Экран if (nocard == 1 ) { // если флаг отсутствия карты памяти zap = 0; // сбрасываем флаг режима записи tft.fillRect(0,156,84,7,TFT_RED); // запись на экран красного квадрата delay (1000); // задержка tft.fillRect(0,156,84,7,TFT_BLACK); // запись на экран чёрного квадрата tft.drawLine(0,160,84,160,TFT_YELLOW); // вывод на экран средней линии } else { if (zap == 1 ) { // если 1 root = SD.open("/"); // открываем корневой каталог findemaxkat(root); // определяем имя последнего каталога root.close(); // закрываем корневой каталог numkat = maxkat; // текущее имя = имя последнего каталога root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла ekran = 0; // сброс флага нажатия кнопки Экран } } } } } } else { // если 1 - нажатия нет, смотрим, нет ли отпускания if (oscknp == 0 ) { // если 0, - отжатие кнопли Экран if (ekran && !reading ) { // если флаг нажатия есть, значит 1 сек не прошло и это осциллограф osc = !osc; // инвертируем флаг осциллографа if (osc == 0 ) { // если выключение осциллографа, tft.drawLine(85,240,460,240,TFT_BLACK); // стирание на экране нижней линии tft.fillRect(85,242,460,78,TFT_BLACK); // запись на экран чёрного квадрата } ekran = 0; // сброс флага нажатия кнопки Экран } } if (reading == 1 ) { // если режим чтения osc = 0; } // выключаем осциллограф } oscknp = oscknt; // записываем текущее состояние кнопки в предыдущее // проверка кнопок 6 - 10 на нажатие regkn = regkn2 | 0b11000001; // маскировка ненужных битов regkn = ~regkn; // инвертируем if (zap == 1 ) { // Если установлен режим записи, regkn = 0x20; // устанавливаем режим Auto } if (regkn != 0) { // если есть нажатие кнопки regm2 = 0xFF; // устанавливаем все единицы в regm2 if (bitRead(regkn, 1) == 1) { // проверяем первый бит - если есть нажатие кнопки 6 bitClear(regm2, 1); } // запись нуля в ind6 else // если нет нажатия кнопки 6 if (bitRead(regkn, 2) == 1) { // проверяем второй бит - если есть нажатие кнопки 7 bitClear(regm2, 2); } // запись нуля в ind7 else // если нет нажатия кнопки 7 if (bitRead(regkn, 3) == 1) { // проверяем третий бит - если есть нажатие кнопки 8 bitClear(regm2, 3); } // запись нуля в ind8 else // если нет нажатия кнопки 8 if (bitRead(regkn, 4) == 1) { // проверяем четвёртый бит - если есть нажатие кнопки 9 bitClear(regm2, 4); } // запись нуля в ind9 else // если нет нажатия кнопки 10 if (bitRead(regkn, 5) == 1) { // проверяем пятый бит - если есть нажатие кнопки 10 bitClear(regm2, 5); } // запись нуля в ind10 // включение светодиодов индикации режима digitalWrite(ind6Pin, bitRead(regm2, 1)); // запись состояния в ind6 digitalWrite(ind7Pin, bitRead(regm2, 2)); // запись состояния в ind7 digitalWrite(ind8Pin, bitRead(regm2, 3)); // запись состояния в ind8 digitalWrite(ind9Pin, bitRead(regm2, 4)); // запись состояния в ind9 digitalWrite(ind10Pin, bitRead(regm2, 5)); // запись состояния в ind10 } // гашение светодиодов L1 - L4 digitalWrite(indAPin, HIGH); // запись единицы в indAPin digitalWrite(indBPin, HIGH); // запись единицы в indBPin digitalWrite(indCPin, HIGH); // запись единицы в indCPin digitalWrite(indDPin, HIGH); // запись единицы в indDPin if (zap == 1 ) { // Если установлен режим записи, // проверка кнопоки 0 на нажатие - удаление одного файла из каталога delknt = bitRead(regkn1,0); // Читаем текущее состояние кнопоки 0 if (delknt == 0 ) { // Если 0 - нажатие, смотрим, первое чтение, или нет if (delknp == 1 ) { // Если 1, первое чтение, delpush = millis(); // Читаем текущее машинное время нажатия кнопки 0 delfl = 1; // устанавливаем флаг нажатия } else { // Если не первое чтение, delnow = millis(); // Читаем текущее машинное время в мс if (delfl && delnow - delpush >= 500) { // Если есть флаг нажатия и время нажатия больше 0,5 сек namefile = maxfile; // текущее имя = имя последнего файла if (SD.exists(String(numkat)+"/"+ String(namefile)+".txt")){ // если есть такой файл SD.remove(String(numkat)+"/"+ String(namefile)+".txt"); // удаляем root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла delfl = 0; // сброс флага нажатия } } } } else { // если кнопку отжали if (delknp == 0 ) { // Если 1, первое чтение, delfl = 0; // сброс флага нажатия кнопки 0 } } delknp = delknt; // записываем текущее состояние кнопки в предыдущее // проверка кнопки 1 на нажатие - удаление всех файлов из текущего каталога карты памяти delfileknt = bitRead(regkn1,1); // Читаем текущее состояние кнопки 1 if (delfileknt == 0 ) { // Если 0 - нажатие, смотрим, первое чтение, или нет if (delfileknp == 1 ) { // Если 1, первое чтение, delfilepush = millis(); // Читаем текущее машинное время нажатия кнопки 1 delfilefl = 1; // устанавливаем флаг нажатия } else { // Если не первое чтение, delfilenow = millis(); // Читаем текущее машинное время в мс if (delfilefl && delfilenow - delfilepush >= 500) { // Если есть флаг нажатия и время нажатия больше 0,5 сек root = SD.open(String(numkat)+"/"); // открываем последний каталог deliteArrey(root); root.close(); // закрываем корневой каталог root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла delfilefl = 0; // сброс флага нажатия } } } else { // если кнопку отжали if (delfileknp == 0 ) { // Если 1, первое чтение, delfilefl = 0; // сброс флага нажатия кнопки 1 } } delfileknp = delfileknt; // записываем текущее состояние кнопки в предыдущее // проверка кнопки 2 на нажатие - удаление каталога delkatknt = bitRead(regkn1,2); // Читаем текущее состояние кнопки 2 if (delkatknt == 0 ) { // Если 0 - нажатие, смотрим, первое чтение, или нет if (delkatknp == 1 ) { // Если 1, первое чтение, delkatpush = millis(); // Читаем текущее машинное время нажатия кнопки 2 delkatfl = 1; // Установка флага нажатия кнопки 2 } else { // Если не первое чтение, delkatnow = millis(); // Читаем текущее машинное время в мс if (delkatfl && delkatnow - delkatpush >= 500){ // Если есть флаг нажатия и время нажатия больше 0,5 сек if (numkat == maxkat && numkat > 0){ // Если каталог последний и не первый SD.rmdir(String(numkat)); // удаляем maxkat root = SD.open("/"); // открываем корневой каталог findemaxkat(root); // определяем имя последнего каталога root.close(); // закрываем корневой каталог numkat = maxkat; // текущее имя = имя последнего каталога root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла delkatfl = 0; } } } // сброс флага нажатия кнопки 2 } else { // если кнопку отжали if (delkatknp == 0 ) { // Если 1, первое чтение, delkatfl = 0; // сброс флага нажатия кнопки 3 } } delkatknp = delkatknt; // записываем текущее состояние кнопки в предыдущее // проверка кнопок 3 и 4 на нажатие - уменьшение предельного расстояния if (reading == 1 ) { // если режим чтения mndecrknt = bitRead(regkn1,5) || bitRead(regkn1,6); // Читаем текущее состояние кнопок 0 и 2 if (mndecrknt == 0 ) { // Если 0 - нажатие, смотрим, первое чтение, или нет if (mndecrknp == 1 ) { // Если 1, первое чтение, mndecrpush = millis(); // Читаем текущее машинное время нажатия кнопки 3 mndecrfl = 1; // Установка флага нажатия кнопки 3 } else { // Если не первое чтение, mndecrnow = millis(); // Читаем текущее машинное время в мс if (mndecrfl && mndecrnow - mndecrpush >= 500){ // Если есть флаг нажатия и время нажатия больше 0,5 сек if (x > 0){ // если расстояние не минимальное x = x - 1; // указываем текущее предельное расстояние mndecrfl = 0; // сброс флага нажатия кнопки 3 } } } } else { // если кнопку отжали if (mndecrknp == 0 ) { // Если 1, первое чтение, mndecrfl = 0; // сброс флага нажатия кнопки 3 } } mndecrknp = mndecrknt; // записываем текущее состояние кнопки в предыдущее } // проверка кнопок 4 и 5 на нажатие - увеличение предельного расстояния if (reading == 1 ) { // если режим чтения mnincrknt = bitRead(regkn1,6) || bitRead(regkn1,7); // читаем текущее состояние кнопок 4 и 5 if (mnincrknt == 0 ) { // если 0 - нажатие, смотрим, первое чтение, или нет if (mnincrknp == 1 ) { // если 1, первое чтение, mnincrpush = millis(); // читаем текущее машинное время нажатия кнопок 4 и 5 mnincrfl = 1; // установка флага нажатия кнопок 4 и 5 } else { // если не первое чтение, mnincrnow = millis(); // читаем текущее машинное время в мс if (mnincrfl && mnincrnow - mnincrpush >= 500){ // если есть флаг нажатия и время нажатия больше 0,5 сек if (x < 4){ // если расстояние не максимальное x = x + 1; // указываем текущее предельное расстояние mnincrfl = 0; // сброс флага нажатия кнопок 4 и 5 } } } } else { // кнопку отжали? if (mnincrknp == 0 ) { // если 0, отжали mnincrfl = 0; // сброс флага нажатия кнопок 4 и 5 } } mnincrknp = mnincrknt; // записываем текущее состояние кнопки в предыдущее } // проверка кнопок 3 и 5 на нажатие - создание нового каталога newkatknt = bitRead(regkn1,5) || bitRead(regkn1,7); // читаем текущее состояние кнопок 3 и 5 if (newkatknt == 0 ) { // если 0 - нажатие, смотрим, первое чтение, или нет if (newkatknp == 1 ) { // если 1, первое чтение, newkatpush = millis(); // читаем текущее машинное время нажатия кнопки 5 newkatfl = 1; // устанавливаем флаг нажатия } else { // если не первое чтение, newkatnow = millis(); // читаем текущее машинное время в мс if (newkatfl && newkatnow - newkatpush >= 500) { // если есть флаг нажатия и время нажатия больше 0,5 сек if (numkat == maxkat){ // если каталог последний и не первый maxkat = maxkat +1; // устанавливаем следующий maxkat numkat = maxkat; // текущее имя = имя последнего каталога SD.mkdir(String(numkat)); // создаём следущий каталог root = SD.open("/"); // открываем корневой каталог findemaxkat(root); // определяем имя последнего каталога root.close(); // закрываем корневой каталог numkat = maxkat; // текущее имя = имя последнего каталога newkatfl = 0; // сброс флага нажатия } } } } else { // если кнопку отжали if (newkatknp == 0 ) { // если 1, первое чтение, newkatfl = 0; // сброс флага нажатия кнопки 3 } } newkatknp = newkatknt; // записываем текущее состояние кнопки в предыдущее // проверка кнопоки 5 на нажатие - перебор каталога вверх incrknt = digitalRead(ctrl6Pin); // читаем текущее состояние кнопки 5 if (incrknt == 0 ) { // если 0 - нажатие, смотрим, первое чтение, или нет if (incrknp == 1 ) { // если 1, первое чтение, incrpush = millis(); // читаем текущее машинное время нажатия кнопки 5 incrfl = 1; // установка флага нажатия кнопки 5 } else { // если не первое чтение, incrnow = millis(); // читаем текущее машинное время в мс if (!mnincrfl && !newkatfl && incrfl && incrnow - incrpush >= 500){ // если есть флаг нажатия и больше 0,5 сек if (numkat < maxkat){ // если каталог не последний numkat = numkat + 1; // текущее имя = имя последнего каталога root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла incrfl = 0; // сброс флага нажатия кнопки 5 } } } } else { // если кнопку отжали if (incrknp == 0 ) { // если 0, отжатие, incrfl = 0; // сброс флага нажатия кнопки 3 } } incrknp = incrknt; // записываем текущее состояние кнопки в предыдущее // проверка кнопоки 4 на нажатие: длительное - режим чтения карты памяти, dispknt = digitalRead(ctrl5Pin); // читаем текущее состояние пина 4 if (dispknt == 0 ) { // если 0 - нажатие, смотрим, первое чтение, или нет if (dispknp == 1 ) { // если 1, первое чтение, disppush = millis(); // читаем текущее машинное время нажатия кнопки Экран dispfl = 1; // установка флага нажатия кнопки Экран } else { // если не первое чтение, dispnow = millis(); // читаем текущее машинное время в мс if (decrknt && incrknt && dispfl && (dispnow - disppush >= 700)) { // если есть флаг нажатия и больше 0,7 сек if (autonom == 0 ) { // если 0 - нажатие, смотрим, первое чтение, или нет reading = !reading; // инвертируем флаг чтения из карты памяти } else { // если 1 - смртрим, - отпускание до истечения 500 мс? reading = 1; // устанавливаем флаг чтения из карты памяти } dispfl = 0; // сброс флага нажатия кнопки 4 root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла if (reading == 0 ) { // если 0 - нажатие, смотрим, первое чтение, или нет readAUTO = 0; // сброс флага чтения всех каналов readingA = 0; // сброс флага чтения канала A readingB = 0; // сброс флага чтения канала B readingC = 0; // сброс флага чтения канала C readingD = 0; // сброс флага чтения канала D g = maxfile ; bitClear(regm2, 5); // запись нуля в ind3 u = 0; // текущий коэффициент усиления = 1 l = 0; // текущий канал = 1 impuls(); // обработка кнопок findkanal(); flagrequ = 0; // сброс флага отправки запроса } } } } else { // если 1 - смртрим, - отпускание до истечения 500 мс? if (!dispknp && dispfl ) { // если отпускание до истечения задержки dispfl = 0; // сброс флага нажатия кнопки 4 } } dispknp = dispknt; // записываем текущее состояние кнопки в предыдущее // проверка кнопоки 3 на нажатие - перебор каталога вниз decrknt = digitalRead(ctrl4Pin); // читаем текущее состояние кнопки 3 if (decrknt == 0 ) { // если 0 - нажатие, смотрим, первое чтение, или нет if (decrknp == 1 ) { // если 1, первое чтение, decrpush = millis(); // читаем текущее машинное время нажатия кнопки 3 decrfl = 1; // установка флага нажатия кнопки 3 } else { // если не первое чтение, decrnow = millis(); // читаем текущее машинное время в мс if (dispknt && incrknt && !newkatfl && decrfl && decrnow - decrpush >= 500){ // если есть флаг нажатия и больше 0,5 сек if (numkat >0){ // если каталог не первый numkat = numkat - 1; // устанавливаем предыдущий номер каталога root = SD.open(String(numkat)+"/"); // открываем последний каталог findemaxfile(root); // определяем имя последнего файла root.close(); // закрываем последний каталог namefile = maxfile; // текущее имя = имя последнего файла decrfl = 0; // сброс флага нажатия кнопки 3 } } } } else { // если кнопку отжали if (decrknp == 0 ) { // если 1, первое чтение, decrfl = 0; // сброс флага нажатия кнопки 3 } } decrknp = decrknt; // записываем текущее состояние кнопки в предыдущее } // Установка начальных значений } void knreadSD(){ // проверка кнопоки 6 на нажатие - чтение канала A (L4) if (reading == 1 ) { // если режим чтения readkntA = digitalRead(ctrl8Pin); // Читаем текущее состояние пина if (readkntA == 0 ) { // Если 0, смотрим, первое чтение, или нет if (readknpA == 1 ) { // Если 1, первое чтение, readingA = !readingA; } // инвертируем флаг чтения канала A if (readingA == 0 ) { // если 0 - выключение g = maxfile ; // прерываем перебор файлов } } readknpA = readkntA; // записываем текущее состояние кнопки в предыдущее // проверка кнопоки 7 на нажатие - чтение канала B (L3) readkntB = digitalRead(ctrl9Pin); // Читаем текущее состояние пина if (readkntB == 0 ) { // Если 0, смотрим, первое чтение, или нет if (readknpB == 1 ) { // Если 1, первое чтение, readingB = !readingB; } // инвертируем флаг чтения канала B if (readingB == 0 ) { // если 0 - выключение g = maxfile ; // прерываем перебор файлов } } readknpB = readkntB; // записываем текущее состояние кнопки в предыдущее // проверка кнопоки 8 на нажатие - чтение канала C (L2) readkntC = digitalRead(ctrl10Pin); // Читаем текущее состояние пина if (readkntC == 0 ) { // Если 0, смотрим, первое чтение, или нет if (readknpC == 1 ) { // Если 1, первое чтение, readingC = !readingC; } // инвертируем флаг чтенияканала C if (readingC == 0 ) { // если 0 - выключение g = maxfile ; // прерываем перебор файлов } } readknpC = readkntC; // записываем текущее состояние кнопки в предыдущее // проверка кнопоки 9 на нажатие - чтение канала D (L1) readkntD = digitalRead(ctrl11Pin); // Читаем текущее состояние пина if (readkntD == 0 ) { // Если 0, смотрим, первое чтение, или нет if (readknpD == 1 ) { // Если 1, первое чтение, readingD = !readingD; } // инвертируем флаг чтения канала D if (readingD == 0 ) { // если 0 - выключение g = maxfile ; // прерываем перебор файлов } } readknpD = readkntD; // записываем текущее состояние кнопки в предыдущее // проверка кнопоки 10 на нажатие zapknt = digitalRead(ctrl12Pin); // Читаем текущее состояние пина if (zapknt == 0 ) { // Если 0, смотрим, первое чтение, или нет if (zapknp == 1 ) { // Если 1, первое чтение, readAUTO = !readAUTO; } // инвертируем флаг чтения всех каналов if (readAUTO == 0 ) { // если 0 - выключение g = maxfile ; // прерываем перебор файлов } } zapknp = zapknt; // записываем текущее состояние кнопки в предыдущее } } // Функция удаления всех файлов в каталоге void deliteArrey(File dir){ while (true) { // пока есть File entry = dir.openNextFile(); // открываем следующий файл if (! entry) { // если файлов больше нет break; // уходим } else { // если есть файлы if (SD.exists(String(numkat)+"/"+ entry.name())){ // если есть такой файл SD.remove(String(numkat)+"/"+ entry.name()); // удаляем } } } } // Функция определения максимального имени каталога на карте памяти void findemaxkat(File dir) { maxkat = 0; // записываем 0 в maxkat File entry = dir.openNextFile(); if (! entry) { // файлов нет SD.mkdir("0"); // создаём каталог "0" } // если есть файлы while (true) { // пока есть File entry = dir.openNextFile(); // открываем следующий файл if (! entry) { // если файлов больше нет break; // уходим } // если есть файлы if (entry.isDirectory()) { // если текущий файл каталог numkat = atoi(entry.name()); // конвертируем номер каталога в int, maxkat = max(maxkat,numkat); // находим максимальный номер каталога } entry.close(); // закрываем файл } } // Функция определения максимального имени файла в каталоге на карте памяти void findemaxfile(File dir) { maxfile = 0; // записываем 0 в maxfile kolfile = 0; // количество файлов while (true) { // пока есть File entry = dir.openNextFile(); // открываем следующий файл if (! entry) { // если файлов больше нет dir.rewindDirectory(); break; // уходим } namefile = atoi(entry.name()); // конвертируем номер файла в int, maxfile = max(maxfile,namefile); // находим максимальный номер файла kolfile = kolfile +1; // количество файлов entry.close(); } if (kolfile == 0) { // если файлов больше нет numzap = 0; } else { numzap = maxfile +1; } } void findkanal() { // Выясняем, какой канал текущий и заносим его в IN_PIN if (bitRead(regm2, 5) == 0) // проверяем пятый бит 0 - AUTO, 1 - SEPAR { // Если 0 - AUTO, читаем все пины if (flagn == 0 ) { // Если 0, идём читать пин, иначе - уходим if (k == 0) { // Если k = 0, - PinD reg_IN = 0xCF; // устанавливаем бит пина D IND_PIN = indDPin; // Устанавливаем пин индикации канала D flagn = 1; // Устанавливаем flagn = 1. Пин определён l = 0; // запоминаем текущий Pin k = 1; // Устанавливаем следующий Pin } else // Если k не 0, идём дальше if (k == 1) { // Если k = 1, PinC reg_IN = 0xD7; // устанавливаем регистр пина C IND_PIN = indCPin; // Устанавливаем пин индикации канала C flagn = 1; // Устанавливаем flagn = 1. Пин прочитан l = 1; // запоминаем текущий Pin k = 2; // Устанавливаем следующий Pin } else // Если k не 1, идём дальше if (k == 2) { // Если k = 2, PinB reg_IN = 0xDB; // устанавливаем регистр пина B IND_PIN = indBPin; // Устанавливаем пин индикации канала B flagn = 1; // Устанавливаем flagn = 1. Пин прочитан l = 2; // запоминаем текущий Pin k = 3; // Устанавливаем следующий Pin } else // Если k не 2, идём дальше if (k == 3) { // Если k = 3, PinA reg_IN = 0xDD; // устанавливаем регистр пина A IND_PIN = indAPin; // Устанавливаем пин индикации канала A flagn = 1; // Устанавливаем flagn = 1. Пин прочитан l = 3; // запоминаем текущий Pin k = 0; // Устанавливаем PinD } } // flagn =1. Пин уже прочитан, уходим } else // Значит, пятый бит = 1 - SEPAR, идём читать if (bitRead(regm2, 1) == 0) { // Если первый бит = 0 reg_IN = 0xFD; // устанавливаем регистр пина индикации IND_PIN = indAPin; // Устанавливаем пин индикации канала A } else // Если нет, идём дальше if (bitRead(regm2, 2) == 0) { // Если второй бит = 0 reg_IN = 0xFB; // устанавливаем регистр пина индикации IND_PIN = indBPin; // Устанавливаем пин индикации канала B }else // Если нет, идём дальше if (bitRead(regm2, 3) == 0) { // Если третий бит = 0 reg_IN = 0xF7; // устанавливаем регистр пина индикации IND_PIN = indCPin; // Устанавливаем пин индикации канала C }else // Если нет, идём дальше if (bitRead(regm2, 4) == 0) { // Если четвёртый бит = 0 reg_IN = 0xEF; // устанавливаем регистр пина индикации IND_PIN = indDPin; // Устанавливаем пин индикации канала D } flagn = 0; // сброс флага прочитанного пина } void initial() { // Установка начальных значений if (bitRead(rec_IN,1) == 0) { // Если А s = 3; } else // если нет, идём дальше if (bitRead(rec_IN,2) == 0) { // Если B s = 2; } else // если нет, идём дальше if (bitRead(rec_IN,3) == 0) { // Если C s = 1; } else // если нет, идём дальше if (bitRead(rec_IN,4) == 0) { // Если D s = 0; } } void usildef() { // Установка начальных значений if (bitRead(regm1,5) == 0) { // если х1 u = 0; } else // если нет, идём дальше if (bitRead(regm1,6) == 0) { // если х6 u = 1; } else // если нет, идём дальше if (bitRead(regm1,7) == 0) { // если х36 u = 2; } } /* 7 6 5 4 3 2 1 0 regm1 X36 X6 X1 12/24V - 16 имп 8 имп 4 имп regm2 - - АВТО D C B A - reg_IN - - АВТО D C B A - regkn2 ЭКРАН - АВТО D C B A СРЕДА - - - - L1 L2 L3 L4 - - - - - КАН 4 КАН 3 КАН 2 КАН 1 - regout - - A0T DC A1T A0R A1R - DF EF F7 FB FD CF D7 DB DD regkn1 х36 х6 х1 - 12/24 16 имп 8 имп 4 имп regkn 0x80 0x40 0x20 0x08 0x04 0x02 0x01 */