WebSVN - NaviCtrl - Diff - Rev 482 and 483



// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include <string.h>
#include <stdio.h>
#include "91x_lib.h"
#include "i2c1.h"
#include "uart1.h"
#include "timer1.h"
#include "eeprom.h"
#include "led.h"

 
 
 
 
 

// The EEPROM M24C64 (64k) ist connected via I2C1 interface to the controller.
// The E0, E2, E3 pins are set to low. Therefore the slave adressbits b3, b2, b1 are 0.
 

}

 
// ----------------------------------------------------------------------------------------
EEPROM_Result_t EEPROM_Transfer(u8 Direction, u16 Address, u8 *pData, u16 DataLen)
{
        u16 i, TxBytes = 0;
        u8 retry = 0;

        EEPROM_Result_t retval = EEPROM_ERROR_UNKNOWN;
 
        if(((u32)Address + (u32)DataLen) >= (EEPROM_SIZE - 1))
        {
                retval = EEPROM_ERROR_OUT_OF_ADDRESS_RANGE;
                return(retval);
        }
        if((DataLen+2) > I2C1_BUFFER_LEN)
        {
                retval = EEPROM_I2C_BUFFER_OVERRUN;
                return(retval);
        }
        do
        {
                if(!I2C1_LockBuffer(I2C_IDLE_TIMEOUT)) return EEPROM_ERROR_I2C_IDLE_TIMEOUT;
 
                // buffer is now locked
                TxBytes = 0;
                // transmitt address
                I2C1_Buffer[TxBytes++] = (u8)(0x00FF & (Address>>8));
                I2C1_Buffer[TxBytes++] = (u8)(0x00FF & Address);
                if(Direction == EEPROM_WRITE)
                {       // copy data to i2c transfer buffer
                        for(i = 0; i<DataLen;i++)
                        {
                                I2C1_Buffer[TxBytes++] = pData[i];
                        }
                        // prepare pointer to rx data
                        EEPROM_pData = 0;
                        EEPROM_DataLen = 0;
                        // start transmission
                        if(!I2C1_Transmission(EEPROM_I2C_ADDRESS, TxBytes, 0, 0))
                        {
                                return(retval);
                        }
                }
                else // Direction == EEPROM_READ
                {
                        // prepare pointer to rx data
                        EEPROM_pData = pData;
                        EEPROM_DataLen = DataLen;
                        // start transmission
                        if(!I2C1_Transmission(EEPROM_I2C_ADDRESS, TxBytes, &EEPROM_RxDataHandler, DataLen))
                        {
                                return(retval);
                        }
                }
                //wait for end of this transfer
                if(I2C1_WaitForEndOfTransmission(I2C_TRANSFER_TIMEOUT))
                {
                        if(I2C1_Error == I2C_ERROR_NONE) return(EEPROM_SUCCESS);
                        else retval = EEPROM_DATA_TRANSFER_INCOMPLETE;
                }
                else// i2c transfer timed out

        u16 AdrOffset = 0;
        u16 RxLen;

 
        while(DataLen > 0)
        {
                if(DataLen > I2C1_BUFFER_LEN) RxLen = I2C1_BUFFER_LEN;

                else RxLen = DataLen;
           
                retval = EEPROM_Transfer(EEPROM_READ, Address+AdrOffset, &(pData[AdrOffset]), RxLen);

Rev 482	Rev 483
Line 54...	Line 54...
54	// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.	54	// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.
55	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	55	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
56	#include <string.h>	56	#include <string.h>
57	#include <stdio.h>	57	#include <stdio.h>
58	#include "91x_lib.h"	58	#include "91x_lib.h"
59	#include "i2c.h"	59	#include "i2c1.h"
60	#include "uart1.h"	60	#include "uart1.h"
61	#include "timer1.h"	61	#include "timer1.h"
62	#include "eeprom.h"	62	#include "eeprom.h"
63	#include "led.h"	63	#include "led.h"
Line 64...	Line -...
64		-
65		64
66		-
67	// The EEPROM M24C64 (64k) ist connected via I2C1 interface to the controller.	-
68	#define EEPROM_I2C I2C1	65
Line 69...	Line 66...
69		66	// The EEPROM M24C64 (64k) ist connected via I2C1 interface to the controller.
70	// The E0, E2, E3 pins are set to low. Therefore the slave adressbits b3, b2, b1 are 0.	67	// The E0, E2, E3 pins are set to low. Therefore the slave adressbits b3, b2, b1 are 0.
71		68
Line 93...	Line 90...
93	}	90	}
Line 94...	Line 91...
94		91
95	// ----------------------------------------------------------------------------------------	92	// ----------------------------------------------------------------------------------------
96	EEPROM_Result_t EEPROM_Transfer(u8 Direction, u16 Address, u8 *pData, u16 DataLen)	93	EEPROM_Result_t EEPROM_Transfer(u8 Direction, u16 Address, u8 *pData, u16 DataLen)
97	{	94	{
98	u16 i;	95	u16 i, TxBytes = 0;
99	u8 retry = 0;	96	u8 retry = 0;
Line 100...	Line 97...
100	EEPROM_Result_t retval = EEPROM_ERROR_UNKNOWN;	97	EEPROM_Result_t retval = EEPROM_ERROR_UNKNOWN;
101		98
102	if(((u32)Address + (u32)DataLen) >= (EEPROM_SIZE - 1))	99	if(((u32)Address + (u32)DataLen) >= (EEPROM_SIZE - 1))
103	{	100	{
104	retval = EEPROM_ERROR_OUT_OF_ADDRESS_RANGE;	101	retval = EEPROM_ERROR_OUT_OF_ADDRESS_RANGE;
105	return(retval);	102	return(retval);
106	}	103	}
107	if((DataLen+2) > I2C_BUFFER_LEN)	104	if((DataLen+2) > I2C1_BUFFER_LEN)
108	{	105	{
109	retval = EEPROM_I2C_BUFFER_OVERRUN;	106	retval = EEPROM_I2C_BUFFER_OVERRUN;
110	return(retval);	107	return(retval);
111	}	108	}
112	do	109	do
113	{	110	{
114	if(!I2CBus_LockBuffer(EEPROM_I2C, I2C_IDLE_TIMEOUT)) return EEPROM_ERROR_I2C_IDLE_TIMEOUT;	111	if(!I2C1_LockBuffer(I2C_IDLE_TIMEOUT)) return EEPROM_ERROR_I2C_IDLE_TIMEOUT;
115	// buffer is now locked	-
116	u8 TxBytes = 0;	112	// buffer is now locked
117	u8 TxData[255];	113	TxBytes = 0;
118	// transmitt address	114	// transmitt address
119	TxData[TxBytes++] = (u8)(0x00FF & (Address>>8));	115	I2C1_Buffer[TxBytes++] = (u8)(0x00FF & (Address>>8));
120	TxData[TxBytes++] = (u8)(0x00FF & Address);	116	I2C1_Buffer[TxBytes++] = (u8)(0x00FF & Address);
121	if(Direction == EEPROM_WRITE)	117	if(Direction == EEPROM_WRITE)
122	{ // copy data to i2c transfer buffer	118	{ // copy data to i2c transfer buffer
123	for(i = 0; i<DataLen;i++)	119	for(i = 0; i<DataLen;i++)
124	{	120	{
125	TxData[TxBytes++] = pData[i];	121	I2C1_Buffer[TxBytes++] = pData[i];
126	}	122	}
127	// prepare pointer to rx data	123	// prepare pointer to rx data
128	EEPROM_pData = 0;	124	EEPROM_pData = 0;
129	EEPROM_DataLen = 0;	125	EEPROM_DataLen = 0;
130	// start transmission	126	// start transmission
131	if(!I2CBus_Transmission(EEPROM_I2C, EEPROM_I2C_ADDRESS, TxData, TxBytes, 0, 0))	127	if(!I2C1_Transmission(EEPROM_I2C_ADDRESS, TxBytes, 0, 0))
132	{	128	{
133	return(retval);	129	return(retval);
134	}	130	}
135	}	131	}
136	else // Direction == EEPROM_READ	132	else // Direction == EEPROM_READ
137	{	133	{
138	// prepare pointer to rx data	134	// prepare pointer to rx data
139	EEPROM_pData = pData;	135	EEPROM_pData = pData;
140	EEPROM_DataLen = DataLen;	136	EEPROM_DataLen = DataLen;
141	// start transmission	137	// start transmission
142	if(!I2CBus_Transmission(EEPROM_I2C, EEPROM_I2C_ADDRESS, TxData, TxBytes, &EEPROM_RxDataHandler, DataLen))	138	if(!I2C1_Transmission(EEPROM_I2C_ADDRESS, TxBytes, &EEPROM_RxDataHandler, DataLen))
143	{	139	{
144	return(retval);	140	return(retval);
145	}	141	}
146	}	142	}
147	//wait for end of this transfer	143	//wait for end of this transfer
148	if(I2CBus_WaitForEndOfTransmission(EEPROM_I2C, I2C_TRANSFER_TIMEOUT))	144	if(I2C1_WaitForEndOfTransmission(I2C_TRANSFER_TIMEOUT))
149	{	145	{
150	if(I2CBus(EEPROM_I2C)->Error == I2C_ERROR_NONE) return(EEPROM_SUCCESS);	146	if(I2C1_Error == I2C_ERROR_NONE) return(EEPROM_SUCCESS);
151	else retval = EEPROM_DATA_TRANSFER_INCOMPLETE;	147	else retval = EEPROM_DATA_TRANSFER_INCOMPLETE;
152	}	148	}
153	else// i2c transfer timed out	149	else// i2c transfer timed out
Line 192...	Line 188...
192	u16 AdrOffset = 0;	188	u16 AdrOffset = 0;
193	u16 RxLen;	189	u16 RxLen;
Line 194...	Line 190...
194		190
195	while(DataLen > 0)	191	while(DataLen > 0)
196	{	192	{
197	if(DataLen > I2C_BUFFER_LEN) RxLen = I2C_BUFFER_LEN;	193	if(DataLen > I2C1_BUFFER_LEN) RxLen = I2C1_BUFFER_LEN;
Line 198...	Line 194...
198	else RxLen = DataLen;	194	else RxLen = DataLen;
199		195
200	retval = EEPROM_Transfer(EEPROM_READ, Address+AdrOffset, &(pData[AdrOffset]), RxLen);	196	retval = EEPROM_Transfer(EEPROM_READ, Address+AdrOffset, &(pData[AdrOffset]), RxLen);

Subversion Repositories NaviCtrl

(root)/tags/V2.04a/eeprom.c @ 654 - Rev 482 → 483