24

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

    25

CanFestival3 win32 port example

    26

    27

This sample demonstrates CanFestival usage with Win32

    28

    29

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

    30

performs SDO reads and prints some slave node information.

    31

    32

Usage:

    33

    34

    win32test <node_id>

    35

    36

  where node_id is node ID in decimal format

    37

    38

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

    39

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

    40

    41

Sample can work on other platdorms as well.

    42

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

    43

    44

#include <stdio.h>

    45

#include <stdlib.h> 

    46

#include "win32test.h"

    47

#include "canfestival.h"

    48

    49

#ifdef WIN32

    50

#define sleep_proc(ms) Sleep(ms)

    51

#define uptime_ms_proc() GetTickCount()

    52

#else

    53

#include <time.h> 

    54

#define sleep_proc(ms)

    55

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

    56

#endif

    57

    58

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

    59

   {

    60

   unsigned long start_time = 0;

    61

    62

   // reset nodes state

    63

   win32test_Data.NMTable[node_id] = Unknown_state;

    64

    65

   // request node state

    66

   masterRequestNodeState(&win32test_Data, node_id);

    67

    68

   start_time = uptime_ms_proc();

    69

   while(uptime_ms_proc() - start_time < timeout_ms)

    70

      {

    71

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

    72

         return 0;

    73

      sleep_proc(1);   

    74

      }

    75

   return 0xFF;

    76

   }

    77

    78

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

    79

   {

    80

   UNS32 abortCode = 0;

    81

   UNS8 res = SDO_UPLOAD_IN_PROGRESS;

    82

   // Read SDO

    83

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

    84

   if (err)

    85

      return 0xFF;

    86

   for(;;)

    87

      {

    88

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

    89

      if (res != SDO_UPLOAD_IN_PROGRESS)

    90

         break;   

    91

      sleep_proc(1);

    92

      continue;

    93

      }

    94

   closeSDOtransfer(&win32test_Data, nodeId, SDO_CLIENT);

    95

   if (res == SDO_FINISHED)

    96

      return 0;

    97

   return 0xFF;   

    98

   }

    99

   100

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

   101

  {

   102

   UNS8 node_id = 0;

   103

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

   104

   char* dll_file_name;

   105

   106

   /* process command line arguments */

   107

   if (argc < 2)

   108

      {

   109

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

   110

      return 1;

   111

      }

   112

   113

   node_id = atoi(argv[1]);

   114

   if (node_id < 2 || node_id > 127)

   115

      {

   116

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

   117

      return 1;

   118

      }

   119

   120

      if (argc > 2)

   121

		dll_file_name = argv[2];

   122

	  else

   123

		dll_file_name = "can_uvccm_win32.dll";

   124

   125

   // load can driver

   126

   if (!LoadCanDriver(dll_file_name))

   127

      {

   128

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

   129

      return 1;

   130

      }

   131

   132

   if (canOpen(&MasterBoard,&win32test_Data))

   133

      {

   134

      /* Defining the node Id */

   135

      setNodeId(&win32test_Data, 0x01);

   136

   137

      /* init */

   138

      setState(&win32test_Data, Initialisation);

   139

   140

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

   141

      /* Put the master in operational mode */

   142

      setState(&win32test_Data, Operational);

   143

   144

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

   145

      masterSendNMTstateChange (&win32test_Data, 0, NMT_Start_Node);

   146

   147

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

   148

   149

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

   150

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

   151

         {

   152

         /* modify Client SDO 1 Parameter */

   153

         UNS32 COB_ID_Client_to_Server_Transmit_SDO = 0x600 + node_id;

   154

         UNS32 COB_ID_Server_to_Client_Receive_SDO  = 0x580 + node_id;

   155

         UNS32 Node_ID_of_the_SDO_Server = node_id;

   156

         UNS8 ExpectedSize = sizeof (UNS32);

   157

   158

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

   159

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

   160

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

   161

            {

   162

            UNS32 dev_type = 0;

   163

            char device_name[64]="";

   164

            char hw_ver[64]="";

   165

            char sw_ver[64]="";   

   166

            UNS32 vendor_id = 0;            

   167

            UNS32 prod_code = 0;

   168

            UNS32 ser_num = 0;

   169

            UNS8 size;

   170

            UNS8 res;

   171

   172

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

   173

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

   174

   175

            size = sizeof (dev_type);

   176

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

   177

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

   178

   179

            size = sizeof (device_name);

   180

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

   181

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

   182

   183

            size = sizeof (hw_ver);

   184

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

   185

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

   186

   187

            size = sizeof (sw_ver);

   188

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

   189

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

   190

   191

            size = sizeof (vendor_id);

   192

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

   193

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

   194

   195

            size = sizeof (prod_code);

   196

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

   197

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

   198

   199

            size = sizeof (ser_num);

   200

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

   201

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

   202

   203

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

   204

            } 

   205

         else

   206

            {

   207

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

   208

            }

   209

         }

   210

      else

   211

         {

   212

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

   213

         }

   214

   215

      masterSendNMTstateChange (&win32test_Data, 0x02, NMT_Stop_Node);

   216

   217

      setState(&win32test_Data, Stopped);

   218

   219

      canClose(&win32test_Data);

   220

      }

   221

   return 0;

   222

  }

   223

   224