ESP32 Forum

Code: Select all

//use the ESP32 hardware SPI to obtain data from a MAX31855 thermocouple amplifier.

1.  Initialize the ESP32, informing it of the HSPI standard pins to be used, clock rate, MISO, CS, CLK pins, setting MOSI -1.
2.  Add the device and get a handle to it.
3. in a loop
    3.1 put the Chip Select (CS) pin high.  
    3.2 delay to settle
    3.3 put the CS pin low.  This causes the MAX31855 to provide 32 bits of data on the MISO line.
    3.4 Read this data from obtained from the MISO.  Save it as 'value' var.
    3.5 bit and 0x80000000 to get the sign bit and save it in 'sign' var.
    3.6 if sign bit not set then proceed, otherwise convert to negative values.  I won't have negative values in my project, so not an issue for me.
    3.7 strip the sign bit by anding 'value' with 0x7FF00000, then shift >> 20 and save as 'CelsiusRawData' var (I'm not concerned with fractions of temperature, so shift them out too; 2 extra bits)
    3.8 get the cold juction temperature sign by anding with 0x8000 and save as 'CJSign' var
    3.9 get the internal cold juction temperature by anding 'value' with 0x7ff0 and shift >> 4 and storing in 'CJRaw' var
    3.10 get error occurred by anding with 0x7 and storing in 'Error' var; take appropriate action if not 0.
    3.11 multiply the CelsiusRawData by .25 (? - not yet sure of this value) to convert to Celsius value, store in 'Celsius' var
    3.12 multiply the CJRaw by .25 (?) to convert to Celcius CJ temperature, store in 'CJ' var.
    3.13 send results to MQTT broker
    3.14 repeat loop to step 3.

Code: Select all

uint8_t data;
spi.transfer(&data, 32 );
<--- data is keeping stored value 

Code: Select all

        uint32_t thermocoupleData = 0;

        buscfg.mosi_io_num = HSPI_MOSI;
        buscfg.miso_io_num = HSPI_MISO;
        buscfg.sclk_io_num = HSPI_SCK;
        buscfg.quadwp_io_num = -1;
        buscfg.quadhd_io_num = -1;
        buscfg.max_transfer_sz = 4;  //4 BYTES???
        buscfg.flags = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_MISO | SPICOMMON_BUSFLAG_SCLK;

        devcfg.command_bits = 0;
        devcfg.address_bits = 0;
        devcfg.dummy_bits = 0;      //note this; if dropping bits at start of cycle
        devcfg.mode = 0;           //0,1,2,3.  has to do with clock polarity, phase, and edge.  See wikipedia.org for spi mode numbers
        devcfg.duty_cycle_pos = 0; // setting to 0 defaults to 128, 50% duty cycle
        devcfg.cs_ena_pretrans = 0;  //amount of spi bit-cycles cs activated before transmission.
        devcfg.cs_ena_posttrans = 0;  //sim to pretrans, but trailing
        devcfg.clock_speed_hz = 10000; //10 khz; clock speed in hz
        devcfg.spics_io_num = HSPI_SS;  //CS GPIO pin, -1 if not used
        devcfg.flags = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_MISO | SPICOMMON_BUSFLAG_SCLK;  //spi_device_ flags
        devcfg.queue_size = 1; //queue depth.  0 will cause crash
        devcfg.pre_cb = NULL; //callback before trans ========not sure here
        devcfg.post_cb = NULL; //callback after trans ========not sure here

        trans_desc.addr =0;
        trans_desc.cmd = 0;
        trans_desc.flags = SPI_TRANS_USE_RXDATA;
        trans_desc.length = 32;
        trans_desc.rxlength = 32;
        trans_desc.tx_buffer = NULL;  //docs specify NULL for no MOSI phase.
        trans_desc.rx_buffer = &thermocoupleData;

Code: Select all

#include "SPI.h"
#include <iostream>


extern "C" {
    void app_main(void);
};

void app_main(void) {
    std::cout << "MAIN LOOP START\n\n\n";

    SPI spi = SPI();

    spi.setHost(HSPI_HOST);
    spi.init(spi.DEFAULT_MOSI_PIN, spi.DEFAULT_MISO_PIN, spi.DEFAULT_CLK_PIN, spi.DEFAULT_CS_PIN);


    uint8_t v = 'A';
    uint8_t r;

    while(1) {
        r = spi.transferByte(v);
        printf("Returned data: %u \n",r);  //always 1
    };
};

Code: Select all

/* 
* MAX31855 Thermocouple Temperature Software - for type K
* Author: BBQBailey, see //github.com/bbqbailey for updates
* Date: May 13, 2018
* Rev: 1.0
* Purpose: Software for MAX31855 on ESP32
*   I was not able to use the Espressif SPI code to work
*   correctly with my MAX31855 thermocouple amplifier for 
*   type K thermocouples, so I wrote this code.  
*   It does not use the hardware SPI capabilities. 
*   Instead, it generates its own clock pulses, and reads the bit 
*   responses.
*
*   It works correctly for me without any vTaskDelay() calls between
*   CLK, CS, MISO signals.
*
* Future Releases:
*   - Add calculations for negative temperatures
*   - Use interrupt callbacks instead of vTaskDelay(), which is a blocking call.
*   - Add web page host
*   - Add MQTT broker communications
*/

#include <iostream>
#include <driver/gpio.h>
#include <freertos/FreeRTOS.h> //for vTaskDelay();
#include <freertos/task.h>     //for vTaskDelay();

//NOTE: the following pins all have an LED attached to them.  Low causes light
#define CS   16  //output - CHIP SELECT
#define CLK  17  //output - CLOCK
#define DATA 18  //input  - DATA AKA MISO

extern "C" {
    void app_main(void);
}

void app_main(void) {
    int valueBit = 0;
    uint32_t rawData = 0;
    uint32_t  error = 0;
    uint8_t  signInt = 0;
    uint8_t  signC = 0;

    float tempIntC = 0.0;
    float tempIntF = 0.0;
    float tempC = 0.0;
    float tempF = 0.0;

    //assign GPI functions
    gpio_set_direction(gpio_num_t(CS), GPIO_MODE_OUTPUT);
    gpio_set_direction(gpio_num_t(CLK), GPIO_MODE_OUTPUT);
    gpio_set_direction(gpio_num_t(DATA), GPIO_MODE_INPUT);

    //start doing it!
    gpio_set_level(gpio_num_t(CS), 1);
    gpio_set_level(gpio_num_t(CLK), 0);

    //create our own clock pulses, then read data bits
    while(1) {
        gpio_set_level(gpio_num_t(CS), 0);  //enable chip
//        vTaskDelay(10);  //uncomment if you are having problems to give chip time to synch with clock

        //get the 32 bits from MAX31855
        //   generate clock pulse high, then read data bit, then clock pulse low
        std::cout << "Binary data received from MAX31855: ";
        for(int i=0;i<31;i++) {
            gpio_set_level(gpio_num_t(CLK), 1);  //clock pulse going high - start pulse
//            vTaskDelay(10);  //uncomment if synch problem
            valueBit = gpio_get_level(gpio_num_t(DATA));  //get bit
            rawData <<= 1;
            rawData += 0x01 & valueBit;  
//            vTaskDelay(10);  //uncomment if synch problem
            gpio_set_level(gpio_num_t(CLK), 0);  //clock pulse going low - end pulse
//            vTaskDelay(10);  //uncomment if synch problem
            std::cout << valueBit;
        }
        gpio_set_level(gpio_num_t(CS), 1);
        std::cout << "\n";

        printf("rawData: 0x%x\n", rawData);
        error = rawData & 0x7;
        if(error) {
            printf("-----Error reported by chip.  Value is: 0x%x\n", error);
            printf("     Following values are probably bad.\n");
        }

        signInt = (rawData & 0x8000) >> 4;
        signC   = (rawData & 0x80000000) >> 31;


        if((signInt == 0) && (signC == 0)) {

            tempIntC = float((rawData >> 4) & 0x7FF) * 0.0625;
            tempIntF = tempIntC * 1.8 + 32.0;
            tempC   = (float((rawData >> 18) & 0x7FFC) * .25 + tempIntC);
            tempF   = tempC * 1.8 + 32.0;
            printf("error: ox%x\n", error);  //will not be zero if error returned from chip
            printf("signInt: ox%x\n", signInt);
            printf("signC: ox%x\n", signC);
            printf("tempIntC: %6.2f \n", tempIntC);
            printf("tempIntF: %6.2f \n", tempIntF);
            printf("tempC: %6.2f \n", tempC);
            printf("TempF: %6.2f \n", tempF);
        }   else  {
            std::cout << "-----negative temperatures not yet implemented.-----\n";
        }

        vTaskDelay(15000);  //or what ever you want.
    }
}

Code: Select all

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "soc/gpio_struct.h"
#include "driver/gpio.h"
#include "driver/spi_common.h"
#include "driver/spi_master.h"
#include "sdkconfig.h"

#define DO 12           // slave Data Out
#define CSL 5            // chip select
#define CLK 14          // spi clock
#define SAMPLE_COUNT 10 // consecutive readouts

typedef struct
{
    float internal_C;
    float thermocouple_C;
    float internal_F;
    float thermocouple_F;
    bool fault;
    bool short_to_VCC;
    bool short_to_GND;
    bool open_circuit;
} max31855_data_t;

xQueueHandle callback_queue;

esp_err_t ret;
spi_device_handle_t spi;
spi_bus_config_t buscfg =
{
    .flags              = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_MISO | SPICOMMON_BUSFLAG_SCLK,
    .miso_io_num        = DO,
    .mosi_io_num        = -1,
    .sclk_io_num        = CLK,
    .quadwp_io_num      = -1,
    .quadhd_io_num      = -1,
    .max_transfer_sz    = 4
};
spi_device_interface_config_t devcfg =
{
    .command_bits       = 0,
    .address_bits       = 0,
    .dummy_bits         = 0,        //note this; if dropping bits at start of cycle
    .duty_cycle_pos     = 0,        // setting to 0 defaults to 128, 50% duty cycle
    .cs_ena_pretrans    = 0,        //amount of spi bit-cycles cs activated before transmission.
    .cs_ena_posttrans   = 0,        //sim to pretrans, but trailing
    .mode               = 0,        //0,1,2,3.  has to do with clock polarity, phase, and edge.  See wikipedia.org for spi mode numbers
    .clock_speed_hz = 4*1000*1000,  //Clock out at  MHz
    .spics_io_num   = CSL,           //CS pin
    .queue_size     = 1, // nr transactions at a time
    .pre_cb         = NULL,//enable_thermocouple_chip,         //callback before trans
    .post_cb        = NULL//disable_thermocouple_chip          //callback after trans
};


void app_main()
{
    gpio_set_direction(CSL, GPIO_MODE_INPUT);

    ret = spi_bus_initialize(HSPI_HOST, &buscfg, 0);
    ret = spi_bus_add_device(HSPI_HOST, &devcfg, &spi);

    uint32_t thermocouple_data;
    max31855_data_t dt;


    for(;;)
    {
    spi_transaction_t t =
    {
        .addr = 0,
        .cmd = 0,
        .flags = SPI_TRANS_USE_RXDATA,
        .length = 32,
        .rxlength = 32,
        .user = NULL,
        .tx_buffer = NULL,
        .rx_buffer = NULL,
    };

    spi_device_transmit(spi, &t);

    thermocouple_data = ((uint32_t)t.rx_data[0] << 24) | ((uint32_t)t.rx_data[1] << 16) | ((uint32_t)t.rx_data[2] << 8) | (uint32_t)t.rx_data[3];

    int16_t internal_data= (int16_t)(thermocouple_data & 0xFFFF);
    dt.internal_C = (internal_data/256) + (((uint8_t)internal_data>>4) & 0xF) * 0.0625f;
   
    int16_t thermal_data = (int16_t)(thermocouple_data >> 18);
    dt.thermocouple_C=(thermal_data/4) + (((uint8_t)thermal_data) & 3) * 0.25f + dt.internal_C;
    
    dt.internal_F = dt.internal_C * 1.8f + 32.0f;
    dt.thermocouple_F  = dt.thermocouple_C * 1.8f + 32.0f;
    
    dt.fault = (thermocouple_data >> 16) & 1;
    dt.short_to_VCC = internal_data & 4;
    dt.short_to_GND = internal_data & 2;
    
    printf("C: %6.2f \n", dt.thermocouple_C);
    printf("F: %6.2f \n", dt.thermocouple_F);
    printf("Ci: %6.2f \n", dt.internal_C);
    printf("Fi: %6.2f \n", dt.internal_F);

    printf("error: 0x%x\n", dt.fault);
    printf("VCC: 0x%x\n", dt.short_to_VCC);
    printf("GND: 0x%x\n", dt.short_to_GND);
    
    vTaskDelay(100 / portTICK_RATE_MS);
    }
}