Proleme beim Auslesen MAX31865 und Programmablauf in C

[Daniel B. (dannyboy1994)]

Hallo zusammen.

Ich bin derzeit wieder dabei etwas ehr Zeit für die "Bastelei" zu 
investieren. Aktuell möchte ich einen Fillament-Extruder bauen (Die 
Mechanische Seite ist so gut wie fertig.

Als Temperatusensor für die Nozzle habe ich mir einen PT100 in 
Kombination mit einem MAX 31865 geschnappt.

Nach dem ich erst einmal eine Möglichkeit gebaut habe über Timer die 
Motoren durchlaufen zu lassen mit vorgegebener RPM um die CPU nicht zu 
blocken, teste ich nun die Möglichkeiten mit dem MAX aus.

Das Problem ist folgendes. Ich habe hier einen Arduino Mega liegen 
welchen ich gerne verwenden möchte. Dar die Arduino IDE allerdings die 
Timer und sämtliche Resourcen nach belieben selbst konfiguriert, mlchte 
ich das ganze in C umsetzen mit AVR Studio. Meine C Kenntnisse sind 
fasst als katastrophal zu bezeichnen, worum es hier aber nicht gehen 
soll.

Nun habe ich folgendes Problem. Der Serielle Port (USB vom Arduino 
Board) spuckt mir leider nur "Müll" aus.

Und ich stecke in einer gewissen Sackgasse was den MAX angeht. 
anscheinend bleibt der AVR in irgendeiner schleife hängen, was mangels 
RS232 schnittstelle aktuell schwer zu diagnostizieren ist..

Ich wäre ber Hilfe in jeglicher hinsicht mehr als Dankbar.

/*
 * MAX31Soft_SPI.c
 *
 * Created: 15.04.2019 16:46:55
 * Author : dbern
 */ 

#include <avr/io.h>

#define F_CPU 16000000UL
#define BAUD 9600UL
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif


uint16_t RTD;
uint16_t RTD_value;
uint16_t resistance;
uint8_t referenz=4300;

int main(void)
{setup_SPI_MAX31865();
  USART_Init();
  USART_Transmit("X");
  while(1)
  {
    RTD=messure_resistance();
    USART_Transmit(RTD);
  }
}
void USART_Init( unsigned int ubrr)
{
  /* Set baud rate */
  DDRE |= (1<<PE1);
  UBRR0H = (unsigned char)(ubrr>>8);
  UBRR0L = (unsigned char)ubrr;

  UCSR0B = (1<<RXEN0)|(1<<TXEN0);
  UCSR0C = (1<<USBS0)|(3<<UCSZ00);
}

void USART_Transmit(unsigned char data)
{

  while ( !( UCSR0A & (1<<UDRE0)) );
  UDR0 = data;
}
int setup_SPI_MAX31865(void){
  DDRB = (1<<PB2)|(1<<PB1);
  SPCR = (1<<SPE)|(1<<MSTR)>(1<<SPR0);
  SPI_trans_8(0x80);
  SPI_trans_8(0b01000000);        //4WIRE MODE no Fault detection Auto cycle
  
}

int SPI_trans_8(uint8_t cData){
  SPDR = cData;
  while(!(SPSR & (1<<SPIF)))
  return SPDR;
}




int messure_resistance(void){
  //Temperature (NC) ? (ADC code/32) – 256
  SPI_trans_8(0x01);
  uint8_t MSB=SPI_trans_8(0);
  SPI_trans_8(0x02);
  uint8_t LSB=SPI_trans_8(0);
  
  RTD_value = MSB;
  RTD_value<<=8;
  RTD_value+=LSB;
  RTD_value>>=1;
  RTD_value=(RTD_value>>1);
  
  resistance=RTD_value*referenz*10;
  resistance/=32768;
  resistance+=0.5;
  
  
  return(resistance);
}

[Bärenmarke (Gast)]

Daniel B. schrieb:
> SPCR = (1<<SPE)|(1<<MSTR)>(1<<SPR0);

Die Zeile macht sicher Probleme, das "größer als" sollte wohl eine Pipe 
sein.
Mit Wurst im SPCR wird auch Wurst im SPDR landen.

int messure_resistance(void){
  //Temperature (NC) ? (ADC code/32) – 256
  SPI_trans_8(0x01);
  uint8_t MSB=SPI_trans_8(0);
  SPI_trans_8(0x02);
  uint8_t LSB=SPI_trans_8(0);
  ....

Ich kenne das IC nicht, aber hier wird das Ergebnis der ersten SPI 
Transaktion nicht gesichert. Bist Du sicher, dass das 2. SPI_trans_8 den 
Wert liefert, den Du möchtest?

Compiliert das Programm ohne Meldungen? main() sieht die anderen 
Funktionen ja nicht, da die Prototypen nicht vorhanden sind.

[Bärenmarke (Gast)]

Den Typ von resistance solltest Du nochmal überdenken. Kann es sein, 
dass die Variable überläuft?

[Daniel B. (dannyboy1994)]

Bärenmarke schrieb:
> Daniel B. schrieb:
>> SPCR = (1<<SPE)|(1<<MSTR)>(1<<SPR0);
>
> Die Zeile macht sicher Probleme, das "größer als" sollte wohl eine Pipe
> sein.
> Mit Wurst im SPCR wird auch Wurst im SPDR landen.
>
>

> int messure_resistance(void){
>   //Temperature (NC) ? (ADC code/32) – 256
>   SPI_trans_8(0x01);
>   uint8_t MSB=SPI_trans_8(0);
>   SPI_trans_8(0x02);
>   uint8_t LSB=SPI_trans_8(0);
>   ....
>

>
> Ich kenne das IC nicht, aber hier wird das Ergebnis der ersten SPI
> Transaktion nicht gesichert. Bist Du sicher, dass das 2. SPI_trans_8 den
> Wert liefert, den Du möchtest?
>
> Compiliert das Programm ohne Meldungen? main() sieht die anderen
> Funktionen ja nicht, da die Prototypen nicht vorhanden sind.

Ich komm leider ursprünglich aus der Assembler Fraktion, was man mir 
wohl an der Sauberkeit und Ordnung hier auch anmerkt. C wurde gewählt da 
es schlussendlich doch etwas mehr 16bit Berechnungen werden und C hier 
einfach komfortabler ist.

Es sollte in messure_resistance folgendermaßen ablaufen:
Sende 0x01 (empfangen wird nichts dar es eine Registeradresse ist)
Sende ein DummyByte um das Höherwertige Byte zu empfangen
Sende 0x02 (Adresse LSB)
Sende ein DummyByte um das Niederwertige Byte zu Empfangen

[Bärenmarke (Gast)]

uint16_t RTD;

void USART_Transmit(unsigned char data)

// und dann:

USART_Transmit(RTD);

unsigned char ist 8-Bit, die oberen 8 Bit aus RTD gehen hier verloren.

[Bärenmarke (Gast)]

Daniel B. schrieb:
> C wurde gewählt da
> es schlussendlich doch etwas mehr 16bit Berechnungen werden und C hier
> einfach komfortabler ist.

Absolut. Dann lies Dir vielleicht nochmal was zur Arithmetik in C durch.

resistance=RTD_value*referenz*10;

Hier z.B.: Schon der konstante Teil (referenz*10=43000) "füllt" die 
16-bit
Variable. Bei der Multiplikation mit 2 bist Du über den Wertebereich 
raus. Nimm hier einen 32-bit Typen!

[Daniel B. (dannyboy1994)]

Bärenmarke schrieb:
>

> 
> uint16_t RTD;
> 
> void USART_Transmit(unsigned char data)
> 
> // und dann:
> 
> USART_Transmit(RTD);
> 
>

>
> unsigned char ist 8-Bit, die oberen 8 Bit aus RTD gehen hier verloren.


Das Entstand wohl dadurch das ich ursprünglich direkt die Temperatur 
berechnen und Ausgeben wollte und mich dann doch vorerst mit weniger 
zufrieden geben wollte um erst einmal eien Wert der sich in Abhängigkeit 
der Temperatur ändert beobachten zu können.
Wie könnte man dies vorerst quick&dirty korrigieren?
Der USART soll derweil als Diagnosemöglichkeit herhalten und später die 
Steuerung des ganzen Per LCD und Drehencoder geschehen.


Ich erhalte leider vom USART immer nur ein "?" als Zeichen aus obigen 
Zeile

int main(void)
{setup_SPI_MAX31865();
  USART_Init(UBRR_VAL);
  USART_Transmit("H");

Anscheinend ist bei der USART Konfiguration schon etwas im Busch.

[Karl M. (Gast)]

Daniel B. schrieb:
> USART_Transmit("H");

Lustig !

Siehst Du diesen Prototype?
>>void USART_Transmit(unsigned char data);

Gibt es denn keine Fehlermeldung(en)?

[Daniel B. (dannyboy1994)]

Karl M. schrieb:
> Daniel B. schrieb:
>> USART_Transmit("H");
>
> Lustig !
>
> Siehst Du diesen Prototype?
>>>void USART_Transmit(unsigned char data);
>
> Gibt es denn keine Fehlermeldung(en)?

AVR Studio gibt 0 Errors 0 Warnings 0 Messages beim Compilieren aus.

[Bärenmarke (Gast)]

Daniel B. schrieb:
>> Gibt es denn keine Fehlermeldung(en)?
>
> AVR Studio gibt 0 Errors 0 Warnings 0 Messages beim Compilieren aus.

Dann compiliere das mal mit -Wall -Wextra!

[leo (Gast)]

Daniel B. schrieb:
> AVR Studio gibt 0 Errors 0 Warnings 0 Messages beim Compilieren aus.

Dann wuerde ich mal ganz schnell danach suchen oder gcc aktualisieren:
e.g.

a.c:4:20: warning: large integer implicitly truncated to unsigned type [-Woverflow]
   uint8_t referenz=4300;
                    ^~~~

leo

[Bärenmarke (Gast)]

Das hier...

Daniel B. schrieb:

 RTD_value>>=1;
 RTD_value=(RTD_value>>1);

sieht auch irgendwie "unbeabsichtigt" aus. Du machst zweimal das selbe?

[Daniel B. (dannyboy1994)]

Bärenmarke schrieb:
> Das hier...
>
> Daniel B. schrieb:
>

>  RTD_value>>=1;
>  RTD_value=(RTD_value>>1);
>

>
> sieht auch irgendwie "unbeabsichtigt" aus. Du machst zweimal das selbe?

Besten Dank, das hatte ich übersehen. Natürlich nur einmal nach rechts 
schieben. Die Frage ist wo er hängen bleibt. Hab AVR Studio nochmal 
compilieren lassen. Habe 9 Wernings und etliche Meldungen. Meine 
C-Kenntinisse lassen in der Richtung doch dann zu wünschen übrig.



Was meint ihr betreff dieses Prototypens?

[Daniel B. (dannyboy1994)]

Guten morgen zusammen. Ich hab das ganze noch einmal von null auf 
gerollt.
Die Berechnung mit Ablauf stimmen soweit im Simulator. Die Kommunikation 
mit dem MAX31 ADC ist noch nicht geprüft. Auch die Serielle 
Schnittstelle ist noch nicht implementiert.


Hier einmal der COde

#include <avr/io.h>
#include <math.h>
    #define RTD_A 3.9083e-3
    #define RTD_B -5.775e-7
uint16_t refResistor=430;

//Rechnung passt. Die Kommunikation mit dem Sensor muss noch geprüft werden. hier könnte der kurze HighPulse von SS ein Problem werden

int main(void)
{
  SPI_init();
  
    while (1) 
    {
    int8_t temperatur= calculate_temperatur(MAX_read());
    PORTA = (temperatur);
    };
  return(0);
}


int SPI_init(void){
  //MISO PB3  SCK PB1  SS PB0  MOSI PB2
  DDRB |= (1<<PB2)|(1<<PB1);
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0)|(1<<SPR1);
  //SPI Master Init mit prescaler 128
  return(0);
}

int SPI_cycle(int8_t data){
  SPDR = data;
  while(!(SPSR & (1<<SPIF)));
  return (SPDR);
}

int MAX_setup(void){
  int8_t ctrl_write = 0x80;
  int8_t configbyte = 0b01000000;
  
  SPI_cycle(ctrl_write);
  SPI_cycle(configbyte);
  //SS könnte ein Probem werden, dar es zwischenzeitlich high wird
  return(0);
}

int MAX_read(void){
  SPI_cycle(0x01);
  uint8_t rMSB = SPI_cycle(0x00);
  SPI_cycle(0x02);
  uint8_t rLSB = SPI_cycle(0x00);
  
  uint16_t  RTD_value = rMSB;
       RTD_value<<=8;
       RTD_value+=rLSB;
       RTD_value>>=1;
  return(RTD_value);
}

int calculate_resistance(uint16_t Rt){      //ergebniss von Max Read übergeben
  Rt /=32768;
  Rt*= refResistor;
  
  return(Rt, 8);
}


int calculate_temperatur(uint16_t Rt){      //ergebniss von resistance
    
//Temperature (NC) ≈ (ADC code/32) – 256 

int8_t temp = (Rt/32)-256;
return (temp);
  }

[Peter D. (peda)]

Daniel B. schrieb:
> C wurde gewählt da
> es schlussendlich doch etwas mehr 16bit Berechnungen werden und C hier
> einfach komfortabler ist.

Ich würde sogar die ganzen Meßwertumrechnungen in float machen, dann 
hast Du keine Überlaufprobleme mehr. Und die Übertragung zum PC dann als 
Text mit sprintf().

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Daniel B. schrieb:
> int calculate_resistance(uint16_t Rt){
>   Rt /=32768;
Nach dieser Rechnung wird Rt entweder 0 oder 1 sein. Andere Werte gibt 
es hier nicht mehr.
>   Rt*= refResistor;
Ergo wird Rt hiernach entweder 0 oder 430 sein.
>   return(Rt, 8);
Ein Kommaoperator an einer ganz interessanten Stelle.
Ich würde da den Wert 8 als Rückgabewert erwarten. Was erwartest du?
Der Compiler meint zu dieser Zeile:
"warning: left-hand operand of comma expression has no effect"
Sieh auch:
https://en.wikipedia.org/wiki/Comma_operator

[Daniel B. (dannyboy1994)]

So hier nun einmal ein Code der Zumindest durchläuft. Es sind einige 
Serielle Ausgaben eingebaut um den Ablauf etwas nachvollziehen zu 
könenn.

Der Prinzipielle Abllauf scheint nun zu funktionieren. Auch aus der SPI 
Schleife springt er heraus. Leider spuckt der MAX keinerlei Messwerte 
aus. Ich erhalte nur 000 als LSB und 000 als MSB...
Es ist alles etwas quick and dirty.

#include <avr/io.h>
#include <math.h>
#define F_CPU 16000000UL
#define BAUD 19200UL
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
#include <stdlib.h>
uint16_t refResistor=430;
  char puffer[10];

int main(void)
{
  USART0_init(UBRR_VAL);
  SPI_init();
  uart_putc('6');
   uart_putc('\n'); 
   
 MAX_setup();
 
  uint8_t data=231;

    while (1) 
    {
      data=calculate_temperatur(MAX_read());
  uart_puts( itoa( data, puffer, 10 ) );    //Variablenwert als Asci senden
  uart_putc('\n');
  _delay_ms(1000);
  
    };
  return(0);
}


int SPI_init(void){
  //MISO PB3  SCK PB1  SS PB0  MOSI PB2
  DDRB |= (1<<PB0)|(1<<PB1)|(1<<PB4);
  PORTB |=(1<<PB4);
  SPCR = 0;
  SPCR |= (1<<SPE)|(1<<MSTR)|(1<<SPR0) | (1<<SPR1);
  //SPI Master Init mit prescaler 128
  return(0);
}


int SPI_cycle(uint8_t data){
  SPDR = data;
  while(!(SPSR & (1<<SPIF))){};
  return (SPDR);
}

int MAX_setup(void){
  uint8_t ctrl_write = 0x80;
  uint8_t configbyte = 0b01000000;
    PORTB &= ~(1<<PB4);
    
  SPI_cycle(ctrl_write);
    uart_putc('7');
  SPI_cycle(configbyte);
  uart_putc('9');
    PORTB |=(1<<PB4);
  //SS könnte ein Probem werden, dar es zwischenzeitlich high wird......gelöst mit PB4
  return(0);
}

int MAX_read(void){
  PORTB &= ~(1<<PB4);
  SPI_cycle(0x01);
  uint8_t rMSB = SPI_cycle(0x00);
  PORTB |=(1<<PB4);
 uart_puts( itoa( rMSB, puffer, 10 ) );
  
  PORTB &= ~(1<<PB4);
  SPI_cycle(0x02);
  uint8_t rLSB = SPI_cycle(0x00);
  PORTB |=(1<<PB4);
 uart_puts( itoa( rLSB, puffer, 10 ) );
  
  uint16_t  RTD_value = rMSB;
       RTD_value<<=8;
       RTD_value+=rLSB;
       RTD_value>>=1;
  return(RTD_value);
}

int calculate_resistance(uint16_t Rt){      //ergebniss von Max Read übergeben
  Rt /=32768;
  Rt*= refResistor;
  
  return(Rt, 8);
}


int calculate_temperatur(uint16_t Rt){      //Max Read
    
//Temperature (NC) ? (ADC code/32) – 256 

int8_t temp = (Rt/32)-256;
return (temp);
  }























int USART0_init(unsigned int ubrr){
  
  UBRR0 = (unsigned char)ubrr; // Set baud rate

  UCSR0B = 0b00011000; // USART ein
  UCSR0C = 0b10001110; // URSEL 8N1
  
  return(1);
}









int uart_putc(unsigned char c)
{
    while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
    {
    }                             

    UDR0 = c;                      /* sende Zeichen */
    return 0;
}


/* puts ist unabhaengig vom Controllertyp */
void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
        uart_putc(*s);
        s++;
    }
}

[Daniel B. (dannyboy1994)]

Ich möchte euch gerne immer am laufenden halten. Leider bekomme ich hier 
4 Fehlermeldungen beim Compilieren. Die Arduino IDE flashed es 
allerdings ohne nachzudenken.

Severity  Code  Description  Project  File  Line
Error    conflicting types for 'write_MAX_reg'  MAX31Soft_SPI 
C:\Users\dbern\Documents\Atmel 
Studio\7.0\MAX31Soft_SPI\MAX31Soft_SPI\main.c  71

Diese Meldung bekomme ich für jede Funktion... leider bekomme ich den 
Fehler nicht behoben und stehe etwas auf dem schlauch.

Messwerte bekomme ich vom MAX31 ebenfalls noch keine. nur 0 als MSB 0 
als LSB und folglich 0 als Temperatur.
ich wäre sehr froh wenn ihr mir dabei helfen könntet. Dann steht 
demnächst die Hochzeit mit dem Teil der stepperansteuerung an.

Gruß Daniel

#include <avr/io.h>
#include <math.h>
#define F_CPU 16000000UL
#define BAUD 19200UL
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
#include <stdlib.h>
uint16_t refResistor=430;
char puffer[20];

int main(void)
{
  USART0_init(UBRR_VAL);
  SPI_init();
  uart_putc('6');
  uart_putc('\n');
  MAX_setup();

  while (1)
  {
    uint8_t data=calculate_temperatur(MAX_read_ADC());
    uart_puts( itoa( data, puffer, 10 ) );    //Variablenwert als Asci senden
    uart_putc('\n');
    _delay_ms(1000);
    MAX_clear_fault();
    
  };
  return(0);
}


int SPI_init(void){
  //MISO PB3  SCK PB1  SS PB0  MOSI PB2
  DDRB |= (1<<PB0)|(1<<PB1)|(1<<PB4);
  PORTB |=(1<<PB4);
  SPCR = 0;
  SPCR |= (1<<SPE)|(1<<MSTR)|(1<<SPR0) | (1<<SPR1);
  //SPI Master Init mit prescaler 128
  return(0);
}

int SPI_cycle(uint8_t data){
  SPDR = data;
  while(!(SPSR & (1<<SPIF))){};
  return (SPDR);
}

int MAX_setup(void){
  uint8_t ctrl_write = 0x80;
  uint8_t configbyte = 0b11000011;
  write_MAX_reg(ctrl_write, configbyte);
  return(0);
}


int MAX_read_fault(void){
  return(read_MAX_reg (0x07));
}
int MAX_clear_fault(void){
  uint8_t data=read_MAX_reg(0x00);
  data &=~ 0x2C;
  write_MAX_reg(0x80,data);
  return(1);
}

int write_MAX_reg(uint8_t addrs, uint8_t data){
  PORTB &= ~(1<<PB4);
  SPI_cycle(addrs);
  SPI_cycle(data);
  PORTB |=(1<<PB4);
  return(1);
}

int read_MAX_reg(uint8_t addrs){

  PORTB &= ~(1<<PB4);
  
  SPI_cycle(addrs);
  uint8_t  data= SPI_cycle(0x00);
  PORTB |=(1<<PB4);
  return(data);
  
}


int MAX_read_ADC(void){
  uint8_t MSB=read_MAX_reg(0x01);
  uart_puts( itoa( MSB, puffer, 10 ) );
  uint8_t LSB=read_MAX_reg(0x02);
  uart_puts( itoa( LSB, puffer, 10 ) );
  
  uint16_t  RTD_value = MSB;
  RTD_value<<=8;
  RTD_value+=LSB;
  RTD_value>>=1;
  return(RTD_value);
}

int calculate_resistance(uint16_t Rt){      //ergebniss von Max Read übergeben
  Rt /=32768;
  Rt*= refResistor;
  
  return(Rt, 8);
}


int calculate_temperatur(uint16_t Rt){      //Max Read
  
  //Temperature (NC) ? (ADC code/32) – 256

  int8_t temp = (Rt/32)-256;
  return (temp);
}
int USART0_init(unsigned int ubrr){
  
  UBRR0 = (unsigned char)ubrr; // Set baud rate

  UCSR0B = 0b00011000; // USART ein
  UCSR0C = 0b10001110; // URSEL 8N1
  
  return(1);
}
int uart_putc(unsigned char c)
{
  while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
  {
  }

  UDR0 = c;                      /* sende Zeichen */
  return 0;
}
/* puts ist unabhaengig vom Controllertyp */
void uart_puts (char *s)
{
  while (*s)
  {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
    uart_putc(*s);
    s++;
  }
}

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Daniel B. schrieb:
> Messwerte bekomme ich vom MAX31 ebenfalls noch keine.
Nimm einen Logikanalyzer oder ein Speicheroszi und miss die 
Kommunikation. Dann kannst du wenigstens sehen, was du am MOSI sendest 
und kontrollieren, ob das zu dem passt, was der MAX laut Datenblatt 
erwartet. Und du kannst sehen, ob der am MISO überhaupt irgendwie auf 
dein Kommando reagiert. Ohne LA/Oszi kann man solche seriellen 
Schnittstellen meist nur unglaublich holprig per Try&Error in Betrieb 
nehmen.

[Bernd N (Gast)]

https://github.com/intel-iot-devkit/mraa/issues/137

[Falk B. (falk)]

Daniel B. schrieb:
> Ich möchte euch gerne immer am laufenden halten. Leider bekomme ich hier
> 4 Fehlermeldungen beim Compilieren. Die Arduino IDE flashed es
> allerdings ohne nachzudenken.
>
> Severity  Code  Description  Project  File  Line
> Error    conflicting types for 'write_MAX_reg'  MAX31Soft_SPI
> C:\Users\dbern\Documents\Atmel
> Studio\7.0\MAX31Soft_SPI\MAX31Soft_SPI\main.c  71

Da stimmen die Datentypen zwischen Funktionsdeklaration und Aufruf nicht 
überein.

1.) Lange Texte gehören in den Anhang, siehe Netiquette.

> Messwerte bekomme ich vom MAX31 ebenfalls noch keine. nur 0 als MSB 0
> als LSB und folglich 0 als Temperatur.

> ich wäre sehr froh wenn ihr mir dabei helfen könntet.

Du musst erstmal einen GAAANZ einfachen SPI-Zugriff machen und testen. 
Also ein möglichst einfaches Register lesen und schreiben, z.B.  High 
Fault Threshold MSB. Wenn das funktioniert geht es weiter, siehe 
Fehlersuche.

Ein Oszi oder Logicanalyzer ist hier SEHR hilfreich.

"Nun habe ich folgendes Problem. Der Serielle Port (USB vom Arduino
Board) spuckt mir leider nur "Müll" aus.

Und ich stecke in einer gewissen Sackgasse was den MAX angeht.
anscheinend bleibt der AVR in irgendeiner schleife hängen, was mangels
RS232 schnittstelle aktuell schwer zu diagnostizieren ist.."

So geht das nicht! Zuerst muss dein UART laufen, damit du ein Chance 
hast, den Fehler zu finden!

[daniel bernhard (Gast)]

Falk B. schrieb:
> Daniel B. schrieb:
> Ich möchte euch gerne immer am laufenden halten. Leider bekomme ich hier
> 4 Fehlermeldungen beim Compilieren. Die Arduino IDE flashed es
> allerdings ohne nachzudenken.
> Severity  Code  Description  Project  File  Line
> Error    conflicting types for 'write_MAX_reg'  MAX31Soft_SPI
> C:\Users\dbern\Documents\Atmel
> Studio\7.0\MAX31Soft_SPI\MAX31Soft_SPI\main.c  71
>
> Da stimmen die Datentypen zwischen Funktionsdeklaration und Aufruf nicht
> überein.
>
> 1.) Lange Texte gehören in den Anhang, siehe Netiquette.
>
> Messwerte bekomme ich vom MAX31 ebenfalls noch keine. nur 0 als MSB 0
> als LSB und folglich 0 als Temperatur.
>
> ich wäre sehr froh wenn ihr mir dabei helfen könntet.
>
> Du musst erstmal einen GAAANZ einfachen SPI-Zugriff machen und testen.
> Also ein möglichst einfaches Register lesen und schreiben, z.B.  High
> Fault Threshold MSB. Wenn das funktioniert geht es weiter, siehe
> Fehlersuche.
>
> Ein Oszi oder Logicanalyzer ist hier SEHR hilfreich.
>
> "Nun habe ich folgendes Problem. Der Serielle Port (USB vom Arduino
> Board) spuckt mir leider nur "Müll" aus.
>
> Und ich stecke in einer gewissen Sackgasse was den MAX angeht.
> anscheinend bleibt der AVR in irgendeiner schleife hängen, was mangels
> RS232 schnittstelle aktuell schwer zu diagnostizieren ist.."
>
> So geht das nicht! Zuerst muss dein UART laufen, damit du ein Chance
> hast, den Fehler zu finden!


Also in Aktueller Version läuft der USART. Das Problem waren " " statt ' 
'.
weitere Tests folgen heute Nacht. Die Schleifen durchläuft er jetzt 
ebenfalls vernünftig. Nur das Problem einer toten Kommunikation bleibt 
bestehen.

Eine weitere kleine Fehlerquelle ist aktuell denke ich auch der weg wie 
ich den AVR flash.  Ich schreibe in Atmel Studio 7 und flashe und 
recompiliere dabei den Code mit der Arduino IDE, um den Bottloader und 
die serielle Schnittstelle weiterhin nutzen zu können.

Gruß Daniel
PS: Ich werde absofort den Quellcode als .c Anhängen.

[Bernd N (Gast)]

Hast du dir den verlinkten Artikel angesehen ?

[Daniel B. (dannyboy1994)]

Bernd N schrieb:
> Hast du dir den verlinkten Artikel angesehen ?

In dem Artikel geht es um die Problematik das CS nach jedem Byte High 
Level annimmt. Ich habe allerdings schon einen seperaten CS eingebaut 
welcher bei mir an Portb4 angeschlossen ist. An den LA hab ich das ganze 
noch nicht anschließen können zwecks Zeitmangel.

Gruß Daniel

[Daniel B. (dannyboy1994)]

Guten Abend zusammen. Nun mit aktuellem oberen Code erhalte ich nach 
Identifizierung eines Verdrahtungsfehlers durchgehend 0xFF als Wert 
zurück gegeben. Die Arduino IDE compiliert ihn Probemlos, AVR STUDIo hat 
allerdings ein Problem mit :

Severity  Code  Description  Project  File  Line
Error    conflicting types for 'write_MAX_reg'  MAX31Soft_SPI 
C:\Users\dbern\Documents\Atmel 
Studio\7.0\MAX31Soft_SPI\MAX31Soft_SPI\main.c  70
Error    conflicting types for 'read_MAX_reg'  MAX31Soft_SPI 
C:\Users\dbern\Documents\Atmel 
Studio\7.0\MAX31Soft_SPI\MAX31Soft_SPI\main.c  77
Error    conflicting types for 'uart_putc'  MAX31Soft_SPI 
C:\Users\dbern\Documents\Atmel 
Studio\7.0\MAX31Soft_SPI\MAX31Soft_SPI\main.c  126



Ich komm hier allerdings nicht auf die Lösung. ich übergebe eine uint8_t 
an die Funktion welche einen uint8_t erwartet und erhalte einen 
Fehler???

Gruß Daniel