Arduino

...
void setup() {
    myCAN.begin(250);
...
}

LPC1768

...
int main()
{
    myCAN.frequency(250000);
...
}

arduinomega2560;

#include <mcp_can.h>
#include <SPI.h>
 //11 ok 12 error
 const int SPI_CS_PIN = 53; //Can‐Bus pin ayarı
 MCP_CAN CAN(SPI_CS_PIN);
 const int analogInPin =0; // Ldr Pin Ayarı
int sensorValue = 0;
   char outputValue = 0;
 void setup()
 {
Serial.begin(9600);
 pinMode(5,OUTPUT);
 pinMode(6,OUTPUT);
 START_INIT:
 if(CAN_OK == CAN.begin(CAN_500KBPS)) //Can‐Bus bağlantı hızı ve kontrolü
 {
 Serial.println("CAN BUS Shield init ok!");
 digitalWrite(6,LOW);
 digitalWrite(5,HIGH); //Baglanti Kuruldu Ledi
 }
 else
 {
 Serial.println("CAN BUS Shield init fail");
 Serial.println("Init CAN BUS Shield again");


 digitalWrite(5,LOW);
 digitalWrite(6,HIGH); //Baglanti Kuruldu Ledi
 delay(1000);
 goto START_INIT;
 }
 }
 void loop()
 {
 sensorValue = analogRead(analogInPin); // sensör okuma
 outputValue = map(sensorValue, 0, 1023, 0, 255);
 analogWrite(3,outputValue);
  byte ldr[8] = {outputValue, 0, 0, 0, 0, 0, 0, 0};
 // send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
 CAN.sendMsgBuf(0x001,0, 8, ldr); //Can‐Bus hattına veri gönderme
delay(1000);
 }

lpc1768 receiver;

#include "mbed.h"
 
const uint16_t MSG_ID = 0x001;
 
Serial      pc(USBTX, USBRX);
DigitalOut  led1(LED1);
DigitalOut  led2(LED2);
CAN         can(p30, p29);
//CANMessage  msg;
   CANMessage msg = CANMessage();                            /*Variable de type CANMessage*/
   
          //canmsg.id=0x001;                    /*L'identification du message*/
       
int main()
{
    can.frequency(250000);
    pc.baud(9600);
  msg.len=8;                       /*Longeur de la trame en octet*/
        msg.format=CANStandard;          /*Format de la trame CANStandart 11 octet*/
        msg.type=CANData; 
    while(1) {
        if(can.read(msg)) {
            led2.write(1);
            pc.printf("CAN message received\r\n");
            pc.printf("  ID      = 0x%.3x\r\n", msg.id);
            pc.printf("  Type    = %d\r\n", msg.type);
            pc.printf("  Format  = %d\r\n", msg.format);
            pc.printf("  Length  = %d\r\n", msg.len);
            pc.printf("  Data    =");            
            for(int i = 0; i < msg.len; i++){
                pc.printf(" %.2x", msg.data[i]);
            pc.printf("\r\n");
 }
            if(msg.id == MSG_ID) {
                led1 = !led1;
            }
        }
    }
}

void setup() {

...

if(CAN_OK == CAN.begin(MCP_ANY, CAN_250KBPS, MCP_8MHZ)) {

...

}

Arduino code

...
const unsigned int  ID_SENSOR_VALUE = 0x201;
const unsigned int  ID_OUTPUT_VALUE = 0x202;
const unsigned int  ID_SENSOR_VOLTAGE = 0x203;
...
union CanDataType {
    byte  			data[8];		// 8 bytes (max length)
    unsigned int	sensorValue;	// 2 bytes
    char  			outputValue;	// 1 byte
    float 			sensorVoltage;	// 4 bytes
};
...
CanDataType  canData;
unsigned int sensorValue;           // 2 bytes
byte         outputValue;           // 1 byte
float        sensorVoltage;         // 4 bytes
...
void loop() {
    ...
    sensorValue = analogRead(analogInPin);
    outputValue = map(sensorValue, 0, 1023, 0, 255);
    sensorVoltage = (sensorValue * 5) / 1023.0f;
    ...
    canData.sensorValue = sensorValue;
    CAN.sendMsgBuf(ID_SENSOR_VALUE , 0, sizeof(canData.sensorValue), &canData);
    delay(1000);
    canData.outputValue = outputValue;
    CAN.sendMsgBuf(ID_OUTPUT_VALUE, 0, sizeof(canData.outputValue), &canData);
    delay(1000);
    canData.sensorVoltage = sensorVoltage;
    CAN.sendMsgBuf(ID_SENSOR_VOLTAGE, 0, sizeof(canData.sensorVoltage), &canData);
    delay(1000);
}

LPC1768 code

#include "mbed.h"
 
const uint16_t ID_SENSOR_VALUE = 0x201;
const uint16_t ID_OUTPUT_VALUE = 0x202;
const uint16_t ID_SENSOR_VOLTAGE = 0x203;
 
Serial       pc(USBTX, USBRX);
DigitalOut   led1(LED1);
DigitalOut   led2(LED2);
CAN          can(p30, p29);
CANMessage   msg;
uint16_t     sensorValue;	// 2 bytes		
uint8_t      outputValue;	// 1 byte
float        sensorVoltage;	// 4 bytes
       
int main()
{
    pc.baud(9600);
    can.frequency(250000);

    while(1) {
        if(can.read(msg)) {
            led1 = !led1;
            pc.printf("CAN message received\r\n");
            pc.printf("  ID      = 0x%.3x\r\n", msg.id);
            pc.printf("  Type    = %d\r\n", msg.type);
            pc.printf("  Format  = %d\r\n", msg.format);
            pc.printf("  Length  = %d\r\n", msg.len);
            pc.printf("  Data    =");
			            
            for(int i = 0; i < msg.len; i++){
                pc.printf(" 0x%.2x", msg.data[i]);
            }
            
            pc.printf("\r\n");
            
			switch(msg.id) {
	        case ID_SENSOR_VALUE:
				sensorValue = *((uint16_t*)msg.data);
				pc.printf("sensorValue = %d\r\n", sensorValue);
		        break;
	        case ID_OUTPUT_VALUE:
				outputValue = *((uint8_t*)msg.data);
				pc.printf("outputValue = %d\r\n", outputValue);
		        break;
	        case ID_SENSOR_VOLTAGE:
				sensorVoltage = *((float*)msg.data);
				pc.printf("sensorVoltage = %5.3fV\r\n", sensorVoltage);
		        break;
	        }
		}		
    }
}

send canbus data

signed char ldr[8] = {val2, 0, 0, 0, 0, 0, 0, 0}; // send data to canbus line

LPC1768

...
int8_t  outputValue;   // 1byte
...
            case ID_OUTPUT_VALUE:
                outputValue = *((int8_t*)msg.data);
                pc.printf("outputValue = %d\r\n", outputValue);
                break;
...