1

/**************************************************************************

     2

CanFestival3 win32 port example

     3

     4

This sample demonstrates CanFestival usage with Win32

     5

     6

Program implements master node. It starts CANOpen slave node, modifies OD, 

     7

performs SDO reads and prints some slave node information.

     8

     9

Usage:

    10

    11

    win32test <node_id>

    12

    13

  where node_id is node ID in decimal format

    14

    15

You should have CanFestival-3.dll CAN-uVCCM.dll in the search path to run this sample.

    16

Code will work with non-UNICODE CanFestival-3.dll CAN-uVCCM.dll libraries.

    17

    18

Sample can work on other platdorms as well.

    19

    20

Copyright (C) 2007  Leonid Tochinski (ltochinski AT chattenassociates DOT com)

    21

***************************************************************************/

    22

    23

#include <stdio.h>

    24

#include <stdlib.h> 

    25

#include "win32test.h"

    26

#include "canfestival.h"

    27

    28

#ifdef WIN32

    29

#define sleep_proc(ms) Sleep(ms)

    30

#define uptime_ms_proc() GetTickCount()

    31

#else

    32

#include <time.h> 

    33

#define sleep_proc(ms)

    34

#define uptime_ms_proc (1000*(time()%86400))  // TOD

    35

#endif

    36

    37

/* required canfestival callbacks. */

    38

void win32test_SDOtimeoutError(UNS8 line)

    39

  {

    40

  }

    41

    42

void win32test_heartbeatError(UNS8 node_id)

    43

  {

    44

  }

    45

    46

void win32test_initialisation(void)

    47

  {

    48

  }

    49

    50

void win32test_preOperational(void)

    51

  {

    52

  }

    53

    54

void win32test_operational(void)

    55

  {

    56

  }

    57

    58

void win32test_stopped(void)

    59

  {

    60

  }

    61

    62

void win32test_post_sync(void)

    63

  {

    64

  }

    65

    66

void win32test_post_TPDO(void)

    67

  {

    68

  }

    69

    70

static CAN_HANDLE g_MasterCanHandle = NULL;

    71

    72

UNS8 win32test_canSend(Message *m)

    73

  {

    74

  if (g_MasterCanHandle != NULL)

    75

     return canSend(g_MasterCanHandle, m);

    76

  return 1;

    77

  }

    78

    79

UNS8 GetChangeStateResults(UNS8 node_id, UNS8 expected_state, unsigned long timeout_ms)

    80

   {

    81

   unsigned long start_time = 0;

    82

    83

   // reset nodes state

    84

   win32test_Data.NMTable[node_id] = Unknown_state;

    85

    86

   // request node state

    87

   masterRequestNodeState(&win32test_Data, node_id);

    88

    89

   start_time = uptime_ms_proc();

    90

   while(uptime_ms_proc() - start_time < timeout_ms)

    91

      {

    92

      if (getNodeState(&win32test_Data, node_id) == expected_state)

    93

         return 0;

    94

      sleep_proc(1);   

    95

      }

    96

   return 0xFF;

    97

   }

    98

    99

UNS8 ReadSDO(UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 dataType, void* data, UNS8* size)

   100

   {

   101

   UNS32 abortCode = 0;

   102

   UNS8 res = SDO_UPLOAD_IN_PROGRESS;

   103

   // Read SDO

   104

   UNS8 err = readNetworkDict (&win32test_Data, nodeId, index, subIndex, dataType);

   105

   if (err)

   106

      return 0xFF;

   107

   for(;;)

   108

      {

   109

      res = getReadResultNetworkDict (&win32test_Data, nodeId, data, size, &abortCode);

   110

      if (res != SDO_UPLOAD_IN_PROGRESS)

   111

         break;   

   112

      sleep_proc(1);

   113

      continue;

   114

      }

   115

   closeSDOtransfer(&win32test_Data, nodeId, SDO_CLIENT);

   116

   if (res == SDO_FINISHED)

   117

      return 0;

   118

   return 0xFF;   

   119

   }

   120

   121

int main(int argc, char *argv[])

   122

  {

   123

   UNS8 node_id = 0;

   124

   s_BOARD MasterBoard = {"1", "125K"};

   125

   char* dll_file_name;

   126

   127

   /* process command line arguments */

   128

   if (argc < 2)

   129

      {

   130

      printf("USAGE: win32test node_id [dll_file_name]\n");

   131

      return 1;

   132

      }

   133

   134

   node_id = atoi(argv[1]);

   135

   if (node_id < 2 || node_id > 127)

   136

      {

   137

      printf("ERROR: node_id shoule be >=2 and <= 127\n");

   138

      return 1;

   139

      }

   140

   141

      if (argc > 2)

   142

		dll_file_name = argv[2];

   143

	  else

   144

		dll_file_name = "can_uvccm_win32.dll";

   145

   146

   // load can driver

   147

   if (!LoadCanDriver(dll_file_name))

   148

      {

   149

      printf("ERROR: could not load diver %s\n", dll_file_name);

   150

      return 1;

   151

      }

   152

   153

   g_MasterCanHandle = canOpen(&MasterBoard,&win32test_Data);

   154

   155

   if (g_MasterCanHandle)

   156

      {

   157

      /* Defining the node Id */

   158

      setNodeId(&win32test_Data, 0x01);

   159

   160

      /* init */

   161

      setState(&win32test_Data, Initialisation);

   162

   163

      /****************************** START *******************************/

   164

      /* Put the master in operational mode */

   165

      setState(&win32test_Data, Operational);

   166

   167

      /* Ask slave node to go in operational mode */

   168

      masterSendNMTstateChange (&win32test_Data, 0, NMT_Start_Node);

   169

   170

      printf("\nStarting node %d (%xh) ...\n",(int)node_id,(int)node_id);

   171

   172

      /* wait untill mode will switch to operational state*/

   173

      if (GetChangeStateResults(node_id, Operational, 3000) != 0xFF)

   174

         {

   175

         /* modify Client SDO 1 Parameter */

   176

         UNS32 COB_ID_Client_to_Server_Transmit_SDO = 0x600 + node_id;

   177

         UNS32 COB_ID_Server_to_Client_Receive_SDO  = 0x580 + node_id;

   178

         UNS32 Node_ID_of_the_SDO_Server = node_id;

   179

         UNS8 ExpectedSize = sizeof (UNS32);

   180

   181

         if (OD_SUCCESSFUL ==  setODentry(&win32test_Data, 0x1280, 1, &COB_ID_Client_to_Server_Transmit_SDO, &ExpectedSize, RW) 

   182

              && OD_SUCCESSFUL ==  setODentry(&win32test_Data, 0x1280, 2, &COB_ID_Server_to_Client_Receive_SDO, &ExpectedSize, RW) 

   183

              && OD_SUCCESSFUL ==  setODentry(&win32test_Data, 0x1280, 3, &Node_ID_of_the_SDO_Server, &ExpectedSize, RW))

   184

            {

   185

            UNS32 dev_type = 0;

   186

            char device_name[64]="";

   187

            char hw_ver[64]="";

   188

            char sw_ver[64]="";   

   189

            UNS32 vendor_id = 0;            

   190

            UNS32 prod_code = 0;

   191

            UNS32 ser_num = 0;

   192

            UNS8 size;

   193

            UNS8 res;

   194

   195

            printf("\nnode_id: %d (%xh) info\n",(int)node_id,(int)node_id);

   196

            printf("********************************************\n");

   197

   198

            size = sizeof (dev_type);

   199

            res = ReadSDO(node_id, 0x1000, 0, uint32, &dev_type, &size);

   200

            printf("device type: %d\n",dev_type & 0xFFFF);

   201

   202

            size = sizeof (device_name);

   203

            res = ReadSDO(node_id, 0x1008, 0, visible_string, device_name, &size);

   204

            printf("device name: %s\n",device_name);

   205

   206

            size = sizeof (hw_ver);

   207

            res = ReadSDO(node_id, 0x1009, 0, visible_string, hw_ver, &size);

   208

            printf("HW version: %s\n",hw_ver);

   209

   210

            size = sizeof (sw_ver);

   211

            res = ReadSDO(node_id, 0x100A, 0, visible_string, sw_ver, &size);

   212

            printf("SW version: %s\n",sw_ver);            

   213

   214

            size = sizeof (vendor_id);

   215

            res = ReadSDO(node_id, 0x1018, 1, uint32, &vendor_id, &size);

   216

            printf("vendor id: %d\n",vendor_id);

   217

   218

            size = sizeof (prod_code);

   219

            res = ReadSDO(node_id, 0x1018, 2, uint32, &prod_code, &size);

   220

            printf("product code: %d\n",prod_code);

   221

   222

            size = sizeof (ser_num);

   223

            res = ReadSDO(node_id, 0x1018, 4, uint32, &ser_num, &size);

   224

            printf("serial number: %d\n",ser_num);

   225

   226

            printf("********************************************\n");

   227

            } 

   228

         else

   229

            {

   230

            printf("ERROR: Object dictionary access failed\n");

   231

            }

   232

         }

   233

      else

   234

         {

   235

         printf("ERROR: node_id %d (%xh) is not responding\n",(int)node_id,(int)node_id);

   236

         }

   237

   238

      masterSendNMTstateChange (&win32test_Data, 0x02, NMT_Stop_Node);

   239

   240

      setState(&win32test_Data, Stopped);

   241

   242

      canClose(g_MasterCanHandle);

   243

      }

   244

   return 0;

   245

  }

   246

   247