Article Index

Page 12 of 16

Page 292

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "driver/gpio.h"
#include "driver/gptimer.h"
#include <unistd.h>

void delay_us(int t)
{
    usleep(t);
}
gptimer_handle_t tick_us_start(void) {
  gptimer_config_t timer_config = {
      .clk_src = GPTIMER_CLK_SRC_DEFAULT,
      .direction = GPTIMER_COUNT_UP,
      .resolution_hz = 1000000,
  };
  gptimer_handle_t gptimer_us = NULL;
  gptimer_new_timer(&timer_config, &gptimer_us);
  gptimer_enable(gptimer_us);
  gptimer_start(gptimer_us);
  return gptimer_us;
}

int64_t tick_us(gptimer_handle_t gptimer_us, int64_t offset) {
  uint64_t count;
  gptimer_get_raw_count(gptimer_us, &count);
  return count + offset;
}
void app_main(void)
{
    gptimer_handle_t timer = tick_us_start();
    gpio_reset_pin(2);
    gpio_set_direction(2, GPIO_MODE_OUTPUT);
    gpio_set_level(2, 1);
    delay_us(1000);
    gpio_set_level(2, 0);
    delay_us(1000);
    gpio_set_direction(2, GPIO_MODE_INPUT);

    while (gpio_get_level(2) == 1)
    {
    };
    while (gpio_get_level(2) == 0)
    {
    };
    while (gpio_get_level(2) == 1)
    {
    };

    int64_t t2;
    uint32_t data = 0;
    int64_t t1 = tick_us(timer, 0);
    for (int i = 0; i < 32; i++)
    {
        while (gpio_get_level(2) == 0)
        {
        };
        while (gpio_get_level(2) == 1)
        {
        };

        t2 = tick_us(timer, 0);
        data = data << 1;
        data = data | ((t2 - t1) > 100);
        t1 = t2;
    }

    uint8_t checksum = 0;
    for (int i = 0; i < 8; i++)
    {
        while (gpio_get_level(2) == 0)
        {
        };
        while (gpio_get_level(2) == 1)
        {
        };
        t2 = tick_us(timer, 0);
        checksum = checksum << 1;
        checksum = checksum | ((t2 - t1) > 100);
        t1 = t2;
    }

    printf("data %ld\n", data);
    uint8_t byte1 = (data >> 24 & 0xFF);
    uint8_t byte2 = (data >> 16 & 0xFF);
    uint8_t byte3 = (data >> 8 & 0xFF);
    uint8_t byte4 = (data & 0xFF);

    printf("Checksum %X %X\n", checksum,
           (byte1 + byte2 + byte3 + byte4) & 0xFF);
    float humidity = (float)((byte1 << 8) | byte2) / 10.0;
    printf("Humidity= %f %%\n", humidity);
    float temperature;
    int neg = byte3 & 0x80;
    byte3 = byte3 & 0x7F;
    temperature = (float)(byte3 << 8 | byte4) / 10.0;
    if (neg > 0)
        temperature = -temperature;
    printf("Temperature= %f C\n", temperature);
}

 

Page 294 from fragment

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "driver/gpio.h"
#include <unistd.h>

void delay_us(int t)
{
    usleep(t);
}

void app_main(void)
{
    gpio_reset_pin(2);
    gpio_set_direction(2, GPIO_MODE_OUTPUT);
    gpio_set_level(2, 1);
    delay_us(1000);
    gpio_set_level(2, 0);
    delay_us(1000);
    gpio_set_direction(2, GPIO_MODE_INPUT);

    while (gpio_get_level(2) == 1)
    {
    };
    while (gpio_get_level(2) == 0)
    {
    };
    while (gpio_get_level(2) == 1)
    {
    };

    uint32_t data = 0;
    for (int i = 0; i < 32; i++)
    {
        while (gpio_get_level(2) == 0)
        {
        };
        delay_us(50);
        data = data << 1;
        data = data | gpio_get_level(2);
        while (gpio_get_level(2) == 1)
        {
        };
    }

    uint8_t checksum = 0;
    for (int i = 0; i < 8; i++)
    {
        while (gpio_get_level(2) == 0)
        {
        };
        delay_us(50);
        checksum = checksum << 1;
        checksum = checksum | gpio_get_level(2);
        while (gpio_get_level(2) == 1)
        {
        };
    }

    printf("data %ld\n", data);
    uint8_t byte1 = (data >> 24 & 0xFF);
    uint8_t byte2 = (data >> 16 & 0xFF);
    uint8_t byte3 = (data >> 8 & 0xFF);
    uint8_t byte4 = (data & 0xFF);

    printf("Checksum %X %X\n", checksum,
           (byte1 + byte2 + byte3 + byte4) & 0xFF);
    float humidity = (float)((byte1 << 8) | byte2) / 10.0;
    printf("Humidity= %f %%\n", humidity);
    float temperature;
    int neg = byte3 & 0x80;
    byte3 = byte3 & 0x7F;
    temperature = (float)(byte3 << 8 | byte4) / 10.0;
    if (neg > 0)
        temperature = -temperature;
    printf("Temperature= %f C\n", temperature);
}

 

Page 298

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "driver/gpio.h"
#include "driver/rmt_rx.h"
#include <unistd.h>

TaskHandle_t taskhandle;

void delay_us(int t)
{
    usleep(t);
}

bool rmtrxDone(rmt_channel_handle_t channel,
               const rmt_rx_done_event_data_t *edata, void *user_data)
{
    xTaskResumeFromISR(*(TaskHandle_t *)user_data);
    return true;
}

rmt_symbol_word_t raw_symbols[100];

void app_main(void)
{
    rmt_rx_channel_config_t rmtrxconfig = {
        .gpio_num = 2,
        .resolution_hz = 1000000,
        .mem_block_symbols = 100,
        .clk_src = RMT_CLK_SRC_DEFAULT,
        .flags.invert_in = false,
        .flags.with_dma = false,
    };
    rmt_channel_handle_t rmtrxHandle;
    rmt_new_rx_channel(&rmtrxconfig, &rmtrxHandle);

    rmt_rx_event_callbacks_t cbs = {
        .on_recv_done = rmtrxDone};
    taskhandle = xTaskGetCurrentTaskHandle();
    rmt_rx_register_event_callbacks(rmtrxHandle, &cbs, &taskhandle);
    rmt_enable(rmtrxHandle);

    rmt_receive_config_t receive_config = {
        .signal_range_min_ns = 2000,
        .signal_range_max_ns = 900000,
    };

    while (true)
    {
        gpio_reset_pin(2);
        gpio_set_direction(2, GPIO_MODE_OUTPUT);
        gpio_set_level(2, 1);
        delay_us(1000);
        gpio_set_level(2, 0);
        delay_us(1000);
        gpio_set_direction(2, GPIO_MODE_INPUT);

        while (gpio_get_level(2) == 1)
        {
        };
        while (gpio_get_level(2) == 0)
        {
        };
        while (gpio_get_level(2) == 1)
        {
        };

        rmt_receive(rmtrxHandle, raw_symbols, sizeof(raw_symbols),
                    &receive_config);
        vTaskSuspend(taskhandle);

        uint8_t byte1 = 0;
        uint8_t byte2 = 0;
        uint8_t byte3 = 0;
        uint8_t byte4 = 0;
        uint8_t checksum = 0;

        for (int i = 0; i < 40; i = i + 1)
        {
            switch (i / 8)
            {
            case 0:
                byte1 = byte1 << 1;
                byte1 = byte1 | (raw_symbols[i].duration0 > 50);
                break;
            case 1:
                byte2 = byte2 << 1;
                byte2 = byte2 | (raw_symbols[i].duration0 > 50);
                break;
            case 2:
                byte3 = byte3 << 1;
                byte3 = byte3 | (raw_symbols[i].duration0 > 50);
                break;
            case 3:
                byte4 = byte4 << 1;
                byte4 = byte4 | (raw_symbols[i].duration0 > 50);
                break;
            case 4:
                checksum = checksum << 1;
                checksum = checksum | (raw_symbols[i].duration0 > 50);
                break;
            }
        }

        printf("Checksum %X %X\n", checksum,
               (byte1 + byte2 + byte3 + byte4) & 0xFF);
        float humidity = (float)((byte1 << 8) | byte2) / 10.0;
        printf("Humidity= %f %%\n", humidity);
        float temperature;
        int neg = byte3 & 0x80;
        byte3 = byte3 & 0x7F;
        temperature = (float)(byte3 << 8 | byte4) / 10.0;
        if (neg > 0)
            temperature = -temperature;
        printf("Temperature= %f C\n", temperature);
        delay_us(1000000);
    }
}

 

Page 311

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "driver/gpio.h"
#include <unistd.h>

void delay_us(int t)
{
    usleep(t);
}

uint8_t readBit(uint8_t pin)
{
    gpio_set_level(pin, 0);
    delay_us(2);
    gpio_set_level(pin, 1);
    delay_us(5);
    uint8_t b = gpio_get_level(pin);
    delay_us(60);
    return b;
}

void writeBit(uint8_t pin, int b)
{
    int delay1, delay2;
    if (b == 1)
    {
        delay1 = 6;
        delay2 = 64;
    }
    else
    {
        delay1 = 60;
        delay2 = 10;
    }
    gpio_set_level(pin, 0);
    delay_us(delay1);
    gpio_set_level(pin, 1);
    delay_us(delay2);
}

int readByte(uint8_t pin)
{
    int byte = 0;
    for (int i = 0; i < 8; i++)
    {
        byte = byte | readBit(pin) << i;
    };
    return byte;
}
void writeByte(uint8_t pin, int byte)
{
    for (int i = 0; i < 8; i++)
    {
        if (byte & 1)
        {
            writeBit(pin, 1);
        }
        else
        {
            writeBit(pin, 0);
        }
        byte = byte >> 1;
    }
}

int presence(int pin)
{
    gpio_reset_pin(pin);
    gpio_set_direction(pin, GPIO_MODE_INPUT_OUTPUT_OD);
    gpio_set_level(pin, 1);
    delay_us(1000);
    gpio_set_level(pin, 0);
    delay_us(480);
    gpio_set_level(pin, 1);
    delay_us(70);
    int res = gpio_get_level(pin);
    delay_us(410);
    return res;
}

int convert(uint8_t pin)
{
    writeByte(pin, 0x44);
    int i;
    for (i = 0; i < 500; i++)
    {
        delay_us(10000);
        if (readBit(pin) == 1)
            break;
    }
    return i;
}
uint8_t crc8(uint8_t *data, uint8_t len)
{
    uint8_t temp;
    uint8_t databyte;
    uint8_t crc = 0;
    for (int i = 0; i < len; i++)
    {
        databyte = data[i];
        for (int j = 0; j < 8; j++)
        {
            temp = (crc ^ databyte) & 0x01;
            crc >>= 1;
            if (temp)
                crc ^= 0x8C;

            databyte >>= 1;
        }
    }
    return crc;
}

float getTemperature(uint8_t pin)
{
    if (presence(pin) == 1)
        return -1000;
    writeByte(pin, 0xCC);
    if (convert(pin) == 500)
        return -3000;
    presence(pin);
    writeByte(pin, 0xCC);
    writeByte(pin, 0xBE);
    uint8_t data[9];
    for (int i = 0; i < 9; i++)
    {
        data[i] = readByte(pin);
    }
    uint8_t crc = crc8(data, 9);
    if (crc != 0)
        return -2000;
    int t1 = data[0];
    int t2 = data[1];
    int16_t temp1 = (t2 << 8 | t1);
    float temp = (float)temp1 / 16;
    return temp;
}
void app_main(void)
{
    while (true)
    {
        float temp = getTemperature(2);
        printf("temperature=%f\n", temp);
        delay_us(1000000);
    }
}

 

Page 318  ESP32 S3

#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"

void writeGRB(int pin, int GRB)
{
    int mask = 0x800000;
    volatile int duty = 0;
    for (int j = 0; j < 24; j++)
    {
        gpio_set_level(pin, 1);
        if ((GRB & mask))
        {
            for (volatile int i = 0; i < 3; i++)
            {
            }
            duty = 0;
            duty = 0;
            gpio_set_level(pin, 0);
            duty++;
            duty = 0;
            duty = 0;
            duty = 0;
        }
        else
        {
            duty = 0;
            gpio_set_level(pin, 0);
            for (volatile int i = 0; i < 5; i++)
            {
            }
        }

        mask = mask >> 1;
    }
    vTaskDelay(60 / portTICK_PERIOD_MS);
}

void app_main(void)
{
    int pin = 48;
    gpio_reset_pin(pin);
    gpio_set_direction(pin, GPIO_MODE_OUTPUT);
    gpio_set_level(pin, 0);
    vTaskDelay(10 / portTICK_PERIOD_MS);
    int color = 0x0000FF;
    writeGRB(pin, color);
    vTaskDelay(1000 / portTICK_PERIOD_MS);
    color = 0x00FF00;
    writeGRB(pin, color);
    vTaskDelay(1000 / portTICK_PERIOD_MS);
    color = 0xFF0000;
    writeGRB(pin, color);
    vTaskDelay(1000 / portTICK_PERIOD_MS);
}

 

Page 319  complete program

#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"

void writeGRB(int pin, int GRB)
{
    int mask = 0x800000;
    volatile int duty = 0;
    for (int j = 0; j < 24; j++)
    {
        gpio_set_level(pin, 1);
        if ((GRB & mask))
        {
            for (volatile int i = 0; i < 2; i++)
            {
            }
            duty = 0;
            gpio_set_level(pin, 0);
            duty = 0;
            duty = 0;
            duty = 0;
            duty = 0;
        }
        else
        {
            gpio_set_level(pin, 0);
            for (volatile int i = 0; i < 3; i++)
            {
            }
            duty = 0;
        }
        vTaskDelay(60 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{
    int pin = 48;
    gpio_reset_pin(pin);
    gpio_set_direction(pin, GPIO_MODE_OUTPUT);
    gpio_set_level(pin, 0);
    vTaskDelay(10 / portTICK_PERIOD_MS);
    int color = 0x0000FF;
    writeGRB(pin, color);
    vTaskDelay(1000 / portTICK_PERIOD_MS);
    color = 0x00FF00;
    writeGRB(pin, color);
    vTaskDelay(1000 / portTICK_PERIOD_MS);
    color = 0xFF0000;
    writeGRB(pin, color);
    vTaskDelay(1000 / portTICK_PERIOD_MS);
}
 

Page 321

#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "driver/rmt_tx.h"

void convertGRB(int GRB, rmt_symbol_word_t *rawdata)
{
    int mask = 0x800000;
    for (int j = 0; j < 24; j++)
    {
        if ((GRB & mask))
        {
            rawdata[j].level0 = 1;
            rawdata[j].duration0 = 7;
            rawdata[j].level1 = 0;
            rawdata[j].duration1 = 12 - 7;
        }
        else
        {
            rawdata[j].level0 = 1;
            rawdata[j].duration0 = 3;
            rawdata[j].level1 = 0;
            rawdata[j].duration1 = 12 - 3;
        }
        mask = mask >> 1;
    }
}

rmt_symbol_word_t raw_symbols[100];

void app_main(void)
{

    int pin = 2;
    rmt_channel_handle_t led_chan = NULL;
    rmt_tx_channel_config_t tx_chan_config = {
        .clk_src = RMT_CLK_SRC_DEFAULT,
        .gpio_num = pin,
        .mem_block_symbols = 64,
        .resolution_hz = 10000000,
        .trans_queue_depth = 4,
        .flags.with_dma = false,
    };
    rmt_new_tx_channel(&tx_chan_config, &led_chan);

    rmt_copy_encoder_config_t config = {};
    rmt_encoder_handle_t encoder = NULL;
    rmt_new_copy_encoder(&config, &encoder);

    rmt_enable(led_chan);

    rmt_transmit_config_t txconf = {
        .loop_count = 1};
    int color = 0x00FFFF;
    convertGRB(color, raw_symbols);
    rmt_transmit(led_chan, encoder, raw_symbols, 24 * sizeof(rmt_symbol_word_t), &txconf);
    rmt_tx_wait_all_done(led_chan, 10000);
}