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

/*!

    24

** @file   sync.c

    25

** @author Edouard TISSERANT and Francis DUPIN

    26

** @date   Tue Jun  5 09:32:32 2007

    27

**

    28

** @brief

    29

**

    30

**

    31

*/

    32

    33

#include "data.h"

    34

#include "sync.h"

    35

#include "canfestival.h"

    36

    37

/* Prototypes for internals functions */

    38

    39

/*!                                                                                                

    40

**                                                                                                 

    41

**                                                                                                 

    42

** @param d                                                                                        

    43

** @param id                                                                                       

    44

**/  

    45

void SyncAlarm(CO_Data* d, UNS32 id);

    46

UNS32 OnCOB_ID_SyncUpdate(CO_Data* d, const indextable * unsused_indextable, 

    47

	UNS8 unsused_bSubindex);

    48

    49

/*!                                                                                                

    50

**                                                                                                 

    51

**                                                                                                 

    52

** @param d                                                                                        

    53

** @param id                                                                                       

    54

**/   

    55

void SyncAlarm(CO_Data* d, UNS32 id)

    56

{

    57

	sendSYNC(d, *d->COB_ID_Sync & 0x1FFFFFFF) ;

    58

}

    59

    60

/*!                                                                                                

    61

** This is called when Index 0x1005 is updated.                                                                                                

    62

**                                                                                                 

    63

** @param d                                                                                        

    64

** @param unsused_indextable                                                                       

    65

** @param unsused_bSubindex                                                                        

    66

**                                                                                                 

    67

** @return                                                                                         

    68

**/  

    69

UNS32 OnCOB_ID_SyncUpdate(CO_Data* d, const indextable * unsused_indextable, UNS8 unsused_bSubindex)

    70

{

    71

	startSYNC(d);

    72

	return 0;

    73

}

    74

    75

/*!                                                                                                

    76

**                                                                                                 

    77

**                                                                                                 

    78

** @param d                                                                                        

    79

**/ 

    80

void startSYNC(CO_Data* d)

    81

{

    82

	RegisterSetODentryCallBack(d, 0x1005, 0, &OnCOB_ID_SyncUpdate);

    83

	RegisterSetODentryCallBack(d, 0x1006, 0, &OnCOB_ID_SyncUpdate);

    84

    85

	if(d->syncTimer != TIMER_NONE){

    86

		stopSYNC(d);

    87

	}

    88

    89

	if(*d->COB_ID_Sync & 0x40000000 && *d->Sync_Cycle_Period)

    90

	{

    91

		d->syncTimer = SetAlarm(

    92

				d,

    93

				0 /*No id needed*/,

    94

				&SyncAlarm,

    95

				US_TO_TIMEVAL(*d->Sync_Cycle_Period), 

    96

				US_TO_TIMEVAL(*d->Sync_Cycle_Period));

    97

	}

    98

}

    99

   100

/*!                                                                                                

   101

**                                                                                                 

   102

**                                                                                                 

   103

** @param d                                                                                        

   104

**/   

   105

void stopSYNC(CO_Data* d)

   106

{

   107

	d->syncTimer = DelAlarm(d->syncTimer);

   108

}

   109

   110

/*!                                                                                                

   111

**                                                                                                 

   112

**                                                                                                 

   113

** @param d                                                                                        

   114

** @param cob_id                                                                                   

   115

**                                                                                                 

   116

** @return                                                                                         

   117

**/  

   118

UNS8 sendSYNC(CO_Data* d, UNS32 cob_id)

   119

{

   120

  Message m;

   121

  UNS8 resultat ;

   122

   123

  MSG_WAR(0x3001, "sendSYNC ", 0);

   124

   125

  m.cob_id.w = cob_id ;

   126

  m.rtr = NOT_A_REQUEST;

   127

  m.len = 0;

   128

  resultat = canSend(d->canHandle,&m) ;

   129

  proceedSYNC(d, &m) ; 

   130

  return resultat ;

   131

}

   132

   133

/*!                                                                                                

   134

**                                                                                                 

   135

**                                                                                                 

   136

** @param d                                                                                        

   137

** @param m                                                                                        

   138

**                                                                                                 

   139

** @return                                                                                         

   140

**/ 

   141

UNS8 proceedSYNC(CO_Data* d, Message *m)

   142

{

   143

   144

  UNS8 res;

   145

   146

  MSG_WAR(0x3002, "SYNC received. Proceed. ", 0);

   147

   148

  (*d->post_sync)();

   149

   150

  /* only operational state allows PDO transmission */

   151

  if(! d->CurrentCommunicationState.csPDO) 

   152

    return 0;

   153

   154

  res = _sendPDOevent(d, 1 /*isSyncEvent*/ );

   155

   156

  /*Call user app callback*/

   157

  (*d->post_TPDO)();

   158

   159

  return res;

   160

   161

}

   162

   163

   164

void _post_sync(){}

   165

void _post_TPDO(){}