Nishant Patel
Published

LPC2129 based CAN Protocol

Implemented LPC2129 microcontroller for Side-light & Head-light tasks, mimicking real car functions with Acceptance Filter Setting.

AdvancedFull instructions provided24 hours39
LPC2129 based CAN Protocol

Things used in this project

Hardware components

NXP LPC2129
Instead of LPC2129 IC take Rhydolabz Boards so it may get easy for connection.
×2
RGB Backlight LCD - 16x2
Adafruit RGB Backlight LCD - 16x2
×1
Female/Female Jumper Wires
Female/Female Jumper Wires
×1
USB Serial Adapter Cable USB A Male to DB9 Male, 5 ft
USB Serial Adapter Cable USB A Male to DB9 Male, 5 ft
×1

Software apps and online services

Keil Embedded Development Tools Keil

Story

Read more

Schematics

CAN CONNECTION BETWEEN TWO BOARDS

Code

CAN RX CODE

C/C++
#include "header.h"

#define LED 1<<17 //left-indecator
#define LED1 1<<19//right-indecator
#define LED2 1<<18//head-light

unsigned int flag=0,lif=0,rif=0,hlf=0;
CAN1 v1;

unsigned char left[]={0,0,0x04,0x08,0x1F,0X08,0X04,0};
unsigned char right[]={0,0,0x4,0X2,0X1F,0X2,0X4,0};
unsigned char head1[]={0X18,0X14,0X12,0X11,0X11,0X12,0X14,0X18};
unsigned char head2[]={0x1F,0,0x1F,0,0x1F,0,0x1F,0};
unsigned char clear[]={0,0,0,0,0,0,0,0};

int main()
{
        can1_init();
        IODIR0=LED|LED1|LED2;
        IOSET0=LED|LED1|LED2;
        uart0_init(9600);
        lcd_init();
        can1_interupt_init();
        config_vic_CAN();
        lcd_cgram1(left);// page:0  &&  left-indecator
        lcd_cgram2(right);// page:1  &&  right-indecator
        lcd_cgram3(head2);// page:2  &&  Head-light
        lcd_cgram4(head1);// page:3  &&  Head-light
        lcd_cgram5(clear);//page:4 && clear
        while(1)
        {
          L1:
          if(flag==1 && v1.rtr==0)
          {
            flag=0;
                if(v1.id==0x3F0 && v1.byteA==0x13)//left-indecator ON
                {
                  uart0_tx_string("Left Indecator ON\r\n");
                  lif=1;
                  L3:
                  while(1)
                  {
                        IOSET0=LED1;
                        IOCLR0=LED;
                        lcd_cmd(0x83);
                        lcd_data(0);
                        delay_ms(100);

                        if(hlf==1)
                        {
                          lcd_cmd(0x83);
                          lcd_data(4);
                        }
                        else
                        {
                                lcd_cmd(0x01);
                        }
                        IOSET0=LED;
                        delay_ms(100);

                        if(flag==1)
                        {
                          if(v1.id==0x3F0 && v1.byteA==0x14)//left-indecator OFF
                          {
                            uart0_tx_string("Left Indecator OFF\r\n");
                                lif=0;
                                IOSET0=LED;
                                if(hlf==1)
                                {
                                  lcd_cmd(0x83);
                                  lcd_data(4);
                                }
                                else
                                {
                                        lcd_cmd(0x01);
                                }
                                flag=0;
                                goto L1;
                          }
                          else if(v1.id==0x3F6 && v1.byteA==0x30)
                          {
                                uart0_tx_string("Head-Lights ON\r\n");
                                IOCLR0=LED2;
                                flag=0;
                                goto L5;
                          }
                          else if(v1.id==0x3F6 && v1.byteA==0x31)
                          {
                                uart0_tx_string("Head-Lights OFF\r\n");
                                IOSET0=LED2;
                                lcd_cmd(0x01);
                                flag=0;
                          }
                          else if(v1.id==0x3F1 && v1.byteA==0x15)//Right Indecator ON
                          {
                                uart0_tx_string("RIGHT Indecator ON\r\n");
                                flag=0;
                                goto L2;
                          }
                        }
                  }
                }
                else if(v1.id==0x3F1 && v1.byteA==0x15)
                {
                  uart0_tx_string("RIGHT Indecator ON\r\n");
                  rif=1;
                  L2:
                  while(1)
                  {
                        IOSET0=LED;
                        IOCLR0=LED1;
                        lcd_cmd(0x88);
                        lcd_data(1);
                        delay_ms(100);

                        if(hlf==1)
                        {
                          lcd_cmd(0x88);
                          lcd_data(4);
                        }
                        else
                        {
                                lcd_cmd(0x01);
                        }
                        IOSET0=LED1;
                        delay_ms(100);

                        if(flag==1)
                        {
                          if(v1.id==0x3F1 && v1.byteA==0x16)
                          {
                                uart0_tx_string("RIGHT Indecator OFF\r\n");
                                IOSET0=LED1;
                                rif=0;
                                if(hlf==1)
                                {
                                  lcd_cmd(0x88);
                                  lcd_data(4);
                                }
                                else
                                {
                                  lcd_cmd(0x01);
                                }
                                goto L1;
                          }
                          else if(v1.id==0x3F6 && v1.byteA==0x30)
                          {
                                uart0_tx_string("Head-Lights ON\r\n");
                                IOCLR0=LED2;
                                flag=0;
                          }
                          else if(v1.id==0x3F6 && v1.byteA==0x31)
                          {
                                uart0_tx_string("Head-Lights OFF\r\n");
                                IOSET0=LED2;
                                flag=0;
                          }
                          else if(v1.id==0x3F0 && v1.byteA==0x13)
                          {
                            uart0_tx_string("Left Indecator ON\r\n");
                                flag=0;
                                goto L3;
                          }
                        }
                  }
            }
                else if(v1.id==0x3F6 && v1.byteA==0x30)
                {
                  uart0_tx_string("Head-Lights ON\r\n");
                  IOCLR0=LED2;
                  L5:
                  hlf=1;
                  lcd_cmd(0x85);
              lcd_data(2);
              lcd_cmd(0x86);
              lcd_data(3);
                  if(lif==1)
                  {
                     goto L3;
                  }
                  else if(rif==1)
                  {
                    goto L2;
                  }
                  flag=0;
                }
                else if(v1.id==0x3F6 && v1.byteA==0x31)
            {
                          uart0_tx_string("Head-Lights OFF\r\n");
                          IOSET0=LED2;
                          if(lif==1 || rif==1)
                          {
                                lcd_cmd(0x85);
                                lcd_data(4);
                                lcd_cmd(0x86);
                                lcd_data(4);
                          }
                          else
                          {
                                lcd_cmd(0x01);
                          }
                          hlf=0;
                          flag=0;
            }
          }
    }
 }

CAN DRIVER

C/C++
#include <LPC21xx.H>
#include "header.h"
extern int flag;
extern CAN1 v1;

void can1_init(void)
{
  VPBDIV=1;//pclk 60MHz
  PINSEL1|=0X14000;
  C2MOD=1;//Transmission Request
  C2BTR=0X001C001D;//Baud-Rate setting (125 kbps)
  AFMR=2;//By-pass filter ON
  C2MOD=0;//Reset mode
}

void can1_tx(CAN1 v)
{
 C2TID1=v.id; //0x123
 C2TFI1=v.dlc<<16;       //1
 if(v.rtr==0)            //1
 {
  C2TDA1=v.byteA;
  C2TDB1=v.byteB;
 }
 else
 {
  C2TFI1=(1<<30);
 }
 C2CMR=1|(1<<5);
 while(TCS==0);
}

void can1_rx(CAN1 *ptr)
{
 while(RBS==0);
 ptr->id=C2RID;
 ptr->dlc=((C2RFS>>16)&0XF);
 ptr->rtr=((C2RFS>>30)&1);
 if(ptr->rtr==0)
 {
   ptr->byteA=C2RDA;
   ptr->byteB=C2RDB;
 }
 C2CMR=(1<<2);
}

__irq void can1_rx_interupt_handler(void)
{
  v1.id=C2RID;
  v1.dlc=((C2RFS>>16)&0XF);
  v1.rtr=((C2RFS>>30)&1);
  if(v1.rtr==0)
  {
    v1.byteA=C2RDA;
        v1.byteB=C2RDB;
  }
  C2CMR=(1<<2);
  flag=1;
  VICVectAddr=0;
}


void can1_interupt_init(void)
{
   C2IER=1;
}

void config_vic_CAN(void)
{
 VICIntSelect=0;
 VICVectCntl0=27|(1<<5);
 VICVectAddr0=(unsigned int)can1_rx_interupt_handler;
 VICIntEnable=(1<<27);
}

UART DRIVER

C/C++
#include <LPC21xx.H>
#include "header.h"
#define LED (1<<17)
#include <stdio.h>


void uart0_init(unsigned int baud)
{
 unsigned int pclk,res;
 int a[]={15,60,30,15,15};
 PINSEL0|=0X5;
 pclk=a[VPBDIV]*1000000;
 res=pclk/(16*baud);
 U0LCR=0X83;
 U0DLL=((res>>0)&0xFF);
 U0DLM=((res>>8)&0XFF);
 U0LCR=0X03;
}

void uart0_tx(unsigned char data)
{
 while(THRE==0);
 U0THR=data;
}

unsigned char uart0_rx(void)
{
 while(RDR==0);
 return U0RBR;
}

void uart0_tx_string(unsigned char* ptr)
{
 while(*ptr!=0)
 {
  uart0_tx(*ptr);
  ptr++;
 }
}

void uart0_rx_string(unsigned char*ptr,unsigned int len)
{
 int i;
 for(i=0;i<len;i++)
 {
  while(RDR==0);
  ptr[i]=U0RBR;
  uart0_tx(ptr[i]);
  if(ptr[i]=='\r')
  {
   break;
  }
 }
 ptr[i]='\0';
}

void uart_tx_integer(int num)//123
{
 unsigned char a[10];
 int i;
 for(i=0;num>0;num/=10,i++)
 {
  a[i]=((num%10)+48);//321
 }
 for(i=i-1;i>=0;i--)
 {
  uart0_tx(a[i]);
 }
}

void integer_to_hex(unsigned int num)
{
 int c=0,d=1,n,n1,n2;
 unsigned char s[]="0123456789ABCDEF";
 n=num;
 for(  ;n;n/=10)
 {
  c++;
 }
 for(  ;c--; )
 {
  d=d*10;
 }
 n=num;
 while(num)     //255
 {
  n1=num%16;//
  n2=num/16;//
  if(n1>9)
  {
   n1=s[n1];
  }
  else
  {
   n1=n1+48;
  }
  if(n2>9)
  {
   n2=s[n2];
  }
  else
  {
   n2=n2+48;
  }
  num=num/d;
 }
 uart0_tx_string("0x");
 uart0_tx(n2);
 uart0_tx(n1);
}

int uart0_atoi(unsigned char*a1)
{
 int i,num=0;
 if(a1[0]=='-')
 {
  i=1;
 }
 else
 {
  i=0;
 }
 for( ;a1[i];i++)
 {
   if(a1[i]>='0' && a1[i]<='9')
   {
    num=((num*10)+(a1[i]-48));//123
   }
   else
   {
    break;
   }
 }
 if(a1[0]=='-')
 {
  return -num;
 }
 return num;
}

header.h

C/C++
#include <LPC21xx.H>

#define THRE ((U0LSR>>5)&1)
#define RDR  (U0LSR&1)

#define RS (1<<17)
#define RW (1<<18)
#define EN (1<<19)

#define CS      (1<<7)
#define SPIF ((S0SPSR>>7)&1)

#define SI ((I2CONSET>>3)&1)

#define SW1 ((IOPIN0>>14)&1)
#define SW2     ((IOPIN0>>15)&1)
#define SW3     ((IOPIN0>>16)&1)

#define TCS ((C1GSR>>3)&1)
#define RBS ((C1GSR>>0)&1)

typedef struct CAN_MSG
{
  unsigned int id;
  unsigned int byteA;
  unsigned int byteB;
  unsigned char rtr;
  unsigned char dlc;
}CAN1;

extern void uart0_init(unsigned int);
extern void uart0_tx(unsigned char);
extern unsigned char uart0_rx(void);
extern void uart0_tx_string(unsigned char*);
extern void uart_tx_integer(int num);
extern void uart0_config_VIC(void);
extern void uart0_interupt_enable(void);
extern void uart0_rx_string(unsigned char*ptr,unsigned int len);
extern void integer_to_hex(unsigned int);
extern int uart0_atoi(unsigned char*a1);

extern void delay_ms(unsigned int);
extern void delay_sec(unsigned int);
extern void delay_us(unsigned int);

extern void lcd_data(unsigned char);
extern void lcd_cmd(unsigned char);
extern void lcd_init(void);
extern void lcd_string(char*);
extern void lcd_cgram1(unsigned char *ptr);
extern void lcd_cgram2(unsigned char *ptr);
extern void lcd_cgram3(unsigned char *ptr);
extern void lcd_cgram4(unsigned char *ptr);
extern void lcd_cgram5(unsigned char *ptr);

extern void timer0_interupt_init(unsigned int);
extern void config_VIC(void);

extern void i2c_byte_write_frame(unsigned char ad,unsigned char mr,unsigned char data);
extern unsigned char i2c_byte_read_frame(unsigned char ad,unsigned char mr);
extern void i2c_init(void);

extern void spi0_init(void);
extern unsigned char spi0_data(unsigned char data);
extern unsigned short int mcp3204_read_data(unsigned char ch_num);

extern void can1_tx(CAN1 v);
extern void can1_init(void);
extern void can1_rx(CAN1 *ptr);
extern void config_vic_CAN(void);
extern void can1_interupt_init(void);

Credits

Nishant Patel

Nishant Patel

1 project • 0 followers
PCB Designer, proficient in troubleshooting, prototyping. Skilled in microcontrollers, protocols, C/C++, and Linux development.
Thanks to Nishant.

Comments