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

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

    38

   {

    39

   unsigned long start_time = 0;

    40

    41

   // reset nodes state

    42

   win32test_Data.NMTable[node_id] = Unknown_state;

    43

    44

   // request node state

    45

   masterRequestNodeState(&win32test_Data, node_id);

    46

    47

   start_time = uptime_ms_proc();

    48

   while(uptime_ms_proc() - start_time < timeout_ms)

    49

      {

    50

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

    51

         return 0;

    52

      sleep_proc(1);   

    53

      }

    54

   return 0xFF;

    55

   }

    56

    57

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

    58

   {

    59

   UNS32 abortCode = 0;

    60

   UNS8 res = SDO_UPLOAD_IN_PROGRESS;

    61

   // Read SDO

    62

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

    63

   if (err)

    64

      return 0xFF;

    65

   for(;;)

    66

      {

    67

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

    68

      if (res != SDO_UPLOAD_IN_PROGRESS)

    69

         break;   

    70

      sleep_proc(1);

    71

      continue;

    72

      }

    73

   closeSDOtransfer(&win32test_Data, nodeId, SDO_CLIENT);

    74

   if (res == SDO_FINISHED)

    75

      return 0;

    76

   return 0xFF;   

    77

   }

    78

    79

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

    80

  {

    81

   UNS8 node_id = 0;

    82

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

    83

   char* dll_file_name;

    84

    85

   /* process command line arguments */

    86

   if (argc < 2)

    87

      {

    88

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

    89

      return 1;

    90

      }

    91

    92

   node_id = atoi(argv[1]);

    93

   if (node_id < 2 || node_id > 127)

    94

      {

    95

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

    96

      return 1;

    97

      }

    98

    99

      if (argc > 2)

   100

		dll_file_name = argv[2];

   101

	  else

   102

		dll_file_name = "can_uvccm_win32.dll";

   103

   104

   // load can driver

   105

   if (!LoadCanDriver(dll_file_name))

   106

      {

   107

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

   108

      return 1;

   109

      }

   110

   111

   if (canOpen(&MasterBoard,&win32test_Data))

   112

      {

   113

      /* Defining the node Id */

   114

      setNodeId(&win32test_Data, 0x01);

   115

   116

      /* init */

   117

      setState(&win32test_Data, Initialisation);

   118

   119

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

   120

      /* Put the master in operational mode */

   121

      setState(&win32test_Data, Operational);

   122

   123

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

   124

      masterSendNMTstateChange (&win32test_Data, 0, NMT_Start_Node);

   125

   126

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

   127

   128

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

   129

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

   130

         {

   131

         /* modify Client SDO 1 Parameter */

   132

         UNS32 COB_ID_Client_to_Server_Transmit_SDO = 0x600 + node_id;

   133

         UNS32 COB_ID_Server_to_Client_Receive_SDO  = 0x580 + node_id;

   134

         UNS32 Node_ID_of_the_SDO_Server = node_id;

   135

         UNS8 ExpectedSize = sizeof (UNS32);

   136

   140

            {

   141

            UNS32 dev_type = 0;

   142

            char device_name[64]="";

   143

            char hw_ver[64]="";

   144

            char sw_ver[64]="";   

   145

            UNS32 vendor_id = 0;            

   146

            UNS32 prod_code = 0;

   147

            UNS32 ser_num = 0;

   148

            UNS8 size;

   149

            UNS8 res;

   150

   151

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

   152

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

   153

   154

            size = sizeof (dev_type);

   155

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

   156

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

   157

   158

            size = sizeof (device_name);

   159

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

   160

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

   161

   162

            size = sizeof (hw_ver);

   163

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

   164

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

   165

   166

            size = sizeof (sw_ver);

   167

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

   168

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

   169

   170

            size = sizeof (vendor_id);

   171

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

   172

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

   173

   174

            size = sizeof (prod_code);

   175

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

   176

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

   177

   178

            size = sizeof (ser_num);

   179

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

   180

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

   181

   182

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

   183

            } 

   184

         else

   185

            {

   186

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

   187

            }

   188

         }

   189

      else

   190

         {

   191

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

   192

         }

   193

   194

      masterSendNMTstateChange (&win32test_Data, 0x02, NMT_Stop_Node);

   195

   196

      setState(&win32test_Data, Stopped);

   197

   198

      canClose(&win32test_Data);

   199

      }

   200

   return 0;

   201

  }

   202

   203