1

/*

     2

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

     3

     4

CanFestival Copyright (C): Edouard TISSERANT and Francis DUPIN

     5

CanFestival Win32 port Copyright (C) 2007 Leonid Tochinski, ChattenAssociates, Inc.

     6

     7

See COPYING file for copyrights details.

     8

     9

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

    10

modify it under the terms of the GNU Lesser General Public

    11

License as published by the Free Software Foundation; either

    12

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

    13

    14

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

    15

but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    17

Lesser General Public License for more details.

    18

    19

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

    20

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

    21

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

    22

*/

    23

    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> [can driver dll filename [baud rate]]

    35

    36

 where node_id is node_id in decimal format

    37

    38

If driver is not specified, CAN-uVCCM.dll will be used by default.

    39

If baudrate is not specified, 125K will be used by default.

    40

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

    41

    42

Sample can work on other platdorms as well.

    43

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

    44

    45

#include <stdio.h>

    46

#include <stdlib.h> 

    47

#include "win32test.h"

    48

#include "canfestival.h"

    49

    50

#ifdef WIN32

    51

#define sleep_proc(ms) Sleep(ms)

    52

#define uptime_ms_proc() GetTickCount()

    53

#else

    54

#include <time.h> 

    55

#define sleep_proc(ms)

    56

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

    57

#endif

    58

    59

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

    60

   {

    61

   unsigned long start_time = 0;

    62

    63

   // reset nodes state

    64

   win32test_Data.NMTable[node_id] = Unknown_state;

    65

    66

   // request node state

    67

   masterRequestNodeState(&win32test_Data, node_id);

    68

    69

   start_time = uptime_ms_proc();

    70

   while(uptime_ms_proc() - start_time < timeout_ms)

    71

      {

    72

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

    73

         return 0;

    74

      sleep_proc(1);   

    75

      }

    76

   return 0xFF;

    77

   }

    78

    79

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

    80

   {

    81

   UNS32 abortCode = 0;

    82

   UNS8 res = SDO_UPLOAD_IN_PROGRESS;

    83

   // Read SDO

    84

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

    85

   if (err)

    86

      return 0xFF;

    87

   for(;;)

    88

      {

    89

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

    90

      if (res != SDO_UPLOAD_IN_PROGRESS)

    91

         break;   

    92

      sleep_proc(1);

    93

      continue;

    94

      }

    95

   closeSDOtransfer(&win32test_Data, nodeId, SDO_CLIENT);

    96

   if (res == SDO_FINISHED)

    97

      return 0;

    98

   return 0xFF;   

    99

   }

   100

   101

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

   102

  {

   103

   UNS8 node_id = 0;

   104

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

   105

   char* dll_file_name;

   106

   107

   /* process command line arguments */

   108

   if (argc < 2)

   109

      {

   110

      printf("USAGE: win32test <node_id> [can driver dll filename [baud rate[bus name]]]\n");

   111

      return 1;

   112

      }

   113

   114

   node_id = atoi(argv[1]);

   115

   if (node_id < 2 || node_id > 127)

   116

      {

   117

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

   118

      return 1;

   119

      }

   120

   121

   if (argc > 2)

   122

      dll_file_name = argv[2];

   123

   else

   124

      dll_file_name = "can_uvccm_win32.dll";

   125

   126

   if (argc > 3)

   127

      MasterBoard.baudrate = argv[3];

   128

   129

   if (argc > 4)

   130

	  MasterBoard.busname = argv[4];

   131

   132

   // load can driver

   133

   if (!LoadCanDriver(dll_file_name))

   134

      {

   135

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

   136

      return 1;

   137

      }

   138

   139

	TimerInit();

   140

   141

   if (canOpen(&MasterBoard,&win32test_Data))

   142

      {

   143

      /* Defining the node Id */

   144

      setNodeId(&win32test_Data, 0x01);

   145

   146

      /* init */

   147

      setState(&win32test_Data, Initialisation);

   148

   149

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

   150

      /* Put the master in operational mode */

   151

      setState(&win32test_Data, Operational);

   152

   153

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

   154

      masterSendNMTstateChange (&win32test_Data, 0, NMT_Start_Node);

   155

   156

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

   157

   158

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

   159

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

   160

         {

   161

         /* modify Client SDO 1 Parameter */

   162

         UNS32 COB_ID_Client_to_Server_Transmit_SDO = 0x600 + node_id;

   163

         UNS32 COB_ID_Server_to_Client_Receive_SDO  = 0x580 + node_id;

   164

         UNS8 Node_ID_of_the_SDO_Server = node_id;

   165

         UNS32 ExpectedSize = sizeof(UNS32);

   166

         UNS32 ExpectedSizeNodeId = sizeof (UNS8);

   167

   168

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

   169

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

   170

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

   171

            {

   172

            UNS32 dev_type = 0;

   173

            char device_name[64]="";

   174

            char hw_ver[64]="";

   175

            char sw_ver[64]="";   

   176

            UNS32 vendor_id = 0;            

   177

            UNS32 prod_code = 0;

   178

            UNS32 ser_num = 0;

   179

            UNS32 size;

   180

            UNS8 res;

   181

   182

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

   183

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

   184

   185

            size = sizeof (dev_type);

   186

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

   187

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

   188

   189

            size = sizeof (device_name);

   190

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

   191

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

   192

   193

            size = sizeof (hw_ver);

   194

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

   195

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

   196

   197

            size = sizeof (sw_ver);

   198

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

   199

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

   200

   201

            size = sizeof (vendor_id);

   202

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

   203

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

   204

   205

            size = sizeof (prod_code);

   206

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

   207

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

   208

   209

            size = sizeof (ser_num);

   210

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

   211

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

   212

   213

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

   214

            } 

   215

         else

   216

            {

   217

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

   218

            }

   219

         }

   220

      else

   221

         {

   222

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

   223

         }

   224

   225

      masterSendNMTstateChange (&win32test_Data, 0x02, NMT_Stop_Node);

   226

   227

      setState(&win32test_Data, Stopped);

   228

   229

      canClose(&win32test_Data);

   230

      }

   231

   return 0;

   232

  }

   233

   234