pcantst.c51

Philips sja1000 can controller. it contains example on how to control this device

#pragma registerbank(0)
#pragma large
#pragma debug
#pragma pagelength(80) pagewidth(110)
/***********************************************************************
*                                                                      *
*  CAN-Testprogramm / Senden und Empgangen mit 1000KBaud/s.            *
*  Objekt 1 wird gesendet, Objekt 2 wird empfangen                     *
*                                                                      *
*                                                                      *
************************************************************************/


/* IMPORTS */
/*=========*/

#include <reg51.h>
#include <rtx51.h>
#include "rtxcan.h"


/* Globale Variablen */
/*===================*/

xdata struct can_message_struct ts[10], tr[10];
unsigned char i;
unsigned int count[10];
       unsigned char stat;

/************************************************************************/
/* Test Task                                                            */
/************************************************************************/

void rec1_task (void) _task_ 2 _priority_ 1
{
   count[2] = 0;
   can_bind_obj (0x01);
   for (;;) {
      if (can_wait (0xff, &tr[2]) == C_OK) {
         count[2]++;
      }
   }
}

void rec2_task (void) _task_ 3 _priority_ 1
{
   count[3] = 0;
   can_bind_obj (0x02);
   for (;;) {
      if (can_wait (0xff, &tr[3]) == C_OK) {
         count[3]++;
      }
   }
}

void rec3_task (void) _task_ 4 _priority_ 1
{
   count[4] = 0;
   can_bind_obj (0x03);
   for (;;) {
      if (can_wait (0xff, &tr[4]) == C_OK) {
         count[4]++;
      }
   }
}




void send_task (void) _task_ 1
{
   /* Start CAN-Task */
   if (can_task_create() == C_OK) {
      can_hw_init (0x80,0x23,0x5e,0,0);

      /* Receive Object definition */
      can_def_obj (0x01,8,D_REC);
      can_def_obj (0x02,8,D_REC);
      can_def_obj (0x03,8,D_REC);
      can_def_obj (0x04,8,D_REC);
      can_def_obj (0x05,8,D_REC);
      can_def_obj (0x06,8,D_REC);
      
      /* Send to remote request Object definition */
      can_def_obj (0x07,8,D_SEND_R_REC);
      
      /* Send request Object definition */
      can_def_obj (0x08,8,D_REC_R_SEND);

      /* Send Object definition */
      can_def_obj (0x20,7,D_SEND);
      can_def_obj (0x30,7,D_SEND);
      can_def_obj (0x40,8,D_SEND);


      /* Create the receive-task */
      os_create_task (2);
      os_create_task (3);
      os_create_task (4);
         
      /* load Send to remote request Object definition */
      ts[7].identifier = 0x07;
      for (i= 0; i<8; i++){
         ts[7].c_data[i] = i;
      }         

      /* load Send to remote request Object definition */
      ts[2].identifier = 0x20;
      for (i= 1; i<8; i++){
        ts[2].c_data[i] = tr[2].c_data[i];
      }
      ts[3].identifier = 0x30;
      for (i= 1; i<8; i++){
        ts[3].c_data[i] = tr[3].c_data[i];
      }
      ts[4].identifier = 0x40;
      for (i= 1; i<8; i++){
        ts[4].c_data[i] = tr[4].c_data[i];
      }

      /* Start communication */
      can_start();

      /* Init the send object */
      for (;;) {
//         os_wait (K_TMO, 5, 0);
         

         if (count[2] > 0){
            ts[2].c_data[0] = count[2];
            can_send (&ts[2]);
            stat = can_get_status();         
            count[2]--;
            
            ts[7].c_data[0]++;            
            can_write(&ts[7]);

            can_request(8);         
          }

         if (count[3] > 0){
            ts[3].c_data[0] = count[3];
            can_send (&ts[3]);
            stat = can_get_status();         
            count[3]--;
            
            ts[7].c_data[0]++;            
            can_write(&ts[7]);
            
            can_request(8);         
         }
         
         if (count[4] > 0){
            ts[4].c_data[0] = count[4];
            can_send (&ts[4]);
            stat = can_get_status();         
            count[4]--;
            
            ts[7].c_data[0]++;            
            can_write(&ts[7]);
            
            can_request(8);         
         }

      }
   }
}



/************************************************************************/
/* MAIN PROGRAM                                                         */
/************************************************************************/
void main (void)
{
   os_start_system (1);
}


/* END of MODULE BCANTST */