Funtion nur Ausfüren in Interupt

[TS (Gast)]

Guten Tag ich habe einen i2C Slave in Betrieb der mir Daten Sendet und 
empfängt. Da ich das Schreiben von Werten in dem Interuptprogramm 
durchfüren möchte, muss ich all diese Parameter übergeben aus dem Main 
(in Funktion Set_Sensor1). Ich möchte die Funktion Set_Sensor1 im 
Interupt nur durchführen also eigentlich nur Set_Sensor1(void). Da ich 
diese Funktion nur benötige um die Variabeln vom Main zu transferieren 
und das Senden auszuführen. Mit Globalen Variabeln würde dies ja ohne 
probleme gehen aber möchte diese nicht verwenden, damit ich die 
übersicht über die Einzelnen Variabeln besitze. Meine Frage wie bringe 
ich die Funktion in meinen Interupt um nur die Funktion auszuführen. 
Stelle Markiert wo die Funktion hinein sollte. Den eine Funtion in einer 
Funktion hab ich ein wernig ausprobiert und erkennt dan die Variabeln 
nicht mehr.

//#################################################################################################*/

#include <util/twi.h>                 // Bezeichnungen für Statuscodes in TWSR
#include <avr/interrupt.h>               // behandlung der Interrupts
#include <stdint.h>                 // definiert Datentyp uint8_t
#include "twislave.h"                 



//########################################################################################## init_twi_slave 

void init_twi_slave(uint8_t adr)
{  
  cli();
  TWAR= adr; //Adresse setzen
  TWCR &= ~(1<<TWSTA)|(1<<TWSTO);
  TWCR|= (1<<TWEA) | (1<<TWEN)|(1<<TWIE);   
  buffer_adr=0xFF;  
  sei();
}
//********************************************************************************************

void Set_Sensor1(uint8_t *A1, uint8_t *B1, uint8_t *C1, uint8_t *D1, uint8_t *E1)
{
  if (rxbuffer[0] == 0x11)
  {
    txbuffer[2]=*A1;
    txbuffer[3]=*B1;
    txbuffer[4]=*C1;
    txbuffer[5]=*D1;
    txbuffer[6]=*E1;
  }
}
//#################################### Macros
//ACK nach empfangenen Daten senden/ ACK nach gesendeten Daten erwarten
#define TWCR_ACK   TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);  

//NACK nach empfangenen Daten senden/ NACK nach gesendeten Daten erwarten     
#define TWCR_NACK   TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);

//switched to the non adressed slave mode...
#define TWCR_RESET   TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);  
//########################################################################################## ISR (TWI_vect) 
//ISR, die bei einem Ereignis auf dem Bus ausgelöst wird. Im Register TWSR befindet sich dann 
//ein Statuscode, anhand dessen die Situation festgestellt werden kann.
ISR (TWI_vect)  
{
  uint8_t data=0;
  switch (TW_STATUS)                 // TWI-Statusregister prüfen und nötige Aktion bestimmen 
    {
    case TW_SR_SLA_ACK:             // 0x60 Slave Receiver, wurde adressiert  
      TWCR_ACK;                 // nächstes Datenbyte empfangen, ACK danach
      buffer_adr=0xFF;             // Bufferposition ist undefiniert
      break;

    case TW_SR_DATA_ACK:             // 0x80 Slave Receiver,Daten empfangen
      data=TWDR;                 // Empfangene Daten auslesen
      if (buffer_adr == 0xFF)         // erster Zugriff, Bufferposition setzen
        {
          if(data<=buffer_size)      // Kontrolle ob gewünschte Adresse im erlaubten bereich
            {
              buffer_adr= data;     // Bufferposition wie adressiert setzen
            }
          else
            {
            buffer_adr=0;         // Adresse auf Null setzen. Ist das sinnvoll?
            }        
          TWCR_ACK;            // nächstes Datenbyte empfangen, ACK danach, um nächstes Byte anzufordern
        }
      else                   // weiterer Zugriff, Daten empfangen
        {
          rxbuffer[buffer_adr]=data;     // Daten in Buffer schreiben
          buffer_adr++;           // Buffer-Adresse weiterzählen für nächsten Schreibzugriff
          if(buffer_adr<(buffer_size-1)) // im Buffer ist noch Platz für mehr als ein Byte
            {
              TWCR_ACK;        // nächstes Datenbyte empfangen, ACK danach, um nächstes Byte anzufordern
            }
          else                 // es kann nur noch ein Byte kommen, dann ist der Buffer voll
            {
              TWCR_NACK;        // letztes Byte lesen, dann NACK, um vollen Buffer zu signaliseren
            }
        }
      break;

    case TW_ST_SLA_ACK:             //
    case TW_ST_DATA_ACK:             // 0xB8 Slave Transmitter, weitere Daten wurden angefordert

      if (buffer_adr == 0xFF)         // zuvor keine Leseadresse angegeben! 
        {
          buffer_adr=0;
        }  
      TWDR = txbuffer[buffer_adr];       // Datenbyte senden 
      buffer_adr++;               // bufferadresse für nächstes Byte weiterzählen
      if(buffer_adr<(buffer_size-1))     // im Buffer ist mehr als ein Byte, das gesendet werden kann
        {
          TWCR_ACK;             // nächstes Byte senden, danach ACK erwarten
        }
      else
        {
          TWCR_NACK;             // letztes Byte senden, danach NACK erwarten
        }
      break;

    case TW_ST_DATA_NACK:             // 0xC0 Keine Daten mehr gefordert 
    case TW_SR_DATA_NACK:             // 0x88 
    case TW_ST_LAST_DATA:             // 0xC8  Last data byte in TWDR has been transmitted (TWEA = “0”); ACK has been received
    case TW_SR_STOP:               // 0xA0 STOP empfangen
    default:   
      TWCR_RESET;               // Übertragung beenden, warten bis zur nächsten Adressierung
      break;  
      
    } //end.switch (TW_STATUS)
    
    //*!*!*!*! Hier soll die Funktion nur ausgeführt werden!!!***!!!    


} //end.ISR(TWI_vect)

[TS (Gast)]

Oh sorry falsches Kapitel Thema wird gewechselt.