Farge nach einem K Typ Sensor ICs

[Christian (Gast)]

Hallo,

Kurze Frage: welche von der 3(4) ICs wäre die beste Lösung, um einen K 
Typ Temperatursensor auszulesen (auszuwerten)?
K Typ Sensor:
http://www.banggood.com/-50650-K-Type-Thermocouple-Probe-Digital-Temperature-Sensor-p-997580.html

-ADS1018
-Max31855 (MAX6675(alt))
-AD8497

Anforderungen: +- 1-2°C(Genauigkeit), max. 500°C, sollte auch nicht zu 
langsam sein, preislich unten 6-10€ pro Teil

Bei Analog Devices handelt es sich wahrscheinlich um den nackten 
Konverter. d.h. theoretisch mehr Programmieraufwand. TI hat SPI 
Interface, Maxim Integrated eine I2C.

PS: Für mich sieht TI auf den ersten Blick der Gewinner zu sein. Oder 
irre ich mich und der hat irgendwelche gravierende Nachteile?
PS2: Kennt jemand noch die Bezeichnung von der Büchse des K Typ Sensors? 
(d.h. für das Einbau in einem Gehäuse)

[Thomas (Gast)]

Kann dir den ADS1118 empfehlen. Habe ich schon mehrfach verwendet ohne 
Probleme.

Gruß

[Christian (Gast)]

Macht es Sinn statt ADS1018 einen ADS1118 zu holen?
http://www.ti.com/product/ADS1118

Die Geschwindigkeit mit der sich der Wert verändert, wäre mir wichtiger 
als so eine Abweichung von 1-2°C

http://www.ti.com/product/ADS1118

[Daniel (Gast)]

Thomas schrieb:
> Kann dir den ADS1118 empfehlen. Habe ich schon mehrfach verwendet ohne
> Probleme.

Hallo Thomas und alle anderen Wissenden ( ;) ),

Ich versuche seit einigen Stunden, den ADS1118 ans Laufen zu bekommen 
und so richtig will es nicht.
Ich habe im Anhang ein Screenshot vom Logic Analyzer, der verrät, dass 
der ADS den Befehl nicht zu akzeptieren scheint (bei der 
32Bit-Übertragung werden am Ende nicht die gesendeten Config-Bytes 
übertragen.
Bei Bedarf schick ich dir gern mehr als das minimale Anwendungsbeispiel 
unten und wäre auch über deinen Code dankbar.
Der ADS soll ebenfalls mit einem Typ-K Sensor verwendet werden und der 
ansteuernde µC ist ein ATMEGA8A, der mit nem Quarz auf 8MHz läuft.

Vielen Dank für die Hilfe,

Daniel


Anwendungsbeispiel:

aus main.c:

//(...)
void initialise(){
  spiInit(SPI_MODE_1, SPI_MSB, SPI_NO_INTERRUPT, 
  _delay_ms(500);
  blinkLED();
}
//(...)
int main(void)
{
  initialise();
  
  
  float temp1, temp2, temp3, temp4;
  

    while (1) 
    {                     
    
    // LED Status invertieren
    _delay_ms(500);
    LEDPORT ^= (1<<LEDstatus);          

    temp1 = perform16BitMeasurement(ADS_DEFAULT_CONFIG_LINKS);
    _delay_us(100);
    temp2 = perform16BitMeasurement(ADS_DEFAULT_CONFIG_LINKS_INT);
    _delay_us(100);
    temp3 = perform16BitMeasurement(ADS_DEFAULT_CONFIG_RECHTS);
    _delay_us(100);
    temp4 = perform16BitMeasurement(ADS_DEFAULT_CONFIG_RECHTS_INT);
    _delay_ms(500);
  }
}

aus SPIinit.h

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif


#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
#include <util/delay.h> 

#include <stdlib.h>




#ifndef SPIINIT_H_
#define SPIINIT_H_


//PinDef
#define SPI_SS_STAT_REG PINB
#define SPI_SS_PORT PORTB
#define SPI_SS_PIN PORTB2
#define SPI_SCK_PIN PORTB5
#define SPI_MOSI_PIN PORTB3
#define SPI_MISO_PIN PORTB4

//SPI clock modes
#define SPI_MODE_0 0x00 /* Sample (Rising) Setup (Falling) CPOL=0, CPHA=0 */
#define SPI_MODE_1 0x01 /* Setup (Rising) Sample (Falling) CPOL=0, CPHA=1 */
#define SPI_MODE_2 0x02 /* Sample (Falling) Setup (Rising) CPOL=1, CPHA=0 */
#define SPI_MODE_3 0x03 /* Setup (Falling) Sample (Rising) CPOL=1, CPHA=1 */

// data direction
#define SPI_LSB 1 /* LSB first */
#define SPI_MSB 0 /* MSB first */

// Interrupt when data received (SPIF bit received)
#define SPI_NO_INTERRUPT 0
#define SPI_INTERRUPT 1

// slave or master with clock div
#define SPI_SLAVE 0xF0
#define SPI_MSTR_CLK2 0x04 /* chip clock/2 */
#define SPI_MSTR_CLK4 0x00 /* chip clock/4 */
#define SPI_MSTR_CLK8 0x05 /* chip clock/8 */
#define SPI_MSTR_CLK16 0x01 /* chip clock/16 */
#define SPI_MSTR_CLK32 0x06 /* chip clock/32 */
#define SPI_MSTR_CLK64 0x02 /* chip clock/64 */
#define SPI_MSTR_CLK128 0x03 /* chip clock/128 */


void spiInit(  uint8_t mode,      // timing mode SPI_MODE[0-4]
        uint8_t dord,             // data direction SPI_LSB|SPI_MSB
        uint8_t interruptEnable, // whether to raise interrupt on recieve
        uint8_t msClock); // clock diviser

uint8_t spiTransceiveByte(uint8_t data, uint8_t eot);

#endif

aus SPIinit.c

#include "SPIinit.h"

//initialise the SPI Bus
void spiInit(uint8_t mode, uint8_t dord, uint8_t interruptEnable, uint8_t msClock)
{
  // specify pin directions for SPI pins on port B
  if (msClock == SPI_SLAVE) {            // if slave SS and SCK is input
    DDRB &= ~(1<<SPI_MOSI_PIN);          // input
    DDRB |= (1<<SPI_MISO_PIN);          // output
    DDRB &= ~(1<<SPI_SS_PIN);          // input
    DDRB &= ~(1<<SPI_SCK_PIN);          // input
    } else {
    DDRB |= (1<<SPI_MOSI_PIN);          // output
    DDRB &= ~(1<<SPI_MISO_PIN);          // input
    DDRB |= (1<<SPI_SCK_PIN);          // output
    DDRB |= (1<<SPI_SS_PIN);          // output
  }
  SPCR = ((interruptEnable ? 1 : 0)<<SPIE)    // interrupt enabled
  | (dord<<DORD)                  // LSB or MSB
  | (((msClock != SPI_SLAVE) ? 1 : 0) <<MSTR)    // Slave or Master
  | (((mode & 0x02) == 2) << CPOL)        // clock timing mode CPOL
  | (((mode & 0x01)) << CPHA)            // clock timing mode CPHA
  | (((msClock & 0x02) == 2) << SPR1)        // cpu clock divisor SPR1
  | ((msClock & 0x01) << SPR0);          // cpu clock divisor SPR0
  

  SPSR = (((msClock & 0x04) == 4) << SPI2X);    // clock divisor SPI2X
  
  SPCR |= (1<<SPE); //enable SPI
}

uint8_t spiTransceiveByte(uint8_t data, uint8_t eot){
  //pull down the slave select pin
  SPI_SS_PORT &= !(1<<SPI_SS_PIN);
  _delay_us(3);
  
  // Load data into the buffer
  SPDR = data;
  
  //Wait until transmission complete
  while(!(SPSR & (1<<SPIF)));
  
  //if end of transmission is reached, pull up the ssPin
  if(eot)  SPI_SS_PORT |= (1<<SPI_SS_PIN);
  
  // Return received data
  return SPDR;
}

aus tempADS1118.h

#include "SPIinit.h"
#include <stdlib.h>
#include <util/delay.h>
#include <stdint.h>

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif


#ifndef TEMPADS1118_H_
#define TEMPADS1118_H_


/* left ext sense
 * SingleShot (SS)
 * default MUX to left (MUX = 000; default)
 * lowest amplification (e.g. PGA = 101)
 * SingleShot + PowerDown (MODE = 1)
 * 16SPS DataRate (DR = 001)
 * ADC mode (TS_MODE = 0; default)
 * internal pullup resistor (PULL_UP_EN = 1)
 * no operation (NOP = 01) otherwise failure
 * Reserved always 1 (R=1)
 */

#define ADS_DEFAULT_CONFIG_LINKS 0b1000101100101011//1 000 101 1 001 0 1 01 1



/* right ext sense
 * SingleShot (SS)
 * MUX to right (MUX = 011)
 * lowest amplification (e.g. PGA = 101)
 * SingleShot + PowerDown (MODE = 1)
 * 16SPS DataRate (DR = 001)
 * internal pullup resistor (PULL_UP_EN = 1)
 * no operation (NOP = 01) otherwise failure
 * Reserved always 1 (R=1)
 * ADC mode (TS_MODE = 0; default)
 */

#define ADS_DEFAULT_CONFIG_RECHTS 0b1011101100101011//1 011 101 1 001 0 1 01 1


/* left int sense
 * SingleShot (SS)
 * MUX to left (MUX = 000; default)
 * lowest amplification (e.g. PGA = 101)
 * SingleShot + PowerDown (MODE = 1)
 * 16SPS DataRate (DR = 001)
 * internal pullup resistor (PULL_UP_EN = 1)
 * no operation (NOP = 01) otherwise failure
 * Reserved always 1 (R=1)
 * Tsense mode (TS_MODE = 0)
 */

#define ADS_DEFAULT_CONFIG_LINKS_INT 0b1000101100111011 //1 000 101 1 001 1 1 01 1



/* right int sense
 * SingleShot (SS)
 * MUX to right (MUX = 011)
 * lowest amplification (e.g. PGA = 101)
 * SingleShot + PowerDown (MODE = 1)
 * 16SPS DataRate (DR = 001)
 * Tsense mode (TS_MODE = 1)
 * internal pullup resistor (PULL_UP_EN = 1)
 * no operation (NOP = 01) otherwise failure
 * Reserved always 1 (R=1)
 */

#define ADS_DEFAULT_CONFIG_RECHTS_INT 0b1011101100111011 //1 011 101 1 001 1 1 01 1


#define ADS_DEFAULT_CONFIG_T0    ADS_DEFAULT_CONFIG_LINKS
#define ADS_DEFAULT_CONFIG_T0_INT  ADS_DEFAULT_CONFIG_LINKS_INT
#define ADS_DEFAULT_CONFIG_T1    ADS_DEFAULT_CONFIG_RECHTS
#define ADS_DEFAULT_CONFIG_T1_INT  ADS_DEFAULT_CONFIG_RECHTS_INT




//perform one 16Bit Measurement (which is the measurement size of our ADC)
int16_t perform16BitMeasurement(int16_t valueMsg);

#endif /* TEMPADS1118_H_ */

aus tempADS1118.c

#include "tempADS1118.h"

//perform one 16Bit Measurement (which is the measurement size of our ADC)
int16_t perform16BitMeasurement(int16_t valueMsg){
  //request measurement
  uint8_t msgP1 = (uint8_t) (valueMsg >> 8); //MSB
  uint8_t msgP2 = valueMsg % 256 ; //LSB

  
  uint8_t valP1 = 0;
  uint8_t valP2 = 0;
  
  
  spiTransceiveByte(msgP1, FALSE);
  spiTransceiveByte(msgP2, TRUE);
  
  _delay_us(250);
  
  //receive value (16bit = 2Byte); MSB first - shift - LSB
  uint16_t value = 0;
  valP1 = (int16_t)spiTransceiveByte(msgP1, FALSE);
  valP2 = (int16_t)spiTransceiveByte(msgP2, FALSE);
  spiTransceiveByte(msgP1, FALSE);
  spiTransceiveByte(msgP2, TRUE);
  
  
  value = valP1 << 8 + valP2;
  
  return value;
}