Hilfe bei Zeiger erstellen.

[Maik81SE]

Moin zusammen,

Leider komme ich im Zuge meines Projektes zu dem Punkt, der mit schon immer geraut hat und welche ich dadurch auch möglichst lange auf ieine Art und Weise umgangen habe.
Pointer&Zeiger

ich habe hier nun eine function auf den Zettel bekommen, welche ich C geschrieben wurde.
Das eigentlich auch nicht das Problem, damit kann ich leben, wo ich aber in's schleudern kommen ich der hier aufgeführte usi_onReceiverPtr.
im Orginal code ist dies weder in der .c noch in der entsprechenden .h definiert.

Code: Alles auswählen

#define USI_RECEIVE_CALLBACK() \
{ \
    if (usi_onReceiverPtr) \
    { \
        if (usiTwiDataInReceiveBuffer()) \
        { \
            usi_onReceiverPtr(usiTwiAmountDataInReceiveBuffer()); \
        } \
    } \
}

ebenso kommt mit auch der

Code: Alles auswählen

if(_onTwiDataRequest) _onTwiDataRequest();

Aufruf nicht ganz koscher vor, oder ist es normal, das man einen Pointer abfragt und sich neu zuweist?

Code: Alles auswählen

void (*_onTwiDataRequest)(void);

ISR( USI_OVERFLOW_VECTOR )
{

  switch ( overflowState )
  {

    // Address mode: check address and send ACK (and next USI_SLAVE_SEND_DATA) if OK,
    // else reset USI
    case USI_SLAVE_CHECK_ADDRESS:
      if ( ( USIDR == 0 ) || ( ( USIDR >> 1 ) == slaveAddress) )
      {
         // callback
         if(_onTwiDataRequest) _onTwiDataRequest();
         if ( USIDR & 0x01 )
        {
          overflowState = USI_SLAVE_SEND_DATA;
        }
        else
        {
          overflowState = USI_SLAVE_REQUEST_DATA;
        } // end if
        SET_USI_TO_SEND_ACK( );
      }
      else
      {
        SET_USI_TO_TWI_START_CONDITION_MODE( );
      }
      break;

    // Master write data mode: check reply and goto USI_SLAVE_SEND_DATA if OK,
    // else reset USI
    case USI_SLAVE_CHECK_REPLY_FROM_SEND_DATA:
      if ( USIDR )
      {
        // if NACK, the master does not want more data
        SET_USI_TO_TWI_START_CONDITION_MODE( );
        return;
      }
      // from here we just drop straight into USI_SLAVE_SEND_DATA if the
      // master sent an ACK

    // copy data from buffer to USIDR and set USI to shift byte
    // next USI_SLAVE_REQUEST_REPLY_FROM_SEND_DATA
    case USI_SLAVE_SEND_DATA:
      USI_REQUEST_CALLBACK();
      // Get data from Buffer
      if ( txHead != txTail )
      {
        txTail = ( txTail + 1 ) & TWI_TX_BUFFER_MASK;
        USIDR = txBuf[ txTail ];
      }
      else
      {
        // the buffer is empty
        SET_USI_TO_READ_ACK( ); // This might be neccessary sometimes see http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&p=805227#805227
        SET_USI_TO_TWI_START_CONDITION_MODE( );
        return;
      } // end if
      overflowState = USI_SLAVE_REQUEST_REPLY_FROM_SEND_DATA;
      SET_USI_TO_SEND_DATA( );
      break;

    // set USI to sample reply from master
    // next USI_SLAVE_CHECK_REPLY_FROM_SEND_DATA
    case USI_SLAVE_REQUEST_REPLY_FROM_SEND_DATA:
      overflowState = USI_SLAVE_CHECK_REPLY_FROM_SEND_DATA;
      SET_USI_TO_READ_ACK( );
      break;

    // Master read data mode: set USI to sample data from master, next
    // USI_SLAVE_GET_DATA_AND_SEND_ACK
    case USI_SLAVE_REQUEST_DATA:
      overflowState = USI_SLAVE_GET_DATA_AND_SEND_ACK;
      SET_USI_TO_READ_DATA( );
      break;

    // copy data from USIDR and send ACK
    // next USI_SLAVE_REQUEST_DATA
    case USI_SLAVE_GET_DATA_AND_SEND_ACK:
      // put data into buffer
      // Not necessary, but prevents warnings
      rxHead = ( rxHead + 1 ) & TWI_RX_BUFFER_MASK;
      rxBuf[ rxHead ] = USIDR;
      // next USI_SLAVE_REQUEST_DATA
      overflowState = USI_SLAVE_REQUEST_DATA;
      SET_USI_TO_SEND_ACK( );
      break;

  } // end switch

} // end ISR( USI_OVERFLOW_VECTOR )

Wenn sich jemand mal die komplette funktion anschauen will die hängt bei.

[sstvmaster]

...
im Orginal code ist dies weder in der .c noch in der entsprechenden .h definiert.
...

Ist doch hier in Zeile 53 definiert: https://github.com/watterott/Arduino-Li ... WI_Slave.h

[PascalDragon]

ich habe hier nun eine function auf den Zettel bekommen, welche ich C geschrieben wurde.
Das eigentlich auch nicht das Problem, damit kann ich leben, wo ich aber in's schleudern kommen ich der hier aufgeführte usi_onReceiverPtr.
im Orginal code ist dies weder in der .c noch in der entsprechenden .h definiert.

sstvmaster hat es zwar schon erwähnt, aber allein auf Grund der Tatsache, dass usi_onReceiverPtr als Funktion genutzt wird, ist es letztlich in FPC als Funktionsvariable zu übersetzen:

Code: Alles auswählen

var
  usi_onReceiverPtr: procedure(... { was auch immer usiTwiAmountdataInReceiverBuffer() zurück gibt });

ebenso kommt mit auch der

Code: Alles auswählen

if(_onTwiDataRequest) _onTwiDataRequest();

Aufruf nicht ganz koscher vor, oder ist es normal, das man einen Pointer abfragt und sich neu zuweist?

Das ist keine Zuweisung, das ist einfach nur die Prüfung und der darauf folgende Aufruf einer Funktionsvariable:

Code: Alles auswählen

if Assigned(_onTwiDataRequest) then
  _onTwiDataRequest();

[Maik81SE]

Ist doch hier in Zeile 53 definiert: https://github.com/watterott/Arduino-Li ... WI_Slave.h

mit anderen Worten, auch wenn man OHNE Arduino arbeitet ist man besser beraten, diese Libs bevorzugt zu nehmen? denn in meiner usiTwISlave.h ein komblett anderer code.

Code: Alles auswählen

#ifndef _USI_TWI_SLAVE_H_
#define _USI_TWI_SLAVE_H_

//##################################################################### includes

#include <stdbool.h>

//################################################################### prototypes

void    usiTwiSlaveInit(uint8_t ownAddress);	// send slave address

//#################################################################### variables

#define buffer_size 16						     //in bytes (2..254), change ONLY here!!!!!


volatile uint8_t rxbuffer[buffer_size];         // Buffer to write data received from the master
volatile uint8_t txbuffer[buffer_size];			// Transmission buffer to be read from the master
volatile uint8_t buffer_adr; 					// Virtual buffer address register


#if 	(buffer_size > 254)
		#error Buffer to big! Maximal 254 Bytes.

#elif 	(buffer_size < 2)
		#error Buffer to small! mindestens 2 Bytes!
#endif

//##############################################################################

#endif  // ifndef _USI_TWI_SLAVE_H_

und sowas kann nur jeden in's schleudern bringen, selbst erfahrenere würde dann schreien.

[PascalDragon]

mit anderen Worten, auch wenn man OHNE Arduino arbeitet ist man besser beraten, diese Libs bevorzugt zu nehmen? denn in meiner usiTwISlave.h ein komblett anderer code.

Was auch nicht überraschend ist, da es eben komplett verschiedener Code ist, der halt letztlich das gleiche Gerät bedient. Ich sehe in deinem angehängten Code zum Beispiel nirgendwo das if(_onTwiDataRequest) _onTwiDataRequest(), das du in dem großen Codeblock zitiert hast.
Was für nen Code nutzt du nun also?

[Maik81SE]

Was auch nicht überraschend ist, da es eben komplett verschiedener Code ist, der halt letztlich das gleiche Gerät bedient. Ich sehe in deinem angehängten Code zum Beispiel nirgendwo das if(_onTwiDataRequest) _onTwiDataRequest(), das du in dem großen Codeblock zitiert hast.
Was für nen Code nutzt du nun also?

Letzteren, das ich auch der einzige, den ich zZ bei mir auf meinem Leptop laufen habe...

Code: Alles auswählen

var
  usi_onReceiverPtr: procedure(... { was auch immer usiTwiAmountdataInReceiverBuffer() zurück gibt });

und genau dem mit komme ich iwie in's schleudern.
Procedure als var?!

bin zwar schon das öfteren darüber in etlichen Tuts gelandet, aber Näher ich da NIE jemand eingegangen...

[fliegermichl]

und genau dem mit komme ich iwie in's schleudern.
Procedure als var?!

Ja, das ist eine sogenannte Prozedur oder Funktionsvariable. In dieser kann man die Adresse einer Procedur oder Funktion speichern. Wenn man das getan hat, dann kann man diese auch aufrufen.

Code: Alles auswählen

type
 TRechne = function (op1, op2 : integer) : integer;

Diese Deklaration definiert erst einmal ganz allgemein einen Typ einer Funktion die zwei Integer Parameter bekommt und ein Integer Ergebnis zurück liefert.
diesen Typ kann man dann einer Variablen zuweisen:

Code: Alles auswählen

function plus(op1, op2 : integer) : integer;
begin
 Result := op1 + op2;
end;

function minus(op1, op2 : integer) : integer;
begin
 Result := op1 - op2;
end;

procedure Machwas(operation : char; op1, op2 : integer);
var Rechne : TRechne;
begin
 Rechne := nil;
 case operation of
  '+' : Rechne := @plus;
  '-' : Rechne := @minus;
 end;
 
 if Rechne <> nil then writeln(Rechne(op1, op2));
end;

Das ist jetzt ein etwas unsinniges Beispiel, verdeutlicht aber die Procedurvariable

[wp_xyz]

Das ist jetzt ein etwas unsinniges Beispiel

Überhaupt nicht, sondern in sehr sinnvolles Beispiel, das genau zeigt worum es geht.

Stellt dir vor du hast zwei riesige Arrays und musst diese mit einer Operation miteinander verknüpfen, nämlich elementweise addieren oder elementweise subtrahieren. Die naheliegende Lösung ist, die Arrays Element für Element zu durchlaufen mit einem case zu entscheiden ob "operation" '+' ist oder '-' und dann dementsprechend die Element zu addieren oder zu subtrahieren. Da in dieser Schleife nicht viel passiert, ist anzunehmen, dass ein großer Teil der Rechenzeit von dem "case" verbraten wird. Stattdessen ist es schlauer eine Prozedurvariable einzuführen und das "case" vor die Schleife zu stellen, wobei das "case" dieser Prozedurvariablen entsprechend entweder die Addier- oder die Subtraktions-Funktion zuweist. In der Schleife selbst ruft man dann jeweils die Prozedurvariable auf und kann sich das "case" in der Schleife sparen.

Nach dem gleichen Prinzip funktionieren übrigen die Events von Lazarus.,

[Maik81SE]

und genau dem mit komme ich iwie in's schleudern.
Procedure als var?!

Ja, das ist eine sogenannte Prozedur oder Funktionsvariable. In dieser kann man die Adresse einer Procedur oder Funktion speichern. Wenn man das getan hat, dann kann man diese auch aufrufen.

Code: Alles auswählen

type
 TRechne = function (op1, op2 : integer) : integer;

Diese Deklaration definiert erst einmal ganz allgemein einen Typ einer Funktion die zwei Integer Parameter bekommt und ein Integer Ergebnis zurück liefert.
diesen Typ kann man dann einer Variablen zuweisen:

Code: Alles auswählen

function plus(op1, op2 : integer) : integer;
begin
 Result := op1 + op2;
end;

function minus(op1, op2 : integer) : integer;
begin
 Result := op1 - op2;
end;

procedure Machwas(operation : char; op1, op2 : integer);
var Rechne : TRechne;
begin
 Rechne := nil;
 case operation of
  '+' : Rechne := @plus;
  '-' : Rechne := @minus;
 end;
 
 if Rechne <> nil then writeln(Rechne(op1, op2));
end;

Das ist jetzt ein etwas unsinniges Beispiel, verdeutlicht aber die Procedurvariable

Lieber ein Unsinniges Beispiel, indemm JEDER versteht, um was es geht als eine Hochgeschrieben Text, den keiner Versteht...