Hello guys,
Im working on a project. I did a keyboard on my nextion screen. When Im pressing a character on the keyboard, nextion writing them on a text bar.
Example:
User pressing ----> 'A' , 'B' , 'C', ' ', 'D' , 'E' , 'F' (Like sending name, surname)
Text Bar Looking -> ABC DEF (Like seeing name, surname)

So how can i save them. Like that kind of table in txt format
1- name1 surname1
2- name2 surname2
3- name3 surname3

Im not good at coding. Actually Im learning to coding. I have an idea but im open for opinions.
My idea is:
I will try to write them eeprom. But how should i processing information.

Thank you all..

buttons: A-b0 B-b1 C-b2 ... F-b5
text bar: t0

 

Code is here but my brain frost. What should I change now? I tried all ways reddit, github, youtube, chatgpt..


/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart2_tx;

/* USER CODE BEGIN PV */
uint8_t RxBuffer[20];
uint8_t RxDataX[20];
uint8_t TxBuffer[20];
uint8_t Size=0;
uint8_t SizeBuffer=0;
uint8_t EndCheck=0;
uint8_t EndCheckNumber=0;
uint8_t RxData[20];
uint8_t SizeShont=0;
uint8_t CmdEnd[3]={255,255,255};
uint8_t buf[50];
uint8_t bufx[50];

//------------------------------------------------------------CHATGPT------------------------------------------------------------
uint8_t receivedData[50];


/////
uint8_t ON1[7]={101,0,2,0,255,255,255};
uint8_t OFF1[7]={101,0,3,0,255,255,255};
//uint8_t TOGGLE1[7]={101,0,4,0,255,255,255};

//uint8_t NEXT[7]={101,0,4,0,255,255,255};
//uint8_t BACK[7]={101,1,3,0,255,255,255};

uint8_t ON2[7]={101,1,2,0,255,255,255};
uint8_t OFF2[7]={101,1,4,0,255,255,255};

uint8_t ON3[7]={101,2,2,0,255,255,255};
uint8_t OFF3[7]={101,2,3,0,255,255,255};

uint8_t A[7]={101,1,6,0,255,255,255};
uint8_t N[7]={101,1,9,0,255,255,255};
uint8_t I[7]={101,1,8,0,255,255,255};
uint8_t L[7]={101,1,10,0,255,255,255};

//------------------------------------------------------------CHATGPT------------------------------------------------------------
#define MAX_NAME_LENGTH 50

char name[MAX_NAME_LENGTH]; // İsim verisini saklamak için bir karakter dizisi

////
int frq=1000;
int counter=0;
int pulsetime=4;
int power=8;
int pulse=0;
int kadame=0;
int Sistem=0;
int len;
int a=0;
int Sisem_cnt_enable;
uint8_t flag=0;
uint8_t kademe=0;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_USART2_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{

RxData[Size]=RxBuffer[0];
//a=500;
SizeShont=0;
if (RxData[Size]==255) EndCheck++;
else EndCheck=0;
if(EndCheck==3)
{
//memset(RxDataX,'\0',strlen(RxDataX));
memset(RxDataX, '\0',(SizeBuffer)*sizeof(char));
for (int i=0;i<=(Size);i++)
{
RxDataX=RxData;
}


//memset(RxData,'\0',Size+1);
memset(RxData, '\0',(Size+1)*sizeof(char));


// sprintf(RxDataX,"%s",RxData);
// memset(RxDataX,'\0',10);
// sprintf(RxDataX,"%s",RxData);
// memset(RxData,'\0',SizeBuffer+1*sizeof(char));

SizeBuffer=Size;
Size=0;
SizeShont=1;
EndCheck=0;
}
if(SizeShont==0)Size=Size+1;
if(Size>20)Size=0;

HAL_UART_Receive_IT(&huart2,RxBuffer,1);
}
HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{

}

void SendNumber(char *id,uint16_t value)
{ //char buf[30];
len= sprintf(buf,"%s.val=%u",id,value);
buf[len]=255;
buf[len+1]=255;
buf[len+2]=255;
HAL_UART_Transmit_IT(&huart2, buf, len+2);

}
void SendData(char *data)
{ //char buf[50];
len= sprintf(buf,"%s",data);
HAL_UART_Transmit_IT(&huart2,buf, len);
}
/*void Nextion_SendString(char *ID,char *string)
{
//char buf[50];
len=sprintf(buf,"%s.txt=\"%s\"",ID,string);
HAL_UART_Transmit_IT(&huart2,buf, len);
}*/
void ReadNextion(void)
{

int result= strcmp(RxDataX,bufx);
if(result==0 )
{
for (int i=0;i<=(SizeBuffer);i++)
{bufx=0;}
}

else
{ for (int i=0;i<=(SizeBuffer);i++)
{
bufx=RxDataX;
RxDataX=0;
}}}

//------------------------------------------------------------CHATGPT------------------------------------------------------------
/*void SaveNameToMemory(const char* name)
{
// İsim verisini hafızada sakla
strncpy(name, name, MAX_NAME_LENGTH - 1);
name[MAX_NAME_LENGTH - 1] = '\0';
}*/
void SaveNameToMemory(const char* inputName)
{
char tempName[MAX_NAME_LENGTH];
strncpy(tempName, inputName, MAX_NAME_LENGTH - 1);
tempName[MAX_NAME_LENGTH - 1] = '\0';

// Hafızada saklanacak olan veriyi tempName'den name dizisine kopyala
strncpy(name, tempName, MAX_NAME_LENGTH);
}
void DisplayDataOnNextion(const char* data)
{
char buffer[50];
snprintf(buffer, sizeof(buffer), "t1.txt=\"%s\"", data);

// Nextion ekranına komut gönder
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, strlen(buffer), HAL_MAX_DELAY);
}

/* USER CODE END 0 */

/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/* MCU Configuration--------------------------------------------------------*/

/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();

/* USER CODE BEGIN Init */

/* USER CODE END Init */

/* Configure the system clock */
SystemClock_Config();

/* USER CODE BEGIN SysInit */

/* USER CODE END SysInit */

/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_USART2_UART_Init();
/* USER CODE BEGIN 2 */
HAL_StatusTypeDef HAL_UART_AbortReceive(huart2);
HAL_Delay(100);
HAL_UART_Receive_IT(&huart2,RxBuffer,1);
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,0);

//HAL_UART_Receive_IT(&huart2,Rx_Data,5);

/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */


/* USER CODE BEGIN 3 */
ReadNextion();
//PAGE-1


if(strcmp(ON1,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,1);
HAL_Delay(100);
}

if(strcmp(OFF1,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,0);
HAL_Delay(100);
}

if(strcmp(ON2,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,1);
HAL_Delay(100);
}

if(strcmp(OFF2,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,0);
HAL_Delay(100);
}

if(strcmp(ON3,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,1);
HAL_Delay(100);
}

if(strcmp(OFF3,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,0);
HAL_Delay(100);
}

//--------------------------------KEYBOARD--------------------------------

if(strcmp(A,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,0);
SendData('A');
HAL_Delay(100);
}
if(strcmp(N,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,0);
SendData('N');
HAL_Delay(100);
}
if(strcmp(I,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,0);
SendData('I');
HAL_Delay(100);
}
if(strcmp(L,bufx)==0)
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15,0);
SendData('L');
HAL_Delay(100);
}

//------------------------------------------------------------CHATGPT------------------------------------------------------------
/*if (HAL_UART_Receive_IT(&huart2, (uint8_t*)receivedData, sizeof(receivedData)) == HAL_OK)
{
SaveNameToMemory(receivedData);
DisplayDataOnNextion(name);
// Kaydedilen ismi seri terminale göndermek için aşağıdaki satırı kullanabilirsiniz
// HAL_UART_Transmit(&huart2, (uint8_t*)name, strlen(name), HAL_MAX_DELAY);
}*/
// Nextion ekranından gelen veriyi oku
char receivedChar;
HAL_UART_Receive(&huart2, (uint8_t*)&receivedChar, 1, HAL_MAX_DELAY);

// Okunan veriyi t1 text nesnesine yazdır
char buffer[10];
sprintf(buffer, "t1.txt=\"%c\"", receivedChar);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, strlen(buffer), HAL_MAX_DELAY);


}
/* USER CODE END 3 */
}

/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

/** Configure the main internal regulator output voltage
*/
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 4;
RCC_OscInitStruct.PLL.PLLN = 168;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}

/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
{
Error_Handler();
}
}

/**
* @brief USART2 Initialization Function
* @Param None
* @retval None
*/
static void MX_USART2_UART_Init(void)
{

/* USER CODE BEGIN USART2_Init 0 */

/* USER CODE END USART2_Init 0 */

/* USER CODE BEGIN USART2_Init 1 */

/* USER CODE END USART2_Init 1 */
huart2.Instance = USART2;
huart2.Init.BaudRate = 9600;
huart2.Init.WordLength = UART_WORDLENGTH_8B;
huart2.Init.StopBits = UART_STOPBITS_1;
huart2.Init.Parity = UART_PARITY_NONE;
huart2.Init.Mode = UART_MODE_TX_RX;
huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart2.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart2) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART2_Init 2 */

/* USER CODE END USART2_Init 2 */

}

/**
* Enable DMA controller clock
*/
static void MX_DMA_Init(void)
{

/* DMA controller clock enable */
__HAL_RCC_DMA1_CLK_ENABLE();

/* DMA interrupt init */
/* DMA1_Stream5_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
/* DMA1_Stream6_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);

}

/**
* @brief GPIO Initialization Function
* @Param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */

/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();

/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15, GPIO_PIN_RESET);

/*Configure GPIO pins : PD12 PD13 PD14 PD15 */
GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}

#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @Param file: pointer to the source file name
* @Param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

 

I used nextion a long time ago. AFAIR they have their own language that looks like C. You may try to concatenate each character in a variable and then send that variable to mcu with a sumbit button