/******************************************************************************
* FunctionName : espconn_port
* Description : access port value for client so that we don't end up bouncing
* all connections at the same time .
* Parameters : none
* Returns : access port value
*******************************************************************************/
uint32 ICACHE_FLASH_ATTR
espconn_port(void)
{
uint32 port = 0;
static uint32 randnum = 0;
do {
port = esp_random();
if (port < 0) {
port = esp_random() - port;
}
port %= 0xc350;
if (port < 0x400) {
port += 0x400;
}
} while (port == randnum);
randnum = port;
return port;
}
void homekit_random_fill(uint8_t *data, size_t size) {
uint32_t x;
for (int i=0; i<size; i+=sizeof(x)) {
x = esp_random();
memcpy(data+i, &x, (size-i >= sizeof(x)) ? sizeof(x) : size-i);
}
}
static int myrand( void *rng_state, unsigned char *output, size_t len )
{
size_t i;
for( i = 0; i < len; ++i )
output[i] = esp_random();
return( 0 );
}
long random(long howbig)
{
uint32_t x = esp_random();
uint64_t m = uint64_t(x) * uint64_t(howbig);
uint32_t l = uint32_t(m);
if (l < howbig) {
uint32_t t = -howbig;
if (t >= howbig) {
t -= howbig;
if (t >= howbig)
t %= howbig;
}
while (l < t) {
x = esp_random();
m = uint64_t(x) * uint64_t(howbig);
l = uint32_t(m);
}
}
return m >> 32;
}
void esp_fill_random(void *buf, size_t len)
{
assert(buf != NULL);
uint8_t *buf_bytes = (uint8_t *)buf;
while (len > 0) {
uint32_t word = esp_random();
uint32_t to_copy = MIN(sizeof(word), len);
memcpy(buf_bytes, &word, to_copy);
buf_bytes += to_copy;
len -= to_copy;
}
}
void AudioHandler::insert_cassette(const CassetteCollection &cassettes) {
if(cassettes.size() == 0)
return;
insert_cassette(cassettes.at(esp_random()%cassettes.size()));
}
static void mqtt_client_thread(void *pvParameters)
{
char *payload = NULL;
MQTTClient client;
Network network;
int rc = 0;
char clientID[32] = {0};
uint32_t count = 0;
ESP_LOGI(TAG, "ssid:%s passwd:%s sub:%s qos:%u pub:%s qos:%u pubinterval:%u payloadsize:%u",
CONFIG_WIFI_SSID, CONFIG_WIFI_PASSWORD, CONFIG_MQTT_SUB_TOPIC,
CONFIG_DEFAULT_MQTT_SUB_QOS, CONFIG_MQTT_PUB_TOPIC, CONFIG_DEFAULT_MQTT_PUB_QOS,
CONFIG_MQTT_PUBLISH_INTERVAL, CONFIG_MQTT_PAYLOAD_BUFFER);
ESP_LOGI(TAG, "ver:%u clientID:%s keepalive:%d username:%s passwd:%s session:%d level:%u",
CONFIG_DEFAULT_MQTT_VERSION, CONFIG_MQTT_CLIENT_ID,
CONFIG_MQTT_KEEP_ALIVE, CONFIG_MQTT_USERNAME, CONFIG_MQTT_PASSWORD,
CONFIG_DEFAULT_MQTT_SESSION, CONFIG_DEFAULT_MQTT_SECURITY);
ESP_LOGI(TAG, "broker:%s port:%u", CONFIG_MQTT_BROKER, CONFIG_MQTT_PORT);
ESP_LOGI(TAG, "sendbuf:%u recvbuf:%u sendcycle:%u recvcycle:%u",
CONFIG_MQTT_SEND_BUFFER, CONFIG_MQTT_RECV_BUFFER,
CONFIG_MQTT_SEND_CYCLE, CONFIG_MQTT_RECV_CYCLE);
MQTTPacket_connectData connectData = MQTTPacket_connectData_initializer;
NetworkInit(&network);
if (MQTTClientInit(&client, &network, 0, NULL, 0, NULL, 0) == false) {
ESP_LOGE(TAG, "mqtt init err");
vTaskDelete(NULL);
}
payload = malloc(CONFIG_MQTT_PAYLOAD_BUFFER);
if (!payload) {
ESP_LOGE(TAG, "mqtt malloc err");
} else {
memset(payload, 0x0, CONFIG_MQTT_PAYLOAD_BUFFER);
}
for (;;) {
ESP_LOGI(TAG, "wait wifi connect...");
xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY);
if ((rc = NetworkConnect(&network, CONFIG_MQTT_BROKER, CONFIG_MQTT_PORT)) != 0) {
ESP_LOGE(TAG, "Return code from network connect is %d", rc);
continue;
}
connectData.MQTTVersion = CONFIG_DEFAULT_MQTT_VERSION;
sprintf(clientID, "%s_%u", CONFIG_MQTT_CLIENT_ID, esp_random());
connectData.clientID.cstring = clientID;
connectData.keepAliveInterval = CONFIG_MQTT_KEEP_ALIVE;
connectData.username.cstring = CONFIG_MQTT_USERNAME;
connectData.password.cstring = CONFIG_MQTT_PASSWORD;
connectData.cleansession = CONFIG_DEFAULT_MQTT_SESSION;
ESP_LOGI(TAG, "MQTT Connecting");
if ((rc = MQTTConnect(&client, &connectData)) != 0) {
ESP_LOGE(TAG, "Return code from MQTT connect is %d", rc);
network.disconnect(&network);
continue;
}
ESP_LOGI(TAG, "MQTT Connected");
#if defined(MQTT_TASK)
if ((rc = MQTTStartTask(&client)) != pdPASS) {
ESP_LOGE(TAG, "Return code from start tasks is %d", rc);
} else {
ESP_LOGI(TAG, "Use MQTTStartTask");
}
#endif
if ((rc = MQTTSubscribe(&client, CONFIG_MQTT_SUB_TOPIC, CONFIG_DEFAULT_MQTT_SUB_QOS, messageArrived)) != 0) {
ESP_LOGE(TAG, "Return code from MQTT subscribe is %d", rc);
network.disconnect(&network);
continue;
}
ESP_LOGI(TAG, "MQTT subscribe to topic %s OK", CONFIG_MQTT_SUB_TOPIC);
for (;;) {
MQTTMessage message;
message.qos = CONFIG_DEFAULT_MQTT_PUB_QOS;
message.retained = 0;
message.payload = payload;
sprintf(payload, "message number %d", ++count);
message.payloadlen = strlen(payload);
if ((rc = MQTTPublish(&client, CONFIG_MQTT_PUB_TOPIC, &message)) != 0) {
ESP_LOGE(TAG, "Return code from MQTT publish is %d", rc);
} else {
ESP_LOGI(TAG, "MQTT published topic %s, len:%u heap:%u", CONFIG_MQTT_PUB_TOPIC, message.payloadlen, esp_get_free_heap_size());
}
if (rc != 0) {
break;
}
vTaskDelay(CONFIG_MQTT_PUBLISH_INTERVAL / portTICK_RATE_MS);
}
network.disconnect(&network);
}
ESP_LOGW(TAG, "mqtt_client_thread going to be deleted");
vTaskDelete(NULL);
return;
}
uint32_t homekit_random() {
return esp_random();
}
static int IRAM_ATTR rand_wrapper(void)
{
return (int)esp_random();
}
