1

/*

     2

This file is part of CanFestival, a library implementing CanOpen Stack. 

     3

     4

Copyright (C): Edouard TISSERANT and Francis DUPIN

     5

     6

See COPYING file for copyrights details.

     7

     8

This library is free software; you can redistribute it and/or

     9

modify it under the terms of the GNU Lesser General Public

    10

License as published by the Free Software Foundation; either

    11

version 2.1 of the License, or (at your option) any later version.

    12

    13

This library is distributed in the hope that it will be useful,

    14

but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    16

Lesser General Public License for more details.

    17

    18

You should have received a copy of the GNU Lesser General Public

    19

License along with this library; if not, write to the Free Software

    20

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    21

*/

    22

    23

#ifndef __sdo_h__

    24

#define __sdo_h__

    25

    26

typedef void (*SDOtimeoutError_t)(UNS8 line);

    27

void _SDOtimeoutError (UNS8);

    28

    29

struct struct_s_transfer;

    30

    31

#include "timer.h"

    32

    33

typedef void (*SDOCallback_t)(CO_Data* d, UNS8 nodeId);

    34

    35

/* The Transfer structure

    36

Used to store the different segments of 

    37

 - a SDO received before writing in the dictionary  

    38

 - the reading of the dictionary to put on a SDO to transmit 

    39

*/

    40

    41

struct struct_s_transfer {

    42

  UNS8           nodeId;     /*own ID if server, or node ID of the server if client */

    43

    44

  UNS8           whoami;     /* Takes the values SDO_CLIENT or SDO_SERVER */

    45

  UNS8           state;      /* state of the transmission : Takes the values SDO_... */

    46

  UNS8           toggle;

    47

  UNS32          abortCode;  /* Sent or received */

    48

  /* index and subindex of the dictionary where to store */

    49

  /* (for a received SDO) or to read (for a transmit SDO) */

    50

  UNS16          index; 

    51

  UNS8           subIndex; 

    52

  UNS32          count;      /* Number of data received or to be sent. */

    53

  UNS32          offset;     /* stack pointer of data[]

    54

                              * Used only to tranfer part of a line to or from a SDO.

    55

                              * offset is always pointing on the next free cell of data[].

    56

                              * WARNING s_transfer.data is subject to ENDIANISATION 

    57

                              * (with respect to CANOPEN_BIG_ENDIAN)

    58

                              */

    59

  UNS8           data [SDO_MAX_LENGTH_TRANSFERT];

    60

  UNS8           dataType;   /* Defined in objdictdef.h Value is visible_string 

    61

                              * if it is a string, any other value if it is not a string, 

    62

                              * like 0. In fact, it is used only if client.

    63

                              */

    64

  TIMER_HANDLE   timer;      /* Time counter to implement a timeout in milliseconds.

    65

                              * It is automatically incremented whenever 

    66

                              * the line state is in SDO_DOWNLOAD_IN_PROGRESS or 

    67

                              * SDO_UPLOAD_IN_PROGRESS, and reseted to 0 

    68

                              * when the response SDO have been received.

    69

                              */

    70

  SDOCallback_t Callback;   /* The user callback func to be called at SDO transaction end */

    71

};

    72

typedef struct struct_s_transfer s_transfer;

    73

    74

    75

#include "data.h"

    76

    77

/* The 8 bytes data of the SDO */

    78

struct BODY{

    79

    UNS8 data[8];

    80

};

    81

    82

/* The SDO structure ...*/

    83

struct struct_s_SDO {

    84

  UNS8 nodeId;		/*in any case, Node ID of the server (case sender or receiver).*/

    85

  struct BODY body;

    86

};

    87

    88

    89

typedef struct struct_s_SDO s_SDO;

    90

    91

/** Reset of a SDO exchange on timeout. 

    92

 * Send a SDO abort

    93

 */

    94

void SDOTimeoutAlarm(CO_Data* d, UNS32 id);

    95

    96

/** Reset all sdo buffers

    97

 */

    98

void resetSDO (CO_Data* d);

    99

   100

   101

/** Copy the data received from the SDO line transfert to the object dictionary

   102

 * Returns SDO error code if error. Else, returns 0; 

   103

 */

   104

UNS32 SDOlineToObjdict (CO_Data* d, UNS8 line);

   105

   106

/** Copy the data from the object dictionary to the SDO line for a network transfert.

   107

 * Returns SDO error code if error. Else, returns 0; 

   108

 */

   109

UNS32 objdictToSDOline (CO_Data* d, UNS8 line);

   110

   111

/** copy data from an existant line in the argument "* data"

   112

 * Returns 0xFF if error. Else, returns 0; 

   113

 */

   114

UNS8 lineToSDO (CO_Data* d, UNS8 line, UNS8 nbBytes, UNS8 * data);

   115

   116

/** Add data to an existant line

   117

 * Returns 0xFF if error. Else, returns 0; 

   118

 */

   119

UNS8 SDOtoLine (CO_Data* d, UNS8 line, UNS8 nbBytes, UNS8 * data);

   120

   121

/** Called when an internal SDO abort occurs.

   122

 * Release the line * Only if server * 

   123

 * If client, the line must be released manually in the core application.

   124

 * The reason of that is to permit the program to read the transfers[][] structure before its reset,

   125

 * because many informations are stored on it : index, subindex, data received or trasmited, ...

   126

 * In all cases, sends a SDO abort.

   127

 * Returns 0

   128

 */

   129

UNS8 failedSDO (CO_Data* d, UNS8 nodeId, UNS8 whoami, UNS16 index, 

   130

		UNS8 subIndex, UNS32 abortCode);

   131

   132

/** Reset an unused line.

   133

 * 

   134

 */

   135

void resetSDOline (CO_Data* d, UNS8 line);

   136

   137

/** Initialize some fields of the structure.

   138

 * Returns 0

   139

 */

   140

UNS8 initSDOline (CO_Data* d, UNS8 line, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 state);

   141

   142

/** Search for an unused line in the transfers array

   143

 * to store a new SDO.

   144

 * ie a line which value of the field "state" is "SDO_RESET"

   145

 * An unused line have the field "state" at the value SDO_RESET

   146

 * bus_id is hardware dependant

   147

 * whoami : create the line for a SDO_SERVER or SDO_CLIENT.

   148

 * return 0xFF if all the lines are on use. Else, return 0

   149

 */

   150

UNS8 getSDOfreeLine (CO_Data* d, UNS8 whoami, UNS8 *line);

   151

   152

/** Search for the line, in the transfers array, which contains the

   153

 * beginning of the reception of a fragmented SDO

   154

 * whoami takes 2 values : look for a line opened as SDO_CLIENT or SDO_SERVER

   155

 * bus_id is hardware dependant

   156

 * nodeId correspond to the message node-id 

   157

 * return 0xFF if error.  Else, return 0

   158

 */

   159

UNS8 getSDOlineOnUse (CO_Data* d, UNS8 nodeId, UNS8 whoami, UNS8 *line);

   160

   161

/** Close a transmission.

   162

 * nodeId : Node id of the server if both server or client

   163

 * whoami : Line opened as SDO_CLIENT or SDO_SERVER

   164

 */

   165

UNS8 closeSDOtransfer (CO_Data* d, UNS8 nodeId, UNS8 whoami);

   166

   167

/** Bytes in the line structure which must be transmited (or received)

   168

 * bus_id is hardware dependant.

   169

 * return 0.

   170

 */

   171

UNS8 getSDOlineRestBytes (CO_Data* d, UNS8 line, UNS8 * nbBytes);

   172

   173

/** Store in the line structure the nb of bytes which must be transmited (or received)

   174

 * bus_id is hardware dependant.

   175

 * return 0 if success, 0xFF if error.

   176

 */

   177

UNS8 setSDOlineRestBytes (CO_Data* d, UNS8 line, UNS8 nbBytes);

   178

   179

/** Transmit a SDO frame on the bus bus_id

   180

 * sdo is a structure which contains the sdo to transmit

   181

 * bus_id is hardware dependant

   182

 * whoami takes 2 values : SDO_CLIENT or SDO_SERVER

   183

 * return canSend(bus_id,&m) or 0xFF if error

   184

 */

   185

UNS8 sendSDO (CO_Data* d, UNS8 whoami, s_SDO sdo);

   186

   187

/** Transmit a SDO error to the client. The reasons may be :

   188

 * Read/Write to a undefined object

   189

 * Read/Write to a undefined subindex

   190

 * Read/write a not valid length object

   191

 * Write a read only object

   192

 * whoami takes 2 values : SDO_CLIENT or SDO_SERVER

   193

 */

   194

UNS8 sendSDOabort (CO_Data* d, UNS8 whoami, UNS16 index, UNS8 subIndex, UNS32 abortCode);

   195

   196

/** Treat a SDO frame reception

   197

 * bus_id is hardware dependant

   198

 * call the function sendSDO

   199

 * return 0xFF if error

   200

 *        0x80 if transfert aborted by the server

   201

 *        0x0  ok

   202

 */

   203

UNS8 proceedSDO (CO_Data* d, Message *m);

   204

   205

/** Used by the application to send a SDO request frame to write the data *data

   206

 * at the index and subIndex indicated

   207

 * in the dictionary of the slave whose node_id is nodeId

   208

 * Count : nb of bytes to write in the dictionnary.

   209

 * datatype (defined in objdictdef.h) : put "visible_string" for strings, 0 for integers or reals or other value.

   210

 * bus_id is hardware dependant

   211

 * return 0xFF if error, else return 0

   212

 */

   213

UNS8 writeNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, 

   214

		       UNS8 subIndex, UNS8 count, UNS8 dataType, void *data); 

   215

/** Used to send a SDO request frame to write in a distant node dictionnary.

   216

 * The function Callback	which must be defined in the user code is called at the

   217

 * end of the exchange. (on succes or abort).

   218

 */       		       

   219

UNS8 writeNetworkDictCallBack (CO_Data* d, UNS8 nodeId, UNS16 index, 

   220

		       UNS8 subIndex, UNS8 count, UNS8 dataType, void *data, SDOCallback_t Callback);

   221

/** Used by the application to send a SDO request frame to read

   222

 * in the dictionary of a server node whose node_id is ID

   223

 * at the index and subIndex indicated

   224

 * bus_id is hardware dependant

   225

 * datatype (defined in objdictdef.h) : put "visible_string" for strings, 0 for integers or reals or other value.

   226

 * return 0xFF if error, else return 0

   227

 */

   228

UNS8 readNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, 

   229

		      UNS8 subIndex, UNS8 dataType);

   230

   231

/** Used to send a SDO request frame to read in a distant node dictionnary.

   232

 * The function Callback	which must be defined in the user code is called at the

   233

 * end of the exchange. (on succes or abort).

   234

 */   

   235

UNS8 readNetworkDictCallback (CO_Data* d, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 dataType, SDOCallback_t Callback);

   236

   237

/** Use this function after a readNetworkDict to get the result.

   238

  Returns : SDO_FINISHED             // data is available

   239

            SDO_ABORTED_RCV          // Transfert failed. (abort SDO received)

   240

            SDO_ABORTED_INTERNAL     // Transfert failed. Internal abort.

   241

            SDO_UPLOAD_IN_PROGRESS   // Data not yet available

   242

	    SDO_DOWNLOAD_IN_PROGRESS // Should not arrive ! 

   243

   244

  dataType (defined in objdictdef.h) : type expected. put "visible_string" for strings, 0 for integers or reals.

   245

  abortCode : 0 = not available. Else : SDO abort code. (received if return SDO_ABORTED_RCV)

   246

  example :

   247

  UNS32 data;

   248

  UNS8 size;

   249

  readNetworkDict(0, 0x05, 0x1016, 1, 0) // get the data index 1016 subindex 1 of node 5

   250

  while (getReadResultNetworkDict (0, 0x05, &data, &size) != SDO_UPLOAD_IN_PROGRESS);

   251

*/

   252

UNS8 getReadResultNetworkDict (CO_Data* d, UNS8 nodeId, void* data, 

   253

			       UNS8 *size, UNS32 * abortCode);

   254

   255

/**

   256

  Use this function after a writeNetworkDict to get the result of the write

   257

  It is mandatory to call this function because it is releasing the line used for the transfer.

   258

  Returns : SDO_FINISHED             // data is available

   259

            SDO_ABORTED_RCV          // Transfert failed. (abort SDO received)

   260

            SDO_ABORTED_INTERNAL     // Transfert failed. Internal abort.

   261

            SDO_DOWNLOAD_IN_PROGRESS // Data not yet available

   262

	    SDO_UPLOAD_IN_PROGRESS   // Should not arrive ! 

   263

  abortCode : 0 = not available. Else : SDO abort code. (received if return SDO_ABORTED_RCV)

   264

  example :

   265

  UNS32 data = 0x50;

   266

  UNS8 size;

   267

  UNS32 abortCode;

   268

  writeNetworkDict(0, 0x05, 0x1016, 1, size, &data) // write the data index 1016 subindex 1 of node 5

   269

  while ( getWriteResultNetworkDict (0, 0x05, &abortCode) != SDO_DOWNLOAD_IN_PROGRESS);  

   270

*/

   271

UNS8 getWriteResultNetworkDict (CO_Data* d, UNS8 nodeId, UNS32 * abortCode);

   272

   273

   274

   275

   276

#endif