ramka

unsigned char crc8(unsigned char poly, unsigned char* data, int size) //funkcja zajebana z gita, nie wiem dokładnie jak działa
{
	unsigned char crc = 0x00;
	int bit;

	while (size--) {
		crc ^= *data++;
		for (bit = 0; bit < 8; bit++) {
			if (crc & 0x01) {
				crc = (crc >> 1) ^ poly;
			} else {
				crc >>= 1;
			}
		}
	}

	return crc;
}

void checkPayload(void) { //wywołanie funkcji
	char tempBuffer[250];
	char payload[127];
	char escapedPayload[127];
	uint8_t i = 0;

	while (Busy_Rx != Empty_Rx) { //tak długo jak bufor nie jest pusty dane są przepisywane do bufora tymczasowego
		tempBuffer[i++] = Buf_Rx[Busy_Rx++];
		if (Busy_Rx >= BUF_SIZE) Busy_Rx = 0;
	}

	uint8_t j = 0;
	uint8_t beginDetected = 0;
	for(uint8_t k=0; k<i; k++){
		if (tempBuffer[k] == 0x21) {  //jeżeli znajdzie znak początku, ustawia flagę, że znaleziono początek
			beginDetected = 1;
			j = 0;
		} else if (beginDetected == 1) { //jeżeli znaleziono początek ramki dane są przepisywane do bufora ramki
			if(j>126) { //jeżeli przekroczy zakres bufora ustawiana jest flaga że nastąpił overflow
				overflowWarning=1;
				break; //wyjście z pętli jeżeli to nastąpi, taki failsafe, żeby nie wyjebało stm'a
			}
			payload[j++] = tempBuffer[k];
		}
	}
	if (beginDetected != 0) { //jeżeli nie znaleziono znaku początku, szukany jest znak escape-u ramki
		uint8_t l = 0;
		uint8_t escape = 0;
		for(uint8_t m=0; m < j; m++){
			if (payload[m] == 0x7C) { //jeżeli znak jest równy znakowi escapeu ustawiana jest flaga
				escape = 1;
			} else if (escape == 0) { //jeżeli flaga escape-u nie jest znaleziona dane są normalnie przepisywane
				escapedPayload[l++] = payload[m];
			} else {//escapowanie danych
				escape = 0;
				escapedPayload[l++] = payload[m] ^ 0x20; //przy znalezionym znaku escapeu, dane są xorowane - nie wiem o co dokładnie z tym chodzi, Tokar powinien wiedziec
			}
		}
		if (l > 2 && l < 126) { //sprawdzanie czy ramka miesci sie w zakresie
		 uint8_t checksum = escapedPayload[l-2]; //suma kontrolna w tym przypadku to drugi znak od końca
		 char data[127];
		 uint8_t n = 0;
		 for(uint8_t o=0; o < l-2; o++){
		 data[n++] = escapedPayload[o]; //przepisywanie danych w taki sposób, żeby nie nadpisac sumy kontrolnej
			}
		 //tutaj powinien byc waruenk sprawdzający sumę crc wpisanych danych np. if(checksum==(0x42,escapedFrame,m-2)
		 exec_command(data, n); //wywolanie funkcji wyszukującej poleceń w ramce
		 //tutaj powinien byc komunikat w razie jakby była zła suma kontrolna np. else sendFrame("wrong checksum",14);
		}
	}
}
void sendPayload(uint8_t *send, uint8_t len) { //wysyłanie danych zwrotnych w ramce
	uint8_t payload[127];
	uint8_t escapedPayload[127];
	uint8_t i;
	for(i=0; i<len; i++){ //przepisanie to co ma byc wysłane
		payload[i] = send[i];
	}

	payload[len] = crc8(0x42, payload, len); //wywołanie funkcji zajebanej z gita xd

	uint8_t l = 1;
	escapedPayload[0] = 0x21;
	for(uint8_t m=0; m < len+1; m++){
		if (payload[1]==0x21 || payload[1]==0x3B || payload[1]==0x7C) { //jeżeli znak równy znakowi początku lub znakowi końca lub znakowi escape-u
			escapedPayload[l++] = 0x7C; //wstawianie znaku escapeu
			escapedPayload[l++] = payload[m] ^ 0x20; //xorowanie
		} else {
			escapedPayload[l++] = payload[m]; //w przeciwnym wypadku przepisywanie normalne danych
		}
	}
    escapedPayload[l] = 0x3B; //ostatni znak zawsze będzie znakiem końca ramki

    uint8_t idx = Empty_Tx;
    for(int i = 0; i<l+1; i++){ //przepisywanie całości do bufora transmisyjnego
    	Buf_Tx[idx] = escapedPayload[i];
    	idx++;
    	if (idx >250){
    		idx = 0;
    	}
    }

    __disable_irq();

    if (Busy_Tx == Empty_Tx && __HAL_UART_GET_FLAG(&huart2, UART_FLAG_TXE) == SET){ //przesyłanie usartem
    	Empty_Tx = idx;
    	temp = Buf_Tx[Busy_Tx];
    	Busy_Tx++;
    	if (Busy_Tx > 250){
    		Busy_Tx = 0;
    	}
    	HAL_UART_Transmit_IT(&huart2, &temp, 1);
    } else {
    	Empty_Tx = idx;
    }
    __enable_irq();
}