Fehler Meldung beim 1. Build

[Niko (Gast)]

Hallo,

ich bekomme immer beim ersten Build eine Warning Meldung:

Severity  Code  Description  Project  File  Line
Warning    control reaches end of non-void function [-Wreturn-type] 
TWI_I2C_MASTER  G:\AtmelStudio\TWI_I2C_MASTER\TWI_I2C_MASTER\main.c
führe ich ein 2. Build durch ist es weg.

Das hier ist der Code, nur ich versteh nicht warum er meckert:

#define F_CPU 16000000UL

#include <avr/io.h>
#include <util/twi.h>
#include <util/delay.h>
#include <stdlib.h>

#define F_SCL 400000L

#define TWCR_START  0xA4 //send start condition
#define TWCR_STOP   0x94 //send stop condition   
#define TWCR_RACK   0xC4 //receive byte and return ack to slave
#define TWCR_RNACK  0x84 //receive byte and return nack to slave
#define TWCR_SEND   0x84 //pokes the TWINT flag in TWCR and TWEN

/* SLAVE ADRESSEN*/
#define GENERAL_CALL  0x00
#define SLAVE      0x7F
#define SLAVE1      0x7E


void I2C_INIT()
{
   TWSR = 0;                         
   TWBR = ((F_CPU/F_SCL)-16)/2;  
}

void I2C_ERROR()
{
  /* Hier Code für ERROR fall*/
}

void MASTER_START (uint8_t add_SLAVE,uint8_t TM_STATUS)
{
  while(1)
  {
    TWCR = TWCR_START;            /* Start*/
  
    while (!(TWCR & (1<<TWINT))  );    /* Warten bis Start ausgeführt*/
    if(!(TW_STATUS == TW_START))    /* Start erfolgreich: Ja weiter im Programm / Nein :ERROR*/
    {
      I2C_ERROR();
    }
  
    TWDR = (add_SLAVE<<1|TM_STATUS);
    TWCR = TWCR_SEND;
  
    while (!(TWCR & (1<<TWINT)));      
    switch (TW_STATUS)
    {
      case TW_SR_GCALL_ACK:
        break;
      
      case TW_MT_SLA_ACK:
        break;
        
      
      case TW_MT_SLA_NACK:
        TWCR = TWCR_STOP;
        while(TWCR & (1<<TWSTO));
        continue;
      
      case TW_MR_SLA_ACK:
        break;
      
      case TW_MR_DATA_NACK:
        TWCR = TWCR_STOP;
        while(TWCR & (1<<TWSTO));
        continue;
      
      default:
        I2C_ERROR();
          
    }
    break;
  }
}


void MASTER_STOP()
{
    TWCR = TWCR_STOP;
    
    while(TWCR & (1<<TWSTO));
}

void MASTER_DATA_WIRTE(uint8_t DATA)
{
  TWDR = DATA;
  TWCR = TWCR_SEND;
  
  while(!(TWCR & (1<<TWINT)));
  switch (TW_STATUS)
  {
    case TW_MT_DATA_ACK:
      break;
    
    case  TW_MT_DATA_NACK:
      MASTER_STOP();
      break;
    
    default:
      I2C_ERROR();  
  }
}

void MASTER_DATA_READ_ACK(uint8_t DATA)
{
  TWCR = TWCR_RNACK;
  while(!(TWCR & (1<<TWINT)));
  
  DATA = TWDR;
}

void MASTER_DATA_READ_NACK(uint8_t DATA)
{
  TWCR = TWCR_RACK;
  while(!(TWCR & (1<<TWINT)));
  
  DATA = TWDR;
}

int main(void)
{
    I2C_INIT();      /* I2C Initialisierung Durchführen*/
    while (1) 
    {
    }
}

[Jim M. (turboj)]

Mach aus dem "int main(" ein "void main(",
oder füge ein "return 0" hinter der (Endlos) Schleife ein.

Beim 2. Build wird main.c offenbar nicht mehr kompiliert. Ist also nur 
"make" und kein komplettes re-build.

[Rufus Τ. F. (rufus)]

Deine Funktion main ist als Funktion mit einem Rückgabewert definiert 
- es fehlt aber genau das, die Rückgabe eines Wertes.

Zwar wird die Funktion wegen der enthaltenen Endlosschleife nie einen 
Wert zurückgeben (da sie sich nie beendet), wenn Du aber vor die letzte 
schließende geschweifte Klammer ein

  return 0;

setzt, verschwindet die Warnung und ihr Beide, Du und Dein Compiler, 
seid zufrieden.

[Niko (Gast)]

Super hat geklappt, aber warum hatte ich bisher die Fehlermeldung nicht, 
diese müsste ja bei jedem Programm kommen.

[Niko (Gast)]

mal so ne kleine frage zu dem Code, will jetzt nicht extra ein neuen 
Beitrag öffnen:

und zwar müsste er doch nach den 2. Durchlauf nur noch 7 lesen und 
schreiben (also DATA=DATA1=DATA2=7)

warum schreibt er ab den 2. Durchlauf DATA = DATA1=3 und DATA2 =7?

#define F_CPU 16000000UL

#include <avr/io.h>
#include <util/twi.h>
#include <util/delay.h>
#include <stdlib.h>

#define F_SCL 400000L

#define TWCR_START  0xA4 //send start condition
#define TWCR_STOP   0x94 //send stop condition   
#define TWCR_RACK   0xC4 //receive byte and return ack to slave
#define TWCR_RNACK  0x84 //receive byte and return nack to slave
#define TWCR_SEND   0x84 //pokes the TWINT flag in TWCR and TWEN

/* SLAVE ADRESSEN*/
#define GENERAL_CALL  0x00
#define SLAVE      0x7F
#define SLAVE1      0x7E


void I2C_INIT()
{
   TWSR = 0;                         
   TWBR = ((F_CPU/F_SCL)-16)/2;  
}

void I2C_ERROR()
{
  /* Hier Code für ERROR fall*/
}

void MASTER_START (uint8_t add_SLAVE,uint8_t TM_STATUS)
{
  while(1)
  {
    TWCR = TWCR_START;            /* Start*/
  
    while (!(TWCR & (1<<TWINT))  );    /* Warten bis Start ausgeführt*/
    if(!(TW_STATUS == TW_START))    /* Start erfolgreich: Ja weiter im Programm / Nein :ERROR*/
    {
      I2C_ERROR();
    }
  
    TWDR = (add_SLAVE<<1|TM_STATUS);
    TWCR = TWCR_SEND;
  
    while (!(TWCR & (1<<TWINT)));      
    switch (TW_STATUS)
    {
      case TW_SR_GCALL_ACK:
        break;
      
      case TW_MT_SLA_ACK:
        break;
        
      
      case TW_MT_SLA_NACK:
        TWCR = TWCR_STOP;
        while(TWCR & (1<<TWSTO));
        continue;
      
      case TW_MR_SLA_ACK:
        break;
      
      case TW_MR_DATA_NACK:
        TWCR = TWCR_STOP;
        while(TWCR & (1<<TWSTO));
        continue;
      
      default:
        I2C_ERROR();
          
    }
    break;
  }
}


void MASTER_STOP()
{
    TWCR = TWCR_STOP;
    
    while(TWCR & (1<<TWSTO));
}

void MASTER_DATA_WIRTE(uint8_t DATA)
{
  TWDR = DATA;
  TWCR = TWCR_SEND;
  
  while(!(TWCR & (1<<TWINT)));
  switch (TW_STATUS)
  {
    case TW_MT_DATA_ACK:
      break;
    
    case  TW_MT_DATA_NACK:
      MASTER_STOP();
      break;
    
    default:
      I2C_ERROR();  
  }
}

void MASTER_DATA_READ_ACK(uint8_t DATA)
{
  TWCR = TWCR_RACK;
  while(!(TWCR & (1<<TWINT)));
  
  DATA = TWDR;
  
  switch (TW_STATUS)
  {
    case TW_MR_DATA_ACK:
      break;
    
    default:
      I2C_ERROR();
  }
}

void MASTER_DATA_READ_NACK(uint8_t DATA)
{
  TWCR = TWCR_RNACK;
  while(!(TWCR & (1<<TWINT)));
  
  DATA = TWDR;
  
  switch (TW_STATUS)
  {
    case TW_MR_DATA_NACK:
      MASTER_STOP();
      break;
    
    default:
      I2C_ERROR();
  }
}

void MT_SLAVE(uint8_t DATA, uint8_t DATA1, uint8_t DATA2)
{
  
  MASTER_START(SLAVE,TW_WRITE);
  MASTER_DATA_WIRTE(DATA);
  MASTER_DATA_WIRTE(DATA1);
  MASTER_DATA_WIRTE(DATA2);
  MASTER_STOP();
}

void MR_SLAVE(uint8_t DATA)
{
  MASTER_START(SLAVE,TW_READ);
  MASTER_DATA_READ_ACK(DATA);
  MASTER_DATA_READ_ACK(DATA);
  MASTER_DATA_READ_ACK(DATA);
  MASTER_DATA_READ_ACK(DATA);
  MASTER_DATA_READ_NACK(DATA);
  
}

int main(void)
{
    I2C_INIT();      /* I2C Initialisierung Durchführen*/
  uint8_t DATA = 1;
  uint8_t DATA1 = 3;
  uint8_t DATA2 = 7;
    while (1) 
    {
    
    MT_SLAVE(DATA,DATA1,DATA2);
    MR_SLAVE(DATA1);
    DATA = DATA1;
    
    }
  return 0;
}

[Brummbär (Gast)]

Niko schrieb:
> warum schreibt er ab den 2. Durchlauf DATA = DATA1=3 und DATA2 =7?

Weil das im Code so steht.

[Brummbär (Gast)]

Du veränderst doch nur DATA. Und zwar kopierst Du immer nur DATA1 nach 
DATA.
DATA1 und DATA2 bleiben immer gleich.

[Brummbär (Gast)]

void MASTER_DATA_READ_NACK(uint8_t DATA)
{
  ...  
  DATA = TWDR;

DATA ist hier nur eine Kopie des Aufrufparameters.
Wenn Du diesen Wert innerhalb der Prozedur änderst, wird der Aufrufer 
davon nichts mitbekommen.

Entweder, baust Du eine Funktion, also mit Rückgabe.
Oder Du verwendest Zeiger.

[Niko (Gast)]

Ah Stimmt vollkommen übersehen.

[Niko (Gast)]

Gibt es noch ne andere Möglichkeit die Variablen ins Hauptprogramm zu 
übernehmen ohne sie als Global zu deklarieren?

#define F_CPU 16000000UL

#include <avr/io.h>
#include <util/twi.h>
#include <util/delay.h>
#include <stdlib.h>

#define F_SCL 400000L

#define TWCR_START  0xA4 //send start condition
#define TWCR_STOP   0x94 //send stop condition   
#define TWCR_RACK   0xC4 //receive byte and return ack to slave
#define TWCR_RNACK  0x84 //receive byte and return nack to slave
#define TWCR_SEND   0x84 //pokes the TWINT flag in TWCR and TWEN

/* SLAVE ADRESSEN*/
#define GENERAL_CALL  0x00
#define SLAVE      0x7F
#define SLAVE1      0x7E

volatile uint8_t DATA = 1;
volatile uint8_t DATA1 = 3;
volatile uint8_t DATA2 = 7;

void I2C_INIT()
{
   TWSR = 0;                         
   TWBR = ((F_CPU/F_SCL)-16)/2;  
}

void I2C_ERROR()
{
  /* Hier Code für ERROR fall*/
}

void MASTER_START (uint8_t add_SLAVE,uint8_t TM_STATUS)
{
  while(1)
  {
    TWCR = TWCR_START;            /* Start*/
  
    while (!(TWCR & (1<<TWINT))  );    /* Warten bis Start ausgeführt*/
    if(!(TW_STATUS == TW_START))    /* Start erfolgreich: Ja weiter im Programm / Nein :ERROR*/
    {
      I2C_ERROR();
    }
  
    TWDR = (add_SLAVE<<1|TM_STATUS);
    TWCR = TWCR_SEND;
  
    while (!(TWCR & (1<<TWINT)));      
    switch (TW_STATUS)
    {
      case TW_SR_GCALL_ACK:
        break;
      
      case TW_MT_SLA_ACK:
        break;
        
      
      case TW_MT_SLA_NACK:
        TWCR = TWCR_STOP;
        while(TWCR & (1<<TWSTO));
        continue;
      
      case TW_MR_SLA_ACK:
        break;
      
      case TW_MR_DATA_NACK:
        TWCR = TWCR_STOP;
        while(TWCR & (1<<TWSTO));
        continue;
      
      default:
        I2C_ERROR();
          
    }
    break;
  }
}


void MASTER_STOP()
{
    TWCR = TWCR_STOP;
    
    while(TWCR & (1<<TWSTO));
}

void MASTER_DATA_WIRTE(uint8_t DATA)
{
  TWDR = DATA;
  TWCR = TWCR_SEND;
  
  while(!(TWCR & (1<<TWINT)));
  switch (TW_STATUS)
  {
    case TW_MT_DATA_ACK:
      break;
    
    case  TW_MT_DATA_NACK:
      MASTER_STOP();
      break;
    
    default:
      I2C_ERROR();  
  }
}

uint8_t MASTER_DATA_READ_ACK(void)
{
  TWCR = TWCR_RACK;
  while(!(TWCR & (1<<TWINT)));
  
  switch (TW_STATUS)
  {
    case TW_MR_DATA_ACK:
      break;
    
    default:
      I2C_ERROR();
  }
  return TWDR;
}


uint8_t MASTER_DATA_READ_NACK(void)
{
  
  
  TWCR = TWCR_RNACK;
  while(!(TWCR & (1<<TWINT)));
  
  
  
  switch (TW_STATUS)
  {
    case TW_MR_DATA_NACK:
      MASTER_STOP();
      
      break;
    
    default:
      I2C_ERROR();
  }
  
  return TWDR;
}


void MT_SLAVE(uint8_t DATA, uint8_t DATA1, uint8_t DATA2)
{
  
  MASTER_START(SLAVE,TW_WRITE);
  MASTER_DATA_WIRTE(DATA);
  MASTER_DATA_WIRTE(DATA1);
  MASTER_DATA_WIRTE(DATA2);
  MASTER_STOP();
}

void MR_SLAVE()
{
  MASTER_START(SLAVE,TW_READ);
  DATA = MASTER_DATA_READ_ACK();
  DATA1 = MASTER_DATA_READ_NACK();
  
  DATA++;
  DATA1++;
}



int main(void)
{
    I2C_INIT();      /* I2C Initialisierung Durchführen*/
  
    while (1) 
    {
    
    MT_SLAVE(DATA,DATA1,DATA2);
    MR_SLAVE();
    
    
    
    }
  return 0;
}

also hab jetzt die Variablen aus MR_SLAVE global deklaiert um mit ihnen 
weiter zu arbeiten, geht da noch anders? würd gerne die Variablen Lokal 
lieber nutzen und von MR_SLAVE im Main damit weiter arbeiten.

[(prx) A. K. (prx)]

Rufus Τ. F. schrieb:
> Deine Funktion main ist als Funktion mit einem Rückgabewert definiert
> - es fehlt aber genau das, die Rückgabe eines Wertes.

Wobei ab C99 von der main() Funktion in ihrer speziellen Rolle überhaupt 
nicht verlangt wird, explizit einen Wert zurück zu geben. Auch nicht, 
wenn man sie mit Returnwert definiert. In dem Fall wird 0 zurückgegeben.

Frag mich nicht was das soll, aber so steht es im Standard. Übersetze 
mit -std=c99, dann ist die Warnung ebenfalls weg. Ab c99 steht brav ein 
implizites return(0) drin, bei c89/c90 hingegen nicht.