(1)i2c.
c
/
*************************************************************************************
*********
File
: I2C.c
Date
: Jan 2013
Target
: LPC2148
Description : Functions related to the I2C
*************************************************************************************
**********/
#include <LPC214X.H>
#include <Stdio.h>
#include "Type.h"
#include "I2C.h"
#include "TIMER.h"
/***************************************************
Contains all EEPROM related functions.
Writing to and reading from the EEPROM fuctions.
All the user data, settings and logged data
will goes into EEPROM.
I2C0 is used for interfacing.
****************************************************
*/
/*
Initialises the I2C protocol and port pins.
*/
void I2C_Init (void)
{
// Power on I2C0 peripheral
PCONP
|= 0x00000080;
// Define port pin as SDA and SCL
PINSEL0
|= 0x00000050 ;
I2C0CONCLR = 0x6C;
// clear all I2C config bits
I2C0CONSET = 0x40;
// set I2EN
// I2C Clock Duty Cycle (high and low)
I2C0SCLH
= PERIFERAL_OPERATING_FREQUENCY_IN_HZ/
(2*EEPROM_OPERATING_FREQUENCY_IN_HZ);
I2C0SCLL
= PERIFERAL_OPERATING_FREQUENCY_IN_HZ/
(2*EEPROM_OPERATING_FREQUENCY_IN_HZ);
}
/*
Waits until given status occured.
Return:
True on status occured and
False on time out
*/
BOOL I2C_WaitStatus (uint8 u8status)
{
TIMER0_RESET();
TIMER0_ENABLE();
while (T0TC < EEPROM_WAIT_TIME_OUT)
{
if (I2C0CONSET & 8) // poll SI bit
{
if (I2C0STAT == u8status)
{
TIMER0_DISABLE();
return TRUE;
}
}
}
TIMER0_DISABLE();
return FALSE;
}
/*
Reads data from EEPROM.
Return:
True on valid data and
False on time out or any error with device
*/
BOOL I2C_ReadFromEEPROM (uint32 u32startAddr, uint8 *u8ptr2arr, uint32 u32len)
{
uint32u32i;
// Check for upper limit
if (u32startAddr + u32len > EEPROM_SIZE)
return FALSE;
for (u32i=0;u32i<u32len;u32i++)
{
I2C0CONSET = 0x20;
if (!I2C_WaitStatus(0x08))
// Start set
// 0x08: ready for device address
return FALSE;
I2C0DAT
= EEPROM_DEVADDR;// addr[0]=0 means I2C write
I2C0CONCLR = 0x2C;
if (!I2C_WaitStatus(0x18))
// clear all except I2EN
// 0x18: ready for data byte
return FALSE;
// Transmit start address - Dummy byte write
I2C0DAT
#ifndef
EEPROM_24C02
= (u32startAddr & 0x000000FF) ;
I2C0CONCLR = 0x2C;
if (!I2C_WaitStatus(0x28))
// clear all except I2EN
// 0x28: ACK has been received
return FALSE;
I2C0CONCLR = 0x08;
I2C0DAT
// clear SI flag
= ((u32startAddr & 0x0000FF00)>>8) &0xFF;
#endif
I2C0CONCLR = 0x2C;
if (!I2C_WaitStatus(0x28))
// clear all except I2EN
// 0x28: ACK has been received
return FALSE;
I2C0CONCLR = 0x08;
// clear SI flag
I2C0CONSET = 0x10;
// generate stop condition
// Read data - Sequential mode.
I2C0CONSET = 0x20;
if (!I2C_WaitStatus(0x08))
// Start set
// 0x08: ready for device address
return FALSE;
I2C0DAT
= EEPROM_DEVADDR|0x01;
// addr[0]=1
means I2C read
I2C0CONCLR = 0x28;
if (!I2C_WaitStatus(0x40))
// clear all except I2EN and AA
// 0x40: ready for data byte
return FALSE;
I2C0CONCLR = 0x2C;
if (!I2C_WaitStatus(0x58))
// clear all except I2EN
// 0x58: data byte received return ACK
return FALSE;
u8ptr2arr[u32i]
= (uint8)I2C0DAT ;
u32startAddr++;
I2C0CONSET = 0x10;
I2C0CONCLR = 0x2C;
}
return TRUE;
}
// generate stop condition
/*
Writes data to EEPROM.
Return:
True on successful write and
False on time out or any error with device
*/
BOOL I2C_WriteToEEPROM (uint32 u32startAddr, uint8 *u8ptr2arr, uint32 u32len)
{
uint32u32i,u32j;
// Check for upper limit
if (u32startAddr + u32len > EEPROM_SIZE)
return FALSE;
// write data byte wise
for (u32i = 0; u32i < u32len; u32i++)
{
I2C0CONSET = 0x20;
if (!I2C_WaitStatus(0x08))
// Start set
// 0x08: ready for device address
return FALSE;
I2C0DAT
= EEPROM_DEVADDR;// addr[0]=0 means I2C write
I2C0CONCLR = 0x2C;
if (!I2C_WaitStatus(0x18))
// clear all except I2EN
// 0x18: ready for data byte
return FALSE;
// Transmit start address
I2C0DAT
#ifndef
= (u32startAddr & 0x000000FF);
EEPROM_24C02
I2C0CONCLR = 0x2C;
if (!I2C_WaitStatus(0x28))
// clear all except I2EN
// 0x28: ACK has been received
return FALSE;
//I2C0CONCLR
= 0x08;
// clear SI flag
I2C0DAT
= ((u32startAddr & 0x0000FF00)>>8) &0xFF;
#endif
I2C0CONCLR = 0x2C;
// clear all except I2EN
if (!I2C_WaitStatus(0x28))
// 0x28: ACK has been received
return FALSE;
I2C0DAT
= (u8ptr2arr[u32i])&0x000000FF;
u32startAddr++;
I2C0CONCLR = 0x2C;
// clear all except I2EN
if (!I2C_WaitStatus(0x28))
// 0x28: ACK has been received
return FALSE;
I2C0CONSET = 0x10;
// generate stop condition
I2C0CONCLR = 0x2C;
// Poll for write done
for (u32j=20;u32j>0;u32j--)
{
I2C0CONSET = 0x20;
// Start set
if (!I2C_WaitStatus(0x08)) // 0x08: ready for device address
return FALSE;
I2C0DAT
= EEPROM_DEVADDR;// addr[0]=0 means
I2C write
I2C0CONCLR = 0x2C;
// clear all except I2EN
if (I2C_WaitStatus(0x18)) // 0x18: ready for data byte
break;
else
{
I2C0CONCLR = 0x2C;
I2C0CONSET = 0x10;
// generate stop condition
I2C0CONCLR = 0x2C;
}
}
I2C0CONSET = 0x10;
// generate stop condition
I2C0CONCLR = 0x2C;
}
return TRUE;
}
(2)main.c
/
******************************************************************
*********************************************
Project
: I2CLPC2148
File
Date
Target
: main.c
: May 2016
: LPC2148
Description : Functions related to the I2C EEPROM. The program
reads and write the data in EEPROM through I2C
******************************************************************
**********************************************/
#include <LPC214X.H>
#include <Stdio.h>
#include "Type.h"
#include "uart.h"
#include "I2C.h"
#include "TIMER.h"
/***************************************************
Main function.
***************************************************/
int main(void)
{
uint8 write_buffer[20] = {'B', 'I', 'N', 'A', 'R', 'Y',0};
uint8 read_buffer[20];
uint32 delay;
PINSEL0 |= 0x00000005 ;
UART0_Init(); // Initialize UART0
I2C_Init();
// Initialize I2C0
TIMER_Init();
// Initialize Timer
UART0_Write_Text("********* LPC2148 ARM7 I2C EEPROM
Demo **********\n\n\r");
UART0_Write_Text("Initialization done. \n\r\n");
while(1)
{
if (!I2C_WriteToEEPROM(0, write_buffer, 20))
write into EEPROM
UART0_Write_Text("\nMemory write error.");
if (!I2C_ReadFromEEPROM(0, read_buffer, 20))
// read from EEPROM
UART0_Write_Text("\nMemory Read error..");
UART0_Write_Text("\n\r The Read Data are: \t");
UART0_Write_Text((char *)read_buffer);
// display data on serial port
UART0_Write_Text("\n\r");
for(delay=0;delay<=5000000;delay++);
}
//return 0 ;
}
//
(3)timer.c
/
******************************************************************
****************************
File
Date
Target
: Timer.c
: Jan 2013
: LPC2148
Description : Functions related to the Timer
******************************************************************
*****************************/
#include <LPC214X.H>
#include "Type.h"
#include "Timer.h"
/**************************************************
Timer0 is used for delay in micro sec
Timer1 is used for time out delay
Timer is initialized to simply count at a specified
frequency(Configuration.h).
Count can be read from register TC.
****************************************************/
/*Initialises the timers*/
void TIMER_Init (void)
{
// Power ON timer peripheral
PCONP
|= 0x00000006;
// TPC: Timer Prescaler counter
// the counter is incremented once every TPC+1 cycles of
PCLK
T0PR= PRESCALER0;
//T1PR
= PRESCALER1;
// TCR: Timer Control Register
// 2: reset counters (both timer and prescaler)
// 1: enable counting
T0TCR=2;
//T1TCR=2;
}
/*waits for next tick in timer*/
void TIMER_WaitForNextTick (void)
{
uint32 start=T0TC;
while (T0TC==start) {}
// wait until timer counter
changes, then leave
}
(4)uart.c
/
******************************************************************
****************************
File
Date
Target
: UART.c
: Jan 2013
: LPC2148
Description : Functions related to the UART)
******************************************************************
*****************************/
#include <LPC21xx.h>
#include "TYPE.h"
#include "UART.h"
/***************UART-0 Functions**************/
void UART0_Init(void)
{
PINSEL0 |= 0x00000005;
//P0.0 as TX0 and P0.1 as
RX0
U0LCR = 0x83;
//Enable
access to Divisor Latches
//and Set 8 bit Character Length with 1 Stop bit and Parity
Disabled
//Access to Divisor Latches is Enabled, in order to write Baud
Rate Generator Registers
//Values to be written in Baud Rate Registers U0DLM and
U0LL
/*
Formula is
Baud_Rate = PCLK*MulVal /
[(16*(256*U0DLM+U0DLL)*(MulVal + DivAddVal))]
Example:MulVal = 1;
DivAddVal = 0;
Baud_Rate = 9600;
PCLK = 15MHz
U0DLM = 0;
Hence,
U0DLL = 15000000/(9600*16) = 97.65625 = 98
U0DLL = 98 = 0x62
*/
U0DLM = 0x00;
U0DLL = 0x62;
//Baud Rate of 9600
U0LCR = 0x03;
//Disable Access to Divisor Latches
}
void UART0_Write(unsigned char value)
{
/*
THRE bit can be extracted by this U0LSR & 0x20
THRE = 0 means data is present.
THRE = 1 means register is empty.
In order to transmit data, we have to wait will the THRE = 1,
then only we can transmit data.
*/
while(!(U0LSR&0x20));
0 stay here
U0THR = value;
}
//THRE =
void UART0_Write_Text(char * msg)
{
while(*msg)
{
UART0_Write(*msg);
msg++;
}
}
unsigned char UART0_Read(void)
{
/*
Receiver Data Ready = U0LSR.0 bit
RDR bit can be extracted by this U0LSR & 0x01
RDR = 0 means no Data is Received in U0RBR
RDR = 1 means that Data is present in U0RBR
*/
while(!(U0LSR & 0x01));
stay here
return (U0RBR);
}
/***************UART-1 Functions**************/
void UART1_Init(void)
{
//RDR = 0
PINSEL0 |= 0x00050000;
//P0.8 as TX1 and P0.9 as
RX1
U1LCR = 0x83;
//Enable
access to Divisor Latches
//and Set 8 bit Character Length with 1 Stop bit and Parity
Disabled
//Access to Divisor Latches is Enabled, in order to write Baud
Rate Generator Registers
//Values to be written in Baud Rate Registers U0DLM and
U0LL
/*
Formula is
Baud_Rate = PCLK*MulVal /
[(16*(256*U0DLM+U0DLL)*(MulVal + DivAddVal))]
Example:MulVal = 1;
DivAddVal = 0;
Baud_Rate = 9600;
PCLK = 15MHz
U0DLM = 0;
Hence,
U0DLL = 15000000/(9600*16) = 97.65625 = 98
U0DLL = 98 = 0x62
*/
U1DLM = 0x00;
U1DLL = 0x62;
//Baud Rate of 9600
U1LCR = 0x03;
//Disable Access to Divisor Latches
}
void UART1_Write(unsigned char value)
{
/*
THRE bit can be extracted by this U0LSR & 0x20
THRE = 0 means data is present.
THRE = 1 means register is empty.
In order to transmit data, we have to wait will the THRE = 1,
then only we can transmit data.
*/
while(!(U1LSR&0x20));
0 stay here
U1THR = value;
}
void UART1_Write_Text(unsigned char * msg)
{
while(*msg)
//THRE =
{
UART1_Write(*msg);
msg++;
}
}
unsigned char UART1_Read(void)
{
/*
Receiver Data Ready = U0LSR.0 bit
RDR bit can be extracted by this U0LSR & 0x01
RDR = 0 means no Data is Received in U0RBR
RDR = 1 means that Data is present in U0RBR
*/
while(!(U1LSR & 0x01));
//RDR = 0
stay here
return (U1RBR);
}
(5)i2c.h
#ifndef I2C_H
#define I2C_H
/* Settings */
#define
PERIFERAL_OPERATING_FREQUENCY_IN_HZ
#define
EEPROM_OPERATING_FREQUENCY_IN_HZ50000
#define EEPROM_DEVADDR
14745600
0xA0
#define
EEPROM_24C512
// EEPROM IC used
#define
EEPROM_SIZE
0xFFFF
// Size
#define
EEPROM_WAIT_TIME_OUT
//EEPROM_24C02
size 0x0000FF
//EEPROM_24C04
size 0x0001FF
//EEPROM_24C08
size 0x0003FF
//EEPROM_24C16
size 0x0007FF
//EEPROM_24C32
size 0x000FFF
//EEPROM_24C64
size 0x001FFF
5000 // 1msec
//EEPROM_24C128 size 0x003FFF
//EEPROM_24C256 size 0x007FFF
//EEPROM_24C512 size 0x00FFFF
/* Function Definations */
extern
void I2C_Init (void);
extern
BOOL
I2C_WaitStatus (uint8 u8status);
extern
BOOL
I2C_WriteToEEPROM (uint32 u32startAddr,
uint8 *u8ptr2arr, uint32 u32len);
extern
BOOL
I2C_ReadFromEEPROM (uint32 u32startAddr,
uint8 *u8ptr2arr, uint32 u32len);
#endif //I2C_H
(6)timer.h
/
******************************************************************
****************************
File
: Timer.h
Date
: Jan 2013
Target
: LPC2148
Description : Functions related to the Timer
******************************************************************
*****************************/
#ifndef TIMER_H
#define TIMER_H
/* Prescaler */
#define PERIFERAL_OPERATING_FREQUENCY_IN_HZ
14745600
#define DESIRED_COUNT_FREQ0
1000000
//1MHz
#define PRESCALER0
((PERIFERAL_OPERATING_FREQUENCY_IN_HZ/DESIRED_COUNT_FR
EQ0)-1)
//#define PRESCALER1
((PERIFERAL_OPERATING_FREQUENCY_IN_HZ/DESIRED_COUNT_FR
EQ1)-1)
#define
TIMER0_RESET()
T0TCR=2
#define
TIMER0_ENABLE()
T0TCR=1
#define
TIMER0_DISABLE()
T0TCR=0
/* Function declrations */
extern void TIMER_Init (void);
extern void TIMER_WaitForNextTick (void);
#endif /* TIMER_H */
(7) type.h
#ifndef TYPE_H
#define TYPE_H
#ifndef NULL
#define NULL
(0)
#endif
#ifndef FALSE
#define FALSE (0)
#endif
#ifndef TRUE
#define TRUE
(1)
#endif
/* Arm data types */
typedef unsigned char
uint8;
typedef unsigned short int
uint16;
typedef unsigned int
uint32;
typedef char
int8;
typedef short int
int16;
typedef int
int32;
typedef unsigned char
BOOL;
/*
Data Type
Actual Cdata type Bytes allocated.
uint8
unsigned char
int8
char
1
1
uint16
unsigned short
int16
short
uint32
unsigned long
int32
long
float32
32 bit float
float64
double
*/
/*
Data type Short form
int8
i8
uint8
u8
int16
i16
uint16
u16
int32
i32
uint32
u32
4
8
float32
fl32
float64
fl64
pointer
ptr
bool
*/
#endif // TYPE_H
(8)uart.h
/
******************************************************************
****************************
File
Date
: UART.h
: Jan 2013
Target
: LPC2148
Description : Functions related to the UART)
******************************************************************
*****************************/
#ifndef UART_H
#define UART_H
void UART0_Init(void);
void UART0_Write(unsigned char value);
void UART0_Write_Text(char *msg);
unsigned char UART0_Read(void);
void UART1_Init(void);
void UART1_Write(unsigned char value);
void UART1_Write_Text(unsigned char *msg);
unsigned char UART1_Read(void);
#endif /* UART0_H */
