Форум arduino.ua

  String nmeaSentence = "";
  boolean str_read = true;
  
void setup() { Serial.begin(9600); }

void serialEvent() { nmeaSentence = Serial.readStringUntil('n');
if (nmeaSentence.length() > 0 && str_read) { GPS_run(nmeaSentence); }
	}
  
void loop() {

	}

void GPS_run(String nmea) {
str_read = false;	
	// ********************************************
str_read = true;	
	}

char fullSpeed[5];
sprintf(fullSpeed, "%03d", speedKmh);

//   чтобы избежать переполнения 

sprintf(fullSpeed, sizeof(fullSpeed), "%03d", speedKmh);

#include <Adafruit_GFX.h>    	// Core graphics library
#include <Adafruit_ST7735.h> 	// Hardware-specific library for ST7735
#include <SPI.h>
#define TFT_CS        10
#define TFT_RST        8 		// Or set to -1 and connect to Arduino RESET pin
#define TFT_DC         9
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
#include <SoftwareSerial.h>
#include <string.h>
SoftwareSerial gpsSerial(4, 3); // (RX, TX Arduino)

String nmeaSentence = ""; 		// Переменная для хранения NMEA-строки
const int timezoneOffset = 3;	// Часовой пояс (например, +3 для EEST)
boolean valid = false;			// флаг валидности координат
boolean drive = false;			// флаг движения
boolean overtime = false;		// флаг время/скорость

//	char tokenKnot[] = "10.5"; 		// Пример тестового значения


void setup() {
//								Serial.begin(9600);
gpsSerial.begin(9600);
tft.initR(INITR_BLACKTAB);   	// initialize a ST7735S chip, black tab
tft.setRotation(3);     		// Установка ориентации экрана
tft.fillScreen(ST77XX_BLACK);	// Установка начального цвета фона
}

void loop() {
  while (gpsSerial.available()) {
    char c = gpsSerial.read(); 	// Считать один символ из GPS
    if (c == 'n') { 			// Проверить, является ли символ концом NMEA-строки
      GPS_run(nmeaSentence); 	// Передать строку в GPS_run() для обработки
      nmeaSentence = ""; 		// Очистить строку для следующей NMEA-строки
    } else if (c != 'r') { 	// Игнорировать символ возврата каретки
      nmeaSentence += c; 		// Добавить символ к строке NMEA
    }
  }
}

void GPS_run(String nmea) {
  if (nmea.startsWith("$GPRMC")) { 					// Проверка на идентификатор строки
//								Serial.println("______________________________"); 
//								Serial.println("_______ вход в $GPRMC ***1*** ");
    char nmeaCStr[nmea.length() + 1];
    nmea.toCharArray(nmeaCStr, nmea.length() + 1);
    int fieldIndex = 0;
    char *token = nmeaCStr;
    char *commaPos = strchr(token, ',');			// Найти первую запятую
    while (fieldIndex <= 13) {
    if (commaPos) {
    *commaPos = ''; 								// Разделяем строку на части

if (fieldIndex == 1) {printFormattedTime(token);token = nullptr;}	// выводим время 1
if (fieldIndex == 2) {printFormattedValid(token);token = nullptr;}	// выводим валидность координат 2	
if (fieldIndex == 7) {printFormattedSpeed(token);token = nullptr;}// выводим скорость 7
if (fieldIndex == 9) {printFormattedDate(token);token = nullptr;}	// выводим дату 9

token = commaPos + 1;
commaPos = strchr(token, ',');} 
else {break;}
      fieldIndex++;}
	}	
	
  if (nmea.startsWith("$GPGGA")) { 					// Проверка на идентификатор строки
//								Serial.println("______________________________");  
//								Serial.println("_______ вход в $GPGGA ***2*** ");
	char nmeaCStr[nmea.length() + 1];
    nmea.toCharArray(nmeaCStr, nmea.length() + 1);
    int fieldIndex = 0;
    char *token = nmeaCStr;
    char *commaPos = strchr(token, ',');			// Найти первую запятую
    while (fieldIndex <= 14) {
    if (commaPos) {
    *commaPos = ''; 								// Разделяем строку на части
 
if (fieldIndex == 7) {printFormattedSatelit(token);token = nullptr;}// выводим спутники 7

token = commaPos + 1;
commaPos = strchr(token, ',');} 
else {break;}
      fieldIndex++;}
	}	
}


// Функция контроля достоверности полученных координат
void printFormattedValid(char* rawValid) {
//									Serial.print("Полученная rawValid       : ");
//	Serial.print(valid); Serial.print(" - "); Serial.println(rawValid);
if (strcmp(rawValid, "V") == 0) {valid = false;}
if (strcmp(rawValid, "A") == 0) {valid = true;}
}


// Функция для форматирования количества спутников
void printFormattedSatelit(char* rawSatel) {
//									Serial.print("Полученная rawSatel       : ");
//									Serial.println(rawSatel);
	static char previousSatel[5];
	if (strcmp(rawSatel, previousSatel) != 0) {
	tft.fillRect(125, 1, 29, 20, ST77XX_BLACK);}
tft.setTextColor(ST7735_WHITE);
tft.setTextSize(1);
tft.setCursor(12, 10);
tft.print("active satellites");
if (valid == false) {tft.setTextColor(ST77XX_RED);}
if (valid == true) {tft.setTextColor(ST77XX_GREEN);}
tft.setTextSize(2); 
tft.setCursor(127, 5);
tft.print(rawSatel);
	strncpy(previousSatel, rawSatel, sizeof(previousSatel) - 1);
    previousSatel[sizeof(previousSatel) - 1] = '';
}


// Функция для форматирования скорости (knot -> km/h)
void printFormattedSpeed(char* rawKnot) {
//    Serial.print("Полученная rawKnot : ");
//    Serial.println(rawKnot);
    tft.setTextColor(ST77XX_ORANGE);
    tft.setTextSize(5);
    tft.setCursor(35, 45);
    float Kmh = atof(rawKnot) * 1.852;
  int speedKmh = (int)Kmh;
  if (speedKmh == 0) {drive = false; return;} 
  else {drive = true;}  
//    Serial.print("Конвертируем узлы в км/ч speedKmh : ");
//    Serial.println(speedKmh);
    char fullSpeed[5];
    sprintf(fullSpeed, "%03d", speedKmh);
	tft.fillRect(5, 40, 155, 45, ST77XX_BLACK);
//  tft.drawRect(5, 40, 155, 45, ST77XX_WHITE);
    tft.print(fullSpeed); 
//    Serial.print("Форматируем число с ведущими нулями fullSpeed: ");
//    Serial.println(fullSpeed);
}


// Функция для форматирования времени с учётом часового пояса (UTC -> ЧЧ:ММ:СС)
void printFormattedTime(char* utcTime) {
//									Serial.print("Полученная utcTime       : ");
//									Serial.println(utcTime);
  char fullTime[9]; 								// Переменная для хранения строки времени в формате "HH:MM:SS"
  char hh[3], mm[3], ss[3];
  strncpy(hh, utcTime, 2); hh[2] = '';
  strncpy(mm, utcTime + 2, 2); mm[2] = '';
  strncpy(ss, utcTime + 4, 2); ss[2] = '';
  int hour = atoi(hh) + timezoneOffset;				// Коррекция часа в зависимости от timezoneOffset
  if (hour < 0) hour += 24; 						// Если час отрицательный, добавляем 24
  if (hour >= 24) hour -= 24; 						// Если час превышает 24, вычитаем 24
  sprintf(fullTime, "%02d:%s:%s", hour, mm, ss);	// Формируем строку времени
// время вверху
	if (drive == false) {
tft.fillRect(5, 40, 155, 45, ST77XX_BLACK);
tft.setTextColor(ST7735_YELLOW);
tft.setTextSize(3);
tft.setCursor(10, 50); tft.print(fullTime); } 
	if (drive == true) { 
tft.fillRect(15, 94, 130, 25, ST77XX_BLACK);
tft.setTextColor(ST7735_YELLOW);
tft.setTextSize(2);
tft.setCursor(30, 100); tft.print(fullTime); 
	overtime = true;}
}


// Функция для форматирования даты (ДД.ММ.ГГГГ)
void printFormattedDate(char* rawDate) {
//									Serial.print("Полученная drive d rawDate : ");
//									Serial.println(drive);
	if (drive == true) {return;}
//									Serial.print("Полученная rawDate       : ");
//									Serial.println(rawDate);
	static char previousDate[11];
	if (strcmp(rawDate, previousDate) != 0 || overtime == true) {
	tft.fillRect(15, 94, 130, 25, ST77XX_BLACK);}
	overtime = false;
char fullDate[11]; 									// Переменная для хранения полной строки даты (формат "DD.MM.YYYY")
char dd[3], mm[3], yy[3]; 							// Обратите внимание, что yy теперь размера 3, а не 5
strncpy(dd, rawDate, 2); dd[2] = '';
strncpy(mm, rawDate + 2, 2); mm[2] = '';
strncpy(yy, rawDate + 4, 2); yy[2] = '';
sprintf(fullDate, "%s.%s.20%s", dd, mm, yy);		// Формируем строку даты
tft.setTextColor(ST77XX_MAGENTA);
tft.setTextSize(2);
tft.setCursor(20, 100);
tft.print(fullDate);
	strncpy(previousDate, rawDate, sizeof(previousDate) - 1);
    previousDate[sizeof(previousDate) - 1] = '';
}

#include <SoftwareSerial.h>
SoftwareSerial gpsSerial(4, 3); // RX (к Arduino), TX (к GPS-модулю)
void setup() {
  Serial.begin(115200);
  gpsSerial.begin(9600);
  Serial.println("Начало чтения NMEA-строк...");
}
void loop() {
  if (gpsSerial.available()) {
    static char buffer[128]; 
    static size_t index = 0; 
    char c = gpsSerial.read(); 
    if (c == 'n') { 
      buffer[index] = ''; 
      Serial.println(buffer); 
      index = 0; } 
	else if (index < sizeof(buffer) - 1) {buffer[index++] = c;}
  }
}

Начало чтения NMEA-строк...
$GPGGA,085638.000,4829.8262,N,03556.0484,E,1,03,7.9,120.1,M,18.9,M,,0000*57
$GPGSA,A,2,31,29,28,,,,,,,,,,7.9,7.9,1.0*31
$GPRMC,085638.000,A,4829.8262,N,03556.0484,E,0.00,,050425,,,A*72

$GPGGA,085639.000,4829.8262,N,03556.0484,E,1,03,7.9,120.1,M,18.9,M,,0000*56
$GPGSA,A,2,31,29,28,,,,,,,,,,7.9,7.9,1.0*31
$GPGSV,3,1,10,25,82,177,,29,58,268,33,12,46,126,,11,39,054,17*75
$GPGSV,3,2,10,28,37,287,34,20,31,093,23,31,23,312,40,05,17,131,19*79
$GPGSV,3,3,10,06,10,040,,18,09,207,*7E
$GPRMC,085639.000,A,4829.8262,N,03556.0484,E,0.00,,050425,,,A*73

$GPGGA,085640.000,4829.8262,N,03556.0484,E,1,03,7.9,120.1,M,18.9,M,,0000*58
$GPGSA,A,2,31,29,28,,,,,,,,,,7.9,7.9,1.0*31
$GPRMC,085640.000,A,4829.8262,N,03556.0484,E,0.00,,050425,,,A*7D

$GPGGA,085641.000,4829.8262,N,03556.0484,E,1,03,7.9,120.1,M,18.9,M,,0000*59
$GPGSA,A,2,31,29,28,,,,,,,,,,7.9,7.9,1.0*31
$GPRMC,085641.000,A,4829.8262,N,03556.0484,E,0.00,,050425,,,A*7C

$GPGGA,085642.000,4829.8262,N,03556.0484,E,1,03,7.9,120.1,M,18.9,M,,0000*5A
$GPGSA,A,2,31,29,28,,,,,,,,,,7.9,7.9,1.0*31
$GPRMC,085642.000,A,4829.8262,N,03556.0484,E,0.00,,050425,,,A*7F

$GPGGA,085643.000,4829.8262,N,03556.0484,E,1,03,7.9,120.1,M,18.9,M,,0000*5B
$GPGSA,A,2,31,29,28,,,,,,,,,,7.9,7.9,1.0*31
$GPRMC,085643.000,A,4829.8262,N,03556.0484,E,0.00,,050425,,,A*7E

$GPGGA,085644.000,4829.8262,N,03556.0484,E,1,03,7.9,120.1,M,18.9,M,,0000*5C
$GPGSA,A,2,31,29,28,,,,,,,,,,7.9,7.9,1.0*31
$GPGSV,3,1,10,25,82,177,,29,58,268,33,12,46,126,,11,39,054,17*75
$GPGSV,3,2,10,28,37,287,33,20,31,093,22,31,23,312,40,05,17,131,17*71
$GPGSV,3,3,10,06,10,040,,18,09,207,*7E
$GPRMC,085644.000,A,4829.8262,N,03556.0484,E,0.00,,050425,,,A*79

#include <SoftwareSerial.h>

SoftwareSerial gpsSerial(4, 3); // Пины для подключения GPS (RX, TX)

char value[32];
char buffer[128];
char subBuffer[128]; // Дополнительный буфер для разделения склеенных строк

void parseNMEA(const char* identifier, int commaIndex) {

    while (gpsSerial.available()) {
        memset(buffer, 0, sizeof(buffer)); // Очистка основного буфера
        size_t len = gpsSerial.readBytesUntil('n', buffer, sizeof(buffer) - 1);
        buffer[len] = 'n'; // Завершающий символ строки

        // Проверка на склеенные строки
        if (strstr(buffer, identifier) && strstr(buffer, "$GPGGA")) {
Serial.println("Обнаружена склеенная строка! Разделяем...");
            char* secondPart = strstr(buffer, "$GPGGA"); // Находим начало второй строки
            size_t firstPartLen = secondPart - buffer;   // Вычисляем длину первой строки

            // Копируем первую часть строки в отдельный буфер
            strncpy(subBuffer, buffer, firstPartLen);
            subBuffer[firstPartLen] = 'n';

Serial.print("Первая часть строки: ");
Serial.println(subBuffer);

            // Обрабатываем первую часть строки
            processLine(subBuffer, identifier, commaIndex);

            // Обрабатываем вторую часть строки
Serial.print("Вторая часть строки: ");
Serial.println(secondPart);
            processLine(secondPart, identifier, commaIndex);
            continue;
        }

        // Фильтр: проверяем начало строки
        if (buffer[0] != '$') {
Serial.println("Строка пропущена: некорректный формат");
            continue;
        }

Serial.print("Полученная строка: ");
Serial.println(buffer);

        // Обработка строки с использованием идентификатора
        processLine(buffer, identifier, commaIndex);
    }
}

void processLine(const char* buffer, const char* identifier, int commaIndex) {
    // Проверяем соответствие идентификатору
    if (strncmp(buffer, identifier, strlen(identifier)) == 0) {
        const char* ptr = buffer;
        for (int i = 0; i < commaIndex; i++) {
            ptr = strchr(ptr, ',');
            if (!ptr) {
Serial.println("Ошибка: недостаточно запятых.");
                return;
            }
            ptr++; // Переход к следующему символу после запятой
        }

        // Получаем значение после запятой
        //char value[32];
        size_t i = 0;
        while (*ptr && *ptr != ',' && *ptr != 'r' && *ptr != 'n' && i < sizeof(value) - 1) {
            value[i++] = *ptr++;
        }
        value[i] = 'n';

//Serial.print("Найдено значение: ");
//Serial.println(value);
        return(value);
    }
}

void setup() {
    Serial.begin(115200);
    gpsSerial.begin(9600);
    Serial.println("Инициализация завершена. Ожидаю данные...");
}

void loop() {
    parseNMEA("$GPGSA", 15); // Ищем данные $GPRMC после девятой запятой
Serial.print("-----------Найдено значение  $GPGSA, 15 : ");
Serial.println(value);
    delay(1000); // Увеличенный интервал для предотвращения переполнения
  
    parseNMEA("$GPGGA", 4); // Ищем данные $GPRMC после девятой запятой
Serial.print("-----------Найдено значение  $GPGGA, 4 : ");
Serial.println(value);
    delay(1000); // Увеличенный интервал для предотвращения переполнения
  
  parseNMEA("$GPRMC", 9); // Ищем данные $GPRMC после девятой запятой
Serial.print("-----------Найдено значение  $GPRMC, 9 : ");
Serial.println(value);
    delay(1000); // Увеличенный интервал для предотвращения переполнения

Serial.println("+++++++++++++++++++++++++++++++");
  
}

Инициализация завершена. Ожидаю данные...
Найдено значение  $GPGSA, 15 : 
Обнаружена склеенная строка! Разделяем...
Первая часть строки: 

Вторая часть строки: $GPGGA,095405.000,4829.8325,N,03556.0791,E,1,03,25.2,189.4,M,18$GPGGA,095406.000,4829.8319,N,03556.0755,E,1,03,25.1,187.5,M,18.
,M,,0000*6A
$GPGSA,A,2,26,31,28,,,,,,,,,,25.2,25.1,1.0*3D
$G.9⸮
Строка пропущена: некорректный формат
Полученная строка: $GPGSA,A,2,26,31,28,,,,,,,,,,25.2,25.1,1.0*3D

Полученная строка: $G829.8319,N,0355,E,23.78,275.81,050425,,,A*57

Найдено значение  $GPGGA, 4 : 03556.0791

Полученная строка: $GPGGA,095407.000,4829.8315,N,03556.0725,E,1,03,25.1,185.7,M,18$GPGGA,095408.000,4829.8313,N,03556.0708,E,1,03,25.1,184.3,M,18.
A,2,26,31,3556.0708,E,1,03,25.1,184.3,M,18.9,M,,0000*63
$GPGSA,Y
Строка пропущена: некорректный формат
Полученная строка: $GPGSA,A,2,26,31,28,,,,,,,,,,25.1,25.1,1.0*3E

Полученная строка: $GPRMC,095408.000,A,4829.8313,N,03556.0708,E,21.39,276.20,050425,,,A*54

Найдено значение  $GPRMC, 9 : 050425
791

+++++++++++++++++++++++++++++++
Полученная строка: $GPGGA,095409.000,4829.8307,N,03556.0723,E,1,03,25.1,183.0,M,1818,33,214,,28,31,257,20,31,31,287,26,12,22,139,20*7E

Полученная строка: $GPGSV,3,3,10,26,19,309,26,11,17,048,18*79

Полученная строка: $GPRMC,095409.000,A,4829.8307,N,03556.0723,E,18.97,274.54,050425,,,A*56

Найдено значение  $GPGSA, 15 : 050425
791

Обнаружена склеенная строка! Разделяем...
Первая часть строки: 

Вторая часть строки: $GPGGA,095410.000,4829.8299,N,03556.0744,E,1,03,25.1,181.8,M,18$GPGGA,095411.000,4829.8291,N,03556.0784,E,1,03,25.0,180.7,M,18.
,,,,,25.1,25.0,1.0*3F
$G.9,M,,0000*65
$GPGSA,A,2,26,31,28,,,,,.:
Строка пропущена: некорректный формат
Полученная строка: $GPGSA,A,2,26,31,28,,,,,,,,,,25.1,25.0,1.0*3F

Полученная строка: $G829.8291,N,0354,E,14.19,272.45,050425,,,A*50

Найдено значение  $GPGGA, 4 : 03556.0744

Полученная строка: $GPGGA,095412.000,4829.8293,N,03556.0725,E,6,00,50.0,180.5,M,18$GPGGA,095413.000,4829.8294,N,03556.0665,E,6,00,50.0,180.2,M,18.
,M,18.9,M,,0000*6F
$GPGSA,A,2,,,,,,,,,,,,,50.0,,6,00,50.0,180.2⸮!
Строка пропущена: некорректный формат
Полученная строка: $GPGSA,A,2,,,,,,,,,,,,,50.0,50.0,50.0*06

Полученная строка: $GPRMC,095413.000,V,4829.8294,N,03556.0665,E,14.19,272.45,050425,,,E*4A

Найдено значение  $GPRMC, 9 : 050425
744

+++++++++++++++++++++++++++++++

Инициализация завершена. Ожидаю данные...
Найдено значение  $GPGSA, 15 : 
Найдено значение  $GPGGA, 4 : 

Найдено значение  $GPRMC, 9 : 

+++++++++++++++++++++++++++++++
Найдено значение  $GPGSA, 15 : 

Найдено значение  $GPGGA, 4 : 

Найдено значение  $GPRMC, 9 : 050425

+++++++++++++++++++++++++++++++
Найдено значение  $GPGSA, 15 : 050425

Найдено значение  $GPGGA, 4 : 
50425

Найдено значение  $GPRMC, 9 : 050425

+++++++++++++++++++++++++++++++
Найдено значение  $GPGSA, 15 : 050425

Найдено значение  $GPGGA, 4 : 
50425

Найдено значение  $GPRMC, 9 : 
50425

+++++++++++++++++++++++++++++++
Найдено значение  $GPGSA, 15 : 28
425

Найдено значение  $GPGGA, 4 : 28
425

Найдено значение  $GPRMC, 9 : 050425

+++++++++++++++++++++++++++++++
Найдено значение  $GPGSA, 15 : 050425

Найдено значение  $GPGGA, 4 : 050425

Найдено значение  $GPRMC, 9 : 050425

+++++++++++++++++++++++++++++++

/*
  An example analogue clock using a TFT LCD screen to show the time
 use of some of the drawing commands with the ST7735 library.
 For a more accurate clock, it would be better to use the RTClib library.
 But this is just a demo. 
 
 This examples uses the hardware SPI only. Non-hardware SPI
 is just too slow (~8 times slower!)
 
 Gilchrist 6/2/2014 1.0
 Updated by Bodmer
 */

#include <TFT_ST7735.h> // Graphics and font library for ST7735 driver chip
#include <SPI.h>

TFT_ST7735 tft = TFT_ST7735();  // Invoke library, pins defined in User_Setup.h

#define ST7735_GREY 0xBDF7

float sx = 0, sy = 1, mx = 1, my = 0, hx = -1, hy = 0;    // Saved H, M, S x & y multipliers
float sdeg=0, mdeg=0, hdeg=0;
uint16_t osx=64, osy=64, omx=64, omy=64, ohx=64, ohy=64;  // Saved H, M, S x & y coords
uint16_t x0=0, x1=0, y0=0, y1=0;
uint32_t targetTime = 0;                    // for next 1 second timeout

static uint8_t conv2d(const char* p) {
  uint8_t v = 0;
  if ('0' <= *p && *p <= '9')
    v = *p - '0';
  return 10 * v + *++p - '0';
}

uint8_t hh=conv2d(__TIME__), mm=conv2d(__TIME__+3), ss=conv2d(__TIME__+6);  // Get H, M, S from compile time

boolean initial = 1;

void setup(void) {
  tft.init();
  tft.setRotation(0);
  tft.fillScreen(ST7735_GREY);
  tft.setTextColor(ST7735_GREEN, ST7735_GREY);  // Adding a black background colour erases previous text automatically
  
  // Draw clock face
  tft.fillCircle(64, 64, 61, ST7735_BLUE);
  tft.fillCircle(64, 64, 57, ST7735_BLACK);

  // Draw 12 lines
  for(int i = 0; i<360; i+= 30) {
    sx = cos((i-90)*0.0174532925);
    sy = sin((i-90)*0.0174532925);
    x0 = sx*57+64;
    y0 = sy*57+64;
    x1 = sx*50+64;
    y1 = sy*50+64;

    tft.drawLine(x0, y0, x1, y1, ST7735_BLUE);
  }

  // Draw 60 dots
  for(int i = 0; i<360; i+= 6) {
    sx = cos((i-90)*0.0174532925);
    sy = sin((i-90)*0.0174532925);
    x0 = sx*53+64;
    y0 = sy*53+64;
    
    tft.drawPixel(x0, y0, ST7735_BLUE);
    if(i==0 || i==180) tft.fillCircle(x0, y0, 1, ST7735_CYAN);
    if(i==0 || i==180) tft.fillCircle(x0+1, y0, 1, ST7735_CYAN);
    if(i==90 || i==270) tft.fillCircle(x0, y0, 1, ST7735_CYAN);
    if(i==90 || i==270) tft.fillCircle(x0+1, y0, 1, ST7735_CYAN);
  }

  tft.fillCircle(65, 65, 3, ST7735_RED);

  // Draw text at position 64,125 using fonts 4
  // Only font numbers 2,4,6,7 are valid. Font 6 only contains characters [space] 0 1 2 3 4 5 6 7 8 9 : . a p m
  // Font 7 is a 7 segment font and only contains characters [space] 0 1 2 3 4 5 6 7 8 9 : .
  tft.drawCentreString("Time flies",64,130,4);

  targetTime = millis() + 1000; 
}

void loop() {
  if (targetTime < millis()) {
    targetTime = millis()+1000;
    ss++;              // Advance second
    if (ss==60) {
      ss=0;
      mm++;            // Advance minute
      if(mm>59) {
        mm=0;
        hh++;          // Advance hour
        if (hh>23) {
          hh=0;
        }
      }
    }

    // Pre-compute hand degrees, x & y coords for a fast screen update
    sdeg = ss*6;                  // 0-59 -> 0-354
    mdeg = mm*6+sdeg*0.01666667;  // 0-59 -> 0-360 - includes seconds
    hdeg = hh*30+mdeg*0.0833333;  // 0-11 -> 0-360 - includes minutes and seconds
    hx = cos((hdeg-90)*0.0174532925);    
    hy = sin((hdeg-90)*0.0174532925);
    mx = cos((mdeg-90)*0.0174532925);    
    my = sin((mdeg-90)*0.0174532925);
    sx = cos((sdeg-90)*0.0174532925);    
    sy = sin((sdeg-90)*0.0174532925);

    if (ss==0 || initial) {
      initial = 0;
      // Erase hour and minute hand positions every minute
      tft.drawLine(ohx, ohy, 65, 65, ST7735_BLACK);
      ohx = hx*33+65;    
      ohy = hy*33+65;
      tft.drawLine(omx, omy, 65, 65, ST7735_BLACK);
      omx = mx*44+65;    
      omy = my*44+65;
    }

      // Redraw new hand positions, hour and minute hands not erased here to avoid flicker
      tft.drawLine(osx, osy, 65, 65, ST7735_BLACK);
      tft.drawLine(ohx, ohy, 65, 65, ST7735_WHITE);
      tft.drawLine(omx, omy, 65, 65, ST7735_WHITE);
      osx = sx*47+65;    
      osy = sy*47+65;
      tft.drawLine(osx, osy, 65, 65, ST7735_RED);

    tft.fillCircle(65, 65, 3, ST7735_RED);
  }
}

  tft.drawFastHLine(0, originY, tft.width(), TFT_WHITE); // Горизонтальная линия вправо
  tft.drawFastVLine(originX, 0, tft.height(), TFT_WHITE);	// Вертикальная линия вверх
//  tft.drawLine(endX, originY, endX - 3, originY - 3, TFT_WHITE);	// Стрелка по X
//  tft.drawLine(originX, endY, originX + 3, endY + 3, TFT_WHITE); 	// Стрелка по Y

  tft.setRotation(3);       // Установка ориентации экрана