279 lines
7.7 KiB
C
279 lines
7.7 KiB
C
/* Copyright 2022 Bogdan Pilyugin
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* File name: Helpers.c
|
|
* Project: ChargePointMainboard
|
|
* Created on: 2022-07-21
|
|
* Author: Bogdan Pilyugin
|
|
* Description:
|
|
*/
|
|
#include "Helpers.h"
|
|
#include "esp_mac.h"
|
|
#include "esp_rom_crc.h"
|
|
#include "mbedtls/md.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
|
|
uint32_t crc32(uint32_t crc, uint8_t const *buf, uint32_t len)
|
|
{
|
|
return esp_rom_crc32_le(crc, buf, len);
|
|
}
|
|
|
|
void GetChipId(uint8_t *i)
|
|
{
|
|
uint8_t mac[6];
|
|
//esp_base_mac_addr_get(mac);
|
|
esp_efuse_mac_get_default(mac);
|
|
memcpy(i,&mac[2],4);
|
|
}
|
|
|
|
char val_to_hex_digit(int val)
|
|
{
|
|
return "0123456789ABCDEF"[val];
|
|
}
|
|
|
|
void bin_to_hex_str(const uint8_t *buf, int len, char *hex)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
uint8_t b = buf[i];
|
|
*hex = val_to_hex_digit((b & 0xf0) >> 4);
|
|
hex++;
|
|
*hex = val_to_hex_digit(b & 0x0f);
|
|
hex++;
|
|
}
|
|
}
|
|
|
|
void BytesToStr(unsigned char *StrIn, unsigned char *StrOut, uint8_t N)
|
|
{
|
|
uint8_t it, tmp;
|
|
for (it = 0; it < N; ++it)
|
|
{
|
|
tmp = *StrIn;
|
|
tmp >>= 4;
|
|
tmp &= 0x0F;
|
|
if (tmp <= 0x09)
|
|
*StrOut = tmp + 0x30;
|
|
else
|
|
*StrOut = tmp + 0x37;
|
|
++StrOut;
|
|
tmp = *StrIn;
|
|
tmp &= 0x0F;
|
|
if (tmp <= 0x09)
|
|
*StrOut = tmp + 0x30;
|
|
else
|
|
*StrOut = tmp + 0x37;
|
|
++StrOut;
|
|
*StrOut = 0x00;
|
|
++StrIn;
|
|
}
|
|
}
|
|
|
|
static char char2int(char input)
|
|
{
|
|
if (input >= '0' && input <= '9')
|
|
return input - '0';
|
|
if (input >= 'A' && input <= 'F')
|
|
return input - 'A' + 10;
|
|
if (input >= 'a' && input <= 'f')
|
|
return input - 'a' + 10;
|
|
return 0x00;
|
|
}
|
|
|
|
bool StrToBytes(unsigned char *StrIn, unsigned char *StrOut)
|
|
{
|
|
if ((strlen((const char*) StrIn) % 2))
|
|
return false;
|
|
while (*StrIn && StrIn[1])
|
|
{
|
|
*(StrOut++) = char2int(*StrIn) * 16 + char2int(StrIn[1]);
|
|
StrIn += 2;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool StrToBytesLen(unsigned char *StrIn, unsigned char *StrOut, uint16_t InputSymbols)
|
|
{
|
|
if (InputSymbols % 2)
|
|
return false;
|
|
for (int i = 0; i < InputSymbols; i+=2)
|
|
{
|
|
*(StrOut++) = char2int(*StrIn) * 16 + char2int(StrIn[1]);
|
|
StrIn += 2;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
uint32_t swap(uint32_t in)
|
|
{
|
|
in = ((in & 0xff000000) >> 24) | ((in & 0x00FF0000) >> 8) | ((in & 0x0000FF00) << 8) | ((in & 0xFF) << 24);
|
|
//in = (in >> 16) | (in << 16);
|
|
return in;
|
|
}
|
|
|
|
char btohexa_low(char b)
|
|
{
|
|
b &= 0x0F;
|
|
return (b > 9u) ? b + 'A' - 10 : b + '0';
|
|
}
|
|
|
|
BYTE hexatob(TCPIP_UINT16_VAL AsciiChars)
|
|
{
|
|
// Convert lowercase to uppercase
|
|
if (AsciiChars.v[1] > 'F')
|
|
AsciiChars.v[1] -= 'a' - 'A';
|
|
if (AsciiChars.v[0] > 'F')
|
|
AsciiChars.v[0] -= 'a' - 'A';
|
|
|
|
// Convert 0-9, A-F to 0x0-0xF
|
|
if (AsciiChars.v[1] > '9')
|
|
AsciiChars.v[1] -= 'A' - 10;
|
|
else
|
|
AsciiChars.v[1] -= '0';
|
|
|
|
if (AsciiChars.v[0] > '9')
|
|
AsciiChars.v[0] -= 'A' - 10;
|
|
else
|
|
AsciiChars.v[0] -= '0';
|
|
|
|
// Concatenate
|
|
return (BYTE) ((AsciiChars.v[1] << 4) | AsciiChars.v[0]);
|
|
}
|
|
|
|
void UnencodeURL(char* URL)
|
|
{
|
|
char *Right, *Copy;
|
|
UINT16_VAL Number;
|
|
|
|
while ((Right = strchr((const char*) URL, '%')))
|
|
{
|
|
// Make sure the string is long enough
|
|
if (Right[1] == '\0')
|
|
break;
|
|
if (Right[2] == '\0')
|
|
break;
|
|
|
|
// Update the string in place
|
|
Number.v[0] = Right[2];
|
|
Number.v[1] = Right[1];
|
|
*Right++ = hexatob(Number);
|
|
URL = Right;
|
|
|
|
// Remove two blank spots by shifting all remaining characters right two
|
|
Copy = Right + 2;
|
|
while ((*Right++ = *Copy++));
|
|
}
|
|
}
|
|
|
|
esp_err_t SHA256Hash(unsigned char *data, int datalen,
|
|
unsigned char *res)
|
|
{
|
|
mbedtls_md_context_t ctx;
|
|
mbedtls_md_type_t md_type = MBEDTLS_MD_SHA256;
|
|
mbedtls_md_init(&ctx);
|
|
mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(md_type), 0);
|
|
mbedtls_md_starts(&ctx);
|
|
mbedtls_md_update(&ctx, (const unsigned char*) data, datalen);
|
|
mbedtls_md_finish(&ctx, res);
|
|
mbedtls_md_free(&ctx);
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t SHA256hmacHash(unsigned char *data,
|
|
int datalen,
|
|
unsigned char *key,
|
|
int keylen,
|
|
unsigned char *res)
|
|
{
|
|
mbedtls_md_context_t ctx;
|
|
mbedtls_md_type_t md_type = MBEDTLS_MD_SHA256;
|
|
mbedtls_md_init(&ctx);
|
|
mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(md_type), 1);
|
|
mbedtls_md_hmac_starts(&ctx, key, keylen);
|
|
mbedtls_md_hmac_update(&ctx, (const unsigned char*) data, datalen);
|
|
mbedtls_md_hmac_finish(&ctx, res);
|
|
mbedtls_md_free(&ctx);
|
|
return ESP_OK;
|
|
}
|
|
|
|
# if(CONFIG_FREERTOS_USE_TRACE_FACILITY == 1)
|
|
void vTaskGetRunTimeStatsCustom( char *pcWriteBuffer )
|
|
{
|
|
TaskStatus_t *pxTaskStatusArray;
|
|
volatile UBaseType_t uxArraySize, x;
|
|
unsigned long ulTotalRunTime, ulStatsAsPercentage;
|
|
|
|
/* Make sure the write buffer does not contain a string. */
|
|
*pcWriteBuffer = 0x00;
|
|
|
|
/* Take a snapshot of the number of tasks in case it changes while this
|
|
function is executing. */
|
|
uxArraySize = uxTaskGetNumberOfTasks();
|
|
|
|
/* Allocate a TaskStatus_t structure for each task. An array could be
|
|
allocated statically at compile time. */
|
|
pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( TaskStatus_t ) );
|
|
|
|
if( pxTaskStatusArray != NULL )
|
|
{
|
|
/* Generate raw status information about each task. */
|
|
uxArraySize = uxTaskGetSystemState( pxTaskStatusArray,
|
|
uxArraySize,
|
|
&ulTotalRunTime );
|
|
|
|
/* For percentage calculations. */
|
|
ulTotalRunTime /= 100UL;
|
|
|
|
/* Avoid divide by zero errors. */
|
|
if( ulTotalRunTime > 0 )
|
|
{
|
|
/* For each populated position in the pxTaskStatusArray array,
|
|
format the raw data as human readable ASCII data. */
|
|
for( x = 0; x < uxArraySize; x++ )
|
|
{
|
|
/* What percentage of the total run time has the task used?
|
|
This will always be rounded down to the nearest integer.
|
|
ulTotalRunTimeDiv100 has already been divided by 100. */
|
|
ulStatsAsPercentage =
|
|
pxTaskStatusArray[ x ].ulRunTimeCounter / ulTotalRunTime;
|
|
|
|
if( ulStatsAsPercentage > 0UL )
|
|
{
|
|
sprintf( pcWriteBuffer, "%-32s %-10llu %-10lu%% %d\r\n",
|
|
pxTaskStatusArray[ x ].pcTaskName,
|
|
(uint64_t)pxTaskStatusArray[ x ].ulRunTimeCounter,
|
|
ulStatsAsPercentage,
|
|
(int)pxTaskStatusArray[ x ].usStackHighWaterMark);
|
|
}
|
|
else
|
|
{
|
|
/* If the percentage is zero here then the task has
|
|
consumed less than 1% of the total run time. */
|
|
sprintf( pcWriteBuffer, "%-32s %-10llu <1%% %d\r\n",
|
|
pxTaskStatusArray[ x ].pcTaskName,
|
|
(uint64_t)pxTaskStatusArray[ x ].ulRunTimeCounter,
|
|
(int)pxTaskStatusArray[ x ].usStackHighWaterMark);
|
|
}
|
|
|
|
pcWriteBuffer += strlen( ( char * ) pcWriteBuffer );
|
|
}
|
|
}
|
|
|
|
/* The array is no longer needed, free the memory it consumes. */
|
|
vPortFree( pxTaskStatusArray );
|
|
}
|
|
}
|
|
#endif
|