اطلاعیه

Collapse
No announcement yet.

مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

Collapse
X
 
  • فیلتر
  • زمان
  • Show
Clear All
new posts

    مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

    درود به همگی.
    من برنامه I2C با یه eeprom رو جواب گرفتم. ولی وقتی از یه باس مشترک برا دو تا eeprom استفاده میکنی، eeprom دوم نه مقداری مینویسه نه مقداری میخونه. اگه آدرس eeprom اول 0xA0 یا 160 باشه، eeprom دوم باید 0xA2 یا 162 باشه درسته ؟؟ حتی پایه A0 eeprom دوم رو به Vcc وصل کردم ولی باز جواب نمیده.
    اینم برنامه.
    کد:
    /*-------------------------------------------------------------------------------
    																 www.ECA.ir
    												  LPC1768 Dev Board Rev.A
    --------------------------------------------------------------------------------*/
    #include <lpc17xx.h>
    #include <stdio.h>
    #include "i2c.h"
    
    #define LCD_LPC1768    
    #define LCD_PORT_1
    #define LCD_RS   14
    #define LCD_RW   10
    #define LCD_E   9
    #define LCD_DB4  8
    #define LCD_DB5  4
    #define LCD_DB6  1
    #define LCD_DB7  0
    
    #include "lcd.h"
    
    extern uint8_t buf[32];
    extern uint8_t bu[32];
    
    
    void Delay(uint32_t delaydata)
    {
    	uint32_t i,j,k;
    	for(i=0;i<delaydata;i++)
    		for(j=0;j<1000;j++)
    			for(k=0;k<100;k++)
    			;
    }
    
    
    
    int main (void)
    {
    	uint32_t i;
    	//char blcd[16];
    	SystemInit();
    	LPC_GPIO2->FIODIR  = 0x000000ff;        /* LEDs PORT2 are Output        */
    	LPC_GPIO0->FIODIR  |= 0x03f80000;
    	LPC_GPIO0->FIOSET  = 0x03f80000;
    	if ( I2CInit( (uint32_t)I2CMASTER ) == 0 )		  /* initialize I2c           */
    	{
    		while ( 1 );								          /* Fatal error             */
    	}
    	
    	for ( i = 0; i < 8; i++ )					        /* clear buffer            */
    	{
    		buf[i]=i+1;
    	}
    	//sprintf(buf,"Hello World !");
    	I2C_WriteNByte(0xa0, 1, 0x00, buf, 8);     /* write buf array into EEPROM      */
    	Delay(50);
    	
    	for ( i = 0; i < 8; i++ )				       	 /* clear buffer             */
    	{
    		buf[i] =0;
    	}
    	 
    	I2C_ReadNByte (0xa0, 1, 0x00, buf, 8);     /* read from EEPROM & save in buf array */   
    	Delay(50);
    
    	for ( i = 8; i < 15; i++ )					        /* clear buffer            */
    	{
    		bu[i]=i+1;
    	}
    	//sprintf(buf,"Hello World !");
    	I2C_WriteNByte(0xa2, 1, 0x01, bu, 8);     /* write buf array into EEPROM      */
    	Delay(50);
    
    	for ( i = 8; i < 15; i++ )				       	 /* clear buffer             */
    	{
    		bu[i] =0;
    	}
    
    	I2C_ReadNByte (0xa2, 1, 0x00, bu, 8);     /* read from EEPROM & save in buf array */   
    	Delay(50);
    
    	lcd_init();
    	lcd_clear();
    	lcd_gotoxy(1,3);
    	lcd_putsf("I2C Example");
    	lcd_gotoxy(2,1);
    
    	//lcd_putsf(buf);
    
    	while(1)
    	{
    		
    		for(i=0;i<8;i++)
    		{
    			/*
    			LPC_GPIO2->FIOPIN = buf[i];
    			lcd_gotoxy(2,1);
    			sprintf(blcd,"T=%c",buf[i]);
    			lcd_putsf(blcd);
    			Delay(100);
    		 */
    			lcd_puts(buf[i]);
    			Delay(100);
    		}
    		for(i=8;i<15;i++)
    		{
    			lcd_puts(bu[i]);
    			Delay(100);
    		}	
    	 
    	}
    
    }

    #2
    پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

    اخ داغ دل منو تازه کردی.با این تابع ببین میتونی به جای اینکه I تا 8 بشموره بیاد تا 12 بشموره و تو ایتوپرام قراش بدی.
    برای سوال خودت هم بستگی داره از ایتوپرام چند کیلو استفاده میکنی و ادرس پایه ها رو چند گذاشتی.دیتاشیت خوب توضیح داد

    دیدگاه


      #3
      پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

      از eeprom 2 دو کیلو استفاده میکنم. 24C02 ، دیتاشیت خود eeprom منظرتون؟

      دیدگاه


        #4
        پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

        بله.دیتا شیت خود ایتوپرام.اگه تونستی با این توابع اطلاعات بیشتری در ایتوپرام ذخیره کنی حتما به منم بگو.توی سایت همسایه در مورد این دوتابع بیشتر صحبت شده.طریقه ادرس دادن شما اشتباست.به مثال زیر توجه کن
        کد:
        #include "lpc17xx.h"
        #include "24LC16.h"
        #include "timer.h"
        #include "i2c.h"
        
        void EEPROMInit(uint32_t peripheral)
        {
        	TimerInit(2,500);
        
        	switch (peripheral) {
        		case 0:
        			I2C0Init();
        			break;
        		case 1:
        			I2C1Init(selected_port);
        			break;
        		case 2:
        			I2C2Init();
        			break;
        
        	i2c_address_read = (161);
        	i2c_address_write = (160);
        
        	}
        }
        
        /*void EEPROMSetBlock(uint8_t blocknr)
        {
        	switch (blocknr) {
        		case 0:
        			i2c_address_read = (Block0 | (1<<0));
        			i2c_address_write = (Block0 | (0<<0));
        			break;
        		case 1:
        			i2c_address_read = (Block1 | (1<<0));
        			i2c_address_write = (Block1 | (0<<0));
        			break;
        		case 2:
        			i2c_address_read = (Block2 | (1<<0));
        			i2c_address_write = (Block2 | (0<<0));
        			break;
        		case 3:
        			i2c_address_read = (Block3 | (1<<0));
        			i2c_address_write = (Block3 | (0<<0));
        			break;
        		case 4:
        			i2c_address_read = (Block4 | (1<<0));
        			i2c_address_write = (Block4 | (0<<0));
        			break;
        		case 5:
        			i2c_address_read = (Block5 | (1<<0));
        			i2c_address_write = (Block5 | (0<<0));
        			break;
        		case 6:
        			i2c_address_read = (Block6 | (1<<0));
        			i2c_address_write = (Block6 | (0<<0));
        			break;
        		case 7:
        			i2c_address_read = (Block7 | (1<<0));
        			i2c_address_write = (Block7 | (0<<0));
        			break;
        	}
        }/*/
        
        void EEPROMWrite(uint32_t peripheral, uint32_t memory_address, uint8_t value)
        {
        	uint32_t portused = peripheral;
        
        	I2CWriteLength[portused] = 3;
        	I2CReadLength[portused] = 0;
        	I2CMasterBuffer[portused][0] = i2c_address_write;
        	I2CMasterBuffer[portused][1] = memory_address;
        	I2CMasterBuffer[portused][2] = value;
        	I2CEngine(portused);
        	delayMs(2,5);
        }
        
        uint8_t EEPROMRead(uint32_t peripheral,uint32_t memory_address)
        {
        	uint8_t value;
        	uint32_t portused = peripheral;
        
        	I2CWriteLength[portused] = 2;
        	I2CReadLength[portused] = 1;
        	I2CMasterBuffer[portused][0] = i2c_address_write;
        	I2CMasterBuffer[portused][1] = memory_address;
        	I2CEngine(portused);
        
        	I2CWriteLength[portused] = 1;
        	I2CMasterBuffer[portused][0] = i2c_address_read;
        	I2CEngine(portused);
        	delayMs(2,5);
        
        	value = I2CSlaveBuffer[portused][0];
        
        	return value;
        }
        کد:
        #define I2C0    	0
        #define I2C1			1
        #define I2C2			2
        
        /*Set 0 for ports 0.0 and 0.1 ---- Set 1 for ports 0.19 and 0.20*/
        #define selected_port	0
        
        #define Block0			0b10100000
        #define Block1			0b10100010
        #define Block2			0b10100100
        #define Block3			0b10100110
        #define Block4			0b10101000
        #define Block5			0b10101010
        #define Block6			0b10101100
        #define Block7			0b10101110
        
        uint8_t i2c_address_read;
        uint8_t i2c_address_write;
        
        void EEPROMInit(uint32_t peripheral);
        void EEPROMSetBlock(uint8_t blocknr);
        void EEPROMWrite(uint32_t peripheral,uint32_t memory_address, uint8_t value);
        uint8_t EEPROMRead(uint32_t peripheral,uint32_t memory_address);
        فکر میکنم تو سایت همسایه نوشته بود uint8_t suba_type برای ادرس دهی چند ایتوپرام هست.در هدر بالا A0.A1.A2 را برای دستیابی به پیج دیتا های ایتوپرام استفاده کرده

        دیدگاه


          #5
          پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

          مرسی. روش کار میکنم. نتیجش میذارم.

          دیدگاه


            #6
            پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

            برنامه رو تا یه حدی ویرایش کردم. ولی بازم مشکل داره. شش بایت میخونه بقیش 255 رو نشون میده. اینم برنامه :
            کد:
            #include <lpc17xx.h>
            #include <stdio.h>
            #include <lpc17xx_i2c.h>
            #include <lpc17xx_pinsel.h>
            
            #define LCD_LPC1768    
            #define LCD_PORT_1
            #define LCD_RS   14
            #define LCD_RW   10
            #define LCD_E   9
            #define LCD_DB4  8
            #define LCD_DB5  4
            #define LCD_DB6  1
            #define LCD_DB7  0
            
            #include "lcd.h"
            
            #define I2CDEV_S_ADDR	80
            #define BUFFER_SIZE		8
            #define I2CDEV_M LPC_I2C0
            
            uint8_t Master_Buf[BUFFER_SIZE];
            uint8_t master_test[2];
            char buf[16];
            
            //*****************************************************************
            void Buffer_Init(uint8_t type)
            {
            	uint8_t i;
            
            	if (type)
            	{
            		for (i = 0; i < BUFFER_SIZE; i++) {
            			Master_Buf[i] = i;
            		}
            	}
            	else
            	{
            		for (i = 0; i < BUFFER_SIZE; i++) {
            			Master_Buf[i] = 0;
            		}
            	}
            }
            //*****************************************************************
            
            void Delay(uint32_t delaydata)
            {
            	uint32_t i,j,k;
            	for(i=0;i<delaydata;i++)
            		for(j=0;j<1000;j++)
            			for(k=0;k<100;k++)
            			;
            }
            
            void _delay(){
            	uint32_t i;
            	for(i=0;i<18000000;i++);
            }
            //*****************************************************************
            int main(void)
            {
            
            	PINSEL_CFG_Type PinCfg;
            	I2C_M_SETUP_Type transferMCfg;
            	uint8_t i;
            	
            	
            	//LPC_SC->PCONP |= (1 << 7);//enable I2C0
            	//LPC_PINCON->PINSEL1 |= 0x01400000; //p0.27 as SDA.0 , p0.28 as SCL.0
            	
            	
            	PinCfg.OpenDrain = 0;
            	PinCfg.Pinmode = 0;
            	PinCfg.Funcnum = 1;
            	PinCfg.Pinnum = 27;
            	PinCfg.Portnum = 0;
            	PINSEL_ConfigPin(&PinCfg);
            	PinCfg.Pinnum = 28;
            	PINSEL_ConfigPin(&PinCfg);
            	
            
            	I2C_Init(I2CDEV_M, 100000);
            	I2C_Cmd(I2CDEV_M, ENABLE);
            	/*
            	Buffer_Init(0);
            	master_test[0] = 'A';
            	master_test[1] = 'B';
            
            	transferMCfg.sl_addr7bit = I2CDEV_S_ADDR;
            	transferMCfg.tx_data = master_test ;
            	transferMCfg.tx_length = sizeof(master_test);
            	transferMCfg.rx_data = Master_Buf;
            	transferMCfg.rx_length = sizeof(Master_Buf);
            	transferMCfg.retransmissions_max = 3;
            	I2C_MasterTransferData(I2CDEV_M, &transferMCfg, I2C_TRANSFER_POLLING);
            	*/
            	
            	Buffer_Init(1);
            
            	/* Start I2C slave device first */
            	transferMCfg.sl_addr7bit = I2CDEV_S_ADDR;
            	transferMCfg.tx_data = Master_Buf;
            	transferMCfg.tx_length = sizeof(Master_Buf);
            	transferMCfg.rx_data = NULL;
            	transferMCfg.rx_length = 0;
            	transferMCfg.retransmissions_max = 3;
            	I2C_MasterTransferData(I2CDEV_M, &transferMCfg, I2C_TRANSFER_POLLING);
            	
            	_delay();
            	
            	Buffer_Init(0);
            
            	/* Start I2C slave device first */
            	transferMCfg.sl_addr7bit = I2CDEV_S_ADDR;
            	transferMCfg.tx_data = NULL ;
            	transferMCfg.tx_length = 0;
            	transferMCfg.rx_data = Master_Buf;
            	transferMCfg.rx_length = sizeof(Master_Buf);
            	transferMCfg.retransmissions_max = 3;
            	I2C_MasterTransferData(I2CDEV_M, &transferMCfg, I2C_TRANSFER_POLLING);
            	
            	
            	lcd_init();
            	lcd_clear();
            	lcd_gotoxy(1,3);
            	lcd_putsf("I2C Example");
            
            	_delay();
            
            	lcd_gotoxy(2,1);
            	for(i=0;i<BUFFER_SIZE;i++){
            		//buf[i] = Master_Buf[i];
            		sprintf(buf,"Data= %d",Master_Buf[i]);
            		lcd_gotoxy(2,1);
            		lcd_putsf("        ");
            		lcd_gotoxy(2,1);
            		lcd_putsf(buf);
            		_delay();
            	}
            	I2C_DeInit(I2CDEV_M);
            
            	while(1);
            
            }

            دیدگاه


              #7
              پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

              باسلام
              من دقیقا متوجه مشکله شما نشدم،
              دوستان من این کتابخونه رو برای 24LCXX نوشتم ببینید کمکتون میکنه.
              من از این برای ذخیره کردن ضرایب تصحیح تاچ که هر کدومشون 8 بایت هستن استفاده کردم.
              با این توابع میتونید دادهای یک بایتی، دو بایتی، 4 بایتی و 8 بایتی (یک PAGE) رو داخل EEPROM ذخیره و بازیابی کنید.

              کد:
              //-----------------------------------------------------------------------------
              // Copyright:   __MRB__
              // Author:     CMSIS_I2C_lib modefied by Mojtaba Rostami 
              // Remarks:
              // Date: 					 2013/10/23
              // known Problems: none
              // Version:    1.0.0
              // Description:  EEPROM driver, 24LCXX 
              //-----------------------------------------------------------------------------
              
              #ifndef HT24LC_H_
              #define HT24LC_H_
              
              #include "lpc17xx_i2c.h"
              #include "lpc17xx_pinsel.h"
              
              /** Used I2C device definition */
              #define I2CDEV LPC_I2C0
              
              /* 7 bit address */
              #define HT24LC_SLVADDR		(0xA0>>1)
              /*I2C0 clockrate*/
              #define I2C_CLOCKRATE					200000
              
              void I2C0_Init (void);
              void I2C1_Init (void);
              
              /*Long Double function for these Data types(10 Bytes):
              long double
              */
              int8_t HT24LC_LDbWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              int8_t HT24LC_LDbRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              
              /*Page function for these Data types(8 Bytes):
              int64_t
              uint64_t
              double
              */
              int8_t HT24LC_PageWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              int8_t HT24LC_PageRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              
              /*Half page function for these Data types(4 Bytes):
              uint32_t
              int32_t
              float
              */
              int8_t HT24LC_HfPageWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              int8_t HT24LC_HfPageRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              
              /*Half Half page function for these Data types(2 Bytes):
              uint16_t
              int16_t
              */
              int8_t HT24LC_HHfPageWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              int8_t HT24LC_HHfPageRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              
              /*Byte function for these Data types(1 Bytes):
              char
              uint8_t
              int8_t
              */
              int8_t HT24LC_ByteWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              int8_t HT24LC_ByteRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t addr,void *data);
              #endif /* LPC17XX_I2C_H_ */
              کد:
              //-----------------------------------------------------------------------------
              // Copyright:   __MRB__
              // Author:     CMSIS_I2C_lib modefied by Mojtaba Rostami 
              // Remarks:
              // Date: 					 2013/10/23
              // known Problems: none
              // Version:    1.0.0
              // Description:  EEPROM driver, 24LCXX 
              //-----------------------------------------------------------------------------
              
              #include	"HT24LC.h"
              
              ////////////////I2C0 Initialization Function///////////////////////////////////////////////
              void I2C0_Init (void)
              {
              	PINSEL_CFG_Type PinCfg;
              	
              	//Init I2C pin connect
              	PinCfg.OpenDrain = PINSEL_PINMODE_OPENDRAIN;
              	PinCfg.Pinmode = PINSEL_PINMODE_PULLUP;
              	PinCfg.Funcnum = 1;
              	PinCfg.Pinnum = 27;
              	PinCfg.Portnum = 0;
              	PINSEL_ConfigPin(&PinCfg);
              	PinCfg.Pinnum = 28;
              	PINSEL_ConfigPin(&PinCfg);
              	// Initialize I2C0 clockrate
              	I2C_Init(LPC_I2C0, I2C_CLOCKRATE);
              	/* Enable I2C0 operation */
              	I2C_Cmd(LPC_I2C0, I2C_MASTER_MODE, ENABLE);
              }////////////////End I2C0 Initialization Function///////////////////////////////////////////////
              
              ////////////////I2C0 Initialization Function///////////////////////////////////////////////
              void I2C1_Init (void)
              {
              	PINSEL_CFG_Type PinCfg;
              	
              	//Init I2C pin connect
              	PinCfg.OpenDrain = PINSEL_PINMODE_OPENDRAIN;
              	PinCfg.Pinmode = PINSEL_PINMODE_PULLUP;
              	PinCfg.Funcnum = 2;
              	PinCfg.Pinnum = 10;
              	PinCfg.Portnum = 0;
              	PINSEL_ConfigPin(&PinCfg);
              	PinCfg.Pinnum = 11;
              	PINSEL_ConfigPin(&PinCfg);
              	// Initialize I2C1 clockrate
              	I2C_Init(LPC_I2C1, I2C_CLOCKRATE);
              	/* Enable I2C1 operation */
              	I2C_Cmd(LPC_I2C1, I2C_MASTER_MODE, ENABLE);
              }////////////////End I2C0 Initialization Function///////////////////////////////////////////////
              
              
              ////////////////EEPROM Long Double Write Function///////////////////////////////////////////////
              int8_t HT24LC_LDbWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Transmit setup */
              	I2C_M_SETUP_Type txsetup;
              	uint8_t wrdata[9+2],*dp,i,offset=8+2;
              	uint32_t tmp;
              	
              	wrdata[0]=offset+pgaddr*offset;
              	
              	dp=(uint8_t *)data;
              	for(i=0;i<8+2;i++)
              		wrdata[i+1]=dp[i];
              	
              	txsetup.sl_addr7bit = HT24LC_ADDR;
              	txsetup.tx_data = wrdata;
              	txsetup.tx_length = sizeof(wrdata);
              	txsetup.rx_data = NULL;
              	txsetup.rx_length = 0;
              	txsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &txsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		for (tmp = 0x100000; tmp; tmp--);
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Long Double Write Function///////////////////////////////////////////////
              
              ////////////////EEPROM Long Double Read Function///////////////////////////////////////////////
              int8_t HT24LC_LDbRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Receive setup */
              	I2C_M_SETUP_Type rxsetup;
              	uint8_t rddata[8+2],*dp,offset=8+2,addr;
              	
              	addr=offset+pgaddr*offset;
              	dp=(uint8_t *)data;
              	
              	rxsetup.sl_addr7bit = HT24LC_ADDR;
              	rxsetup.tx_data = &addr;// Get address to read at writing address
              	rxsetup.tx_length = 1;
              	rxsetup.rx_data = dp;
              	rxsetup.rx_length = sizeof(rddata);
              	rxsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &rxsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Long Double Read Function///////////////////////////////////////////////
              
              
              ////////////////EEPROM Page Write Function///////////////////////////////////////////////
              int8_t HT24LC_PageWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Transmit setup */
              	I2C_M_SETUP_Type txsetup;
              	uint8_t wrdata[9],*dp,i,offset=8;
              	uint32_t tmp;
              	
              	wrdata[0]=offset+pgaddr*offset;
              	
              	dp=(uint8_t *)data;
              	for(i=0;i<8;i++)
              		wrdata[i+1]=dp[i];
              	
              	txsetup.sl_addr7bit = HT24LC_ADDR;
              	txsetup.tx_data = wrdata;
              	txsetup.tx_length = sizeof(wrdata);
              	txsetup.rx_data = NULL;
              	txsetup.rx_length = 0;
              	txsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &txsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		for (tmp = 0x100000; tmp; tmp--);
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Page Write Function///////////////////////////////////////////////
              
              ////////////////EEPROM Page Read Function///////////////////////////////////////////////
              int8_t HT24LC_PageRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Receive setup */
              	I2C_M_SETUP_Type rxsetup;
              	uint8_t rddata[8],*dp,offset=8,addr;
              	
              	addr=offset+pgaddr*offset;
              	dp=(uint8_t *)data;
              	
              	rxsetup.sl_addr7bit = HT24LC_ADDR;
              	rxsetup.tx_data = &addr;// Get address to read at writing address
              	rxsetup.tx_length = 1;
              	rxsetup.rx_data = dp;
              	rxsetup.rx_length = sizeof(rddata);
              	rxsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &rxsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Page Read Function///////////////////////////////////////////////
              
              ////////////////EEPROM Half page Write Function///////////////////////////////////////////////
              int8_t HT24LC_HfPageWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Transmit setup */
              	I2C_M_SETUP_Type txsetup;
              	uint8_t wrdata[9-4],*dp,i,offset=8-4;
              	uint32_t tmp;
              	
              	wrdata[0]=offset+pgaddr*offset;
              	
              	dp=(uint8_t *)data;
              	for(i=0;i<8-4;i++)
              		wrdata[i+1]=dp[i];
              	
              	txsetup.sl_addr7bit = HT24LC_ADDR;
              	txsetup.tx_data = wrdata;
              	txsetup.tx_length = sizeof(wrdata);
              	txsetup.rx_data = NULL;
              	txsetup.rx_length = 0;
              	txsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &txsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		for (tmp = 0x100000; tmp; tmp--);
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Half page Write Function///////////////////////////////////////////////
              
              ////////////////EEPROM Half page Read Function///////////////////////////////////////////////
              int8_t HT24LC_HfPageRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Receive setup */
              	I2C_M_SETUP_Type rxsetup;
              	uint8_t rddata[8-4],*dp,offset=8-4,addr;
              	
              	addr=offset+pgaddr*offset;
              	dp=(uint8_t *)data;
              	
              	rxsetup.sl_addr7bit = HT24LC_ADDR;
              	rxsetup.tx_data = &addr;// Get address to read at writing address
              	rxsetup.tx_length = 1;
              	rxsetup.rx_data = dp;
              	rxsetup.rx_length = sizeof(rddata);
              	rxsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &rxsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Half page Read Function///////////////////////////////////////////////
              
              ////////////////EEPROM Half Half page Write Function///////////////////////////////////////////////
              int8_t HT24LC_HHfPageWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Transmit setup */
              	I2C_M_SETUP_Type txsetup;
              	uint8_t wrdata[9-6],*dp,i,offset=8-6;
              	uint32_t tmp;
              	
              	wrdata[0]=offset+pgaddr*offset;
              	
              	dp=(uint8_t *)data;
              	for(i=0;i<8-6;i++)
              		wrdata[i+1]=dp[i];
              	
              	txsetup.sl_addr7bit = HT24LC_ADDR;
              	txsetup.tx_data = wrdata;
              	txsetup.tx_length = sizeof(wrdata);
              	txsetup.rx_data = NULL;
              	txsetup.rx_length = 0;
              	txsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &txsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		for (tmp = 0x100000; tmp; tmp--);
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Half Half page Write Function///////////////////////////////////////////////
              
              ////////////////EEPROM Half Half page Read Function///////////////////////////////////////////////
              int8_t HT24LC_HHfPageRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Receive setup */
              	I2C_M_SETUP_Type rxsetup;
              	uint8_t rddata[8-6],*dp,offset=8-6,addr;
              	
              	addr=offset+pgaddr*offset;
              	dp=(uint8_t *)data;
              	
              	rxsetup.sl_addr7bit = HT24LC_ADDR;
              	rxsetup.tx_data = &addr;// Get address to read at writing address
              	rxsetup.tx_length = 1;
              	rxsetup.rx_data = dp;
              	rxsetup.rx_length = sizeof(rddata);
              	rxsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &rxsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Half Half page Read Function///////////////////////////////////////////////
              
              ////////////////EEPROM Byte Write Function///////////////////////////////////////////////
              int8_t HT24LC_ByteWr(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Transmit setup */
              	I2C_M_SETUP_Type txsetup;
              	uint8_t wrdata[9-7],*dp,i,offset=8-7;
              	uint32_t tmp;
              	
              	wrdata[0]=offset+pgaddr*offset;
              	
              	dp=(uint8_t *)data;
              	for(i=0;i<8-7;i++)
              		wrdata[i+1]=dp[i];
              	
              	txsetup.sl_addr7bit = HT24LC_ADDR;
              	txsetup.tx_data = wrdata;
              	txsetup.tx_length = sizeof(wrdata);
              	txsetup.rx_data = NULL;
              	txsetup.rx_length = 0;
              	txsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &txsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		for (tmp = 0x100000; tmp; tmp--);
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Byte Write Function///////////////////////////////////////////////
              
              ////////////////EEPROM Byte Read Function///////////////////////////////////////////////
              int8_t HT24LC_ByteRd(LPC_I2C_TypeDef *I2Cx,uint8_t HT24LC_ADDR,uint8_t pgaddr,void *data)
              {
              	/* Receive setup */
              	I2C_M_SETUP_Type rxsetup;
              	uint8_t rddata[8-7],*dp,offset=8-7,addr;
              	
              	addr=offset+pgaddr*offset;
              	dp=(uint8_t *)data;
              	
              	rxsetup.sl_addr7bit = HT24LC_ADDR;
              	rxsetup.tx_data = &addr;// Get address to read at writing address
              	rxsetup.tx_length = 1;
              	rxsetup.rx_data = dp;
              	rxsetup.rx_length = sizeof(rddata);
              	rxsetup.retransmissions_max = 3;
              
              	if (I2C_MasterTransferData(I2Cx, &rxsetup, I2C_TRANSFER_POLLING) == SUCCESS){
              		return (0);
              	} else {
              		return (-1);
              	}
              }////////////////End EEPROM Byte Read Function///////////////////////////////////////////////

              دیدگاه


                #8
                پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

                ممنون ازتون. فقط یه سوال داشتم. برنامه ای که بالا مال خودم بود خواندن از آدرس جاری بود. برنامه شما خواندن از آدرس فعلی رو پشتیبانی می کنه؟ من دقیقا با همین مشکل دارم.

                این آدرسا uint8_t HT24LC_ADDR,uint8_t pgaddr رو چجوری باید مقدار دهی کرد؟
                منظورم pgaddr چه بازه ای داره؟ یا همین طور ADDR ؟

                دیدگاه


                  #9
                  پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

                  یه سوال دیگه؟ برنامه نوشته رو تست کردک ولی فقط دو بایت میخونه؟ نمیدونم مشکلش از کجاست؟
                  البته من از توابع page_red & page_write استفاده کردم.
                  اینم برنامه:
                  کد:
                  I2C0_Init();
                  	Buffer_Init(1);
                  	for(i=0;i<BUFFER_SIZE;i++)
                  		HT24LC_HHfPageWr(I2CDEV_M,HT24LC_SLVADDR,i,Master_Buf);
                  	Buffer_Init(0);
                  	for(i=0;i<BUFFER_SIZE;i++)
                  		HT24LC_HHfPageRd(I2CDEV_M,HT24LC_SLVADDR,i,Master_Buf);
                  		
                  	lcd_init();
                  	lcd_clear();
                  	lcd_gotoxy(1,3);
                  	lcd_putsf("I2C Example");
                  
                  	_delay();
                  
                  	lcd_gotoxy(2,1);
                  	for(i=0;i<BUFFER_SIZE;i++){
                  		//buf[i] = Master_Buf[i];
                  		sprintf(buf,"Data= %d",Master_Buf[i]);
                  		lcd_gotoxy(2,1);
                  		lcd_putsf("        ");
                  		lcd_gotoxy(2,1);
                  		lcd_putsf(buf);
                  		_delay();
                  	}
                  	I2C_DeInit(I2CDEV_M);

                  دیدگاه


                    #10
                    پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

                    ممنون ازتون. فقط یه سوال داشتم. برنامه ای که بالا مال خودم بود خواندن از آدرس جاری بود. برنامه شما خواندن از آدرس فعلی رو پشتیبانی می کنه؟ من دقیقا با همین مشکل دارم.
                    منظورتون از آدرس فعلی رو متوجه نمیشم.
                    با این توابع میتونید تو هر جایی از eeprom بنویسید و از هر جایی از اون بخونید. در هر زمان و در هر مکان !!!
                    eeprom ای که شما ازش استفاده میکنید 2کیلو بایتی هست یعنی 256 تا بایت یعنی 128 تا word یعنی 64 تا دبل word یعنی 32 تا page یعنی 16 تا دبل page حالا با استفاده از این توابع میتونید به هر نوع داده ای که خواستید بنویسید و بخونید. البته تابع دبل page اش تکمیل نشده فرصت کردم اون رو اصلاح اش میکنم.

                    این آدرسا uint8_t HT24LC_ADDR,uint8_t pgaddr رو چجوری باید مقدار دهی کرد؟
                    منظورم pgaddr چه بازه ای داره؟ یا همین طور ADDR ؟
                    خوب برای استفاده از این توابع،
                    همونطور که متوجه شدید یک خروجی داره که اگه تابع به درستی اجرا بشه مقدار یک و در غیر این صورت مقدار 1- برو برمیگردونه.

                    هر تابع چهار ورودی داره،

                    ورودی اول : یا میتونه LPC_I2C0 باشه برای استفاده از I2C0
                    یا میتونه LPC_I2C1 باشه برای استفاده از I2C1

                    ورودی دوم : یه داده 7 بیتی هست که بیانگر آدرس اسلیو هست . که همونطور که میدونید برای 24LCXX مقدار چهار بیت اول 1010 و سه بیت آخر هم توسط پایه های A0 , A1, A2 تعیین میشه.

                    ورودی سوم : آدرس جایی هست که میخواییم توش بنویسیم یا از اون بخونیم. توجه کنید که این آدرس برای هر تابع یعنی آدرسی از همون جنس هست و رنجش باتوجه به EEPROM مورذ بحث برای هر تابع به صورت زیر هست:
                    برای تابع یک بایت : 0 تا 255
                    برای تابع دو بایت : 0 تا 127
                    برای تابع 4 بایت : 0 تا 63
                    برای تابع 8 بایت : 0 تا 32
                    برای تابع 16 بایت : 0 تا 15

                    ورودی چهارم: آدرس داده ای هست که میخواییم مقادیرش رو بنویسیم داخل EEPROM یا مقادیری از EEPROM بخونیم داخل اون سیو کنیم.

                    این هم یه مثال کامل از نحوه استفاده از این توابع :

                    کد:
                    #include "lpc17xx_i2c.h"
                    #include "lpc17xx_pinsel.h"
                    #include "lpc17xx_gpio.h"
                    #include "HT24LC.h"
                    #include "delay.h"
                    
                    /************************** PRIVATE DEFINITIONS *************************/
                    
                    
                    
                    typedef struct Matrix 
                    {						
                    double An, 
                          Bn,   
                          Cn,  
                          Dn,  
                          En,  
                          Fn,   
                          Divider ;
                    } Matrix;
                    Matrix matrix1={34,12.23,.11,9.11,.0001,-.000231,-2.00001};
                    Matrix matrix2;
                    uint8_t *sp;
                    
                    uint8_t temp2[8],temp1[8]={22,10,3,5};
                    float	temp4,temp3=-56.879,*sp2;
                    int16_t temp6,temp5=-8934;
                    int8_t temp8,temp7=0x44;
                    char str1='a',str2;
                    int main(void){
                    			
                    	//my settings:
                    	GPIO_SetDir(2, (255<<0), 1);
                    	delay_init();
                    	//end my settings
                    	I2C0_Init ();
                    	/*
                    	HT24LC_PageWr(I2CDEV,HT24LC_SLVADDR,0,&matrix1.An);
                    	HT24LC_PageWr(I2CDEV,HT24LC_SLVADDR,1,&matrix1.Bn);
                    	HT24LC_PageWr(I2CDEV,HT24LC_SLVADDR,2,&matrix1.Cn);
                    	HT24LC_PageWr(I2CDEV,HT24LC_SLVADDR,3,&matrix1.Dn);
                    	HT24LC_PageWr(I2CDEV,HT24LC_SLVADDR,4,&matrix1.En);
                    	HT24LC_PageWr(I2CDEV,HT24LC_SLVADDR,5,&matrix1.Fn);
                    	HT24LC_PageWr(I2CDEV,HT24LC_SLVADDR,6,&matrix1.Divider);
                    	*/
                    	/*
                    	HT24LC_PageRd(I2CDEV,HT24LC_SLVADDR,0,&matrix2.An);
                    	HT24LC_PageRd(I2CDEV,HT24LC_SLVADDR,1,&matrix2.Bn);
                    	HT24LC_PageRd(I2CDEV,HT24LC_SLVADDR,2,&matrix2.Cn);
                    	HT24LC_PageRd(I2CDEV,HT24LC_SLVADDR,3,&matrix2.Dn);
                    	HT24LC_PageRd(I2CDEV,HT24LC_SLVADDR,4,&matrix2.En);
                    	HT24LC_PageRd(I2CDEV,HT24LC_SLVADDR,5,&matrix2.Fn);
                    	HT24LC_PageRd(I2CDEV,HT24LC_SLVADDR,6,&matrix2.Divider);
                    	*/
                    	
                    	/*
                    	HT24LC_HfPageWr(I2CDEV,HT24LC_SLVADDR,0,&temp3);
                    	HT24LC_HfPageRd(I2CDEV,HT24LC_SLVADDR,0,&temp4);
                    	*/
                    	
                    	//sp=(uint8_t *)&matrix2.An;
                    	//if(matrix2.An==matrix1.An)
                    	
                    	//sp=(uint8_t *)&temp4;
                    	//if(temp4==temp3)
                    	/*
                    	HT24LC_HHfPageWr(I2CDEV,HT24LC_SLVADDR,0,&temp5);
                    	HT24LC_HHfPageRd(I2CDEV,HT24LC_SLVADDR,0,&temp6);
                    	*/
                    	//sp=(uint8_t *)&temp6;
                    	//if(temp6==temp5)
                    	
                    	//HT24LC_ByteWr(I2CDEV,HT24LC_SLVADDR,255,&temp7);
                    	HT24LC_ByteRd(I2CDEV,HT24LC_SLVADDR,100,&temp8);
                    	sp=(uint8_t *)&temp8;
                    	//if(temp8==temp7)	
                    	
                    	//HT24LC_ByteWr(I2CDEV,HT24LC_SLVADDR,255,&str1);
                    	//HT24LC_ByteRd(I2CDEV,HT24LC_SLVADDR,255,&str2);
                    	//sp=(uint8_t *)&str2;
                    	//if(str2==str1)	
                    		
                    	FIO_ByteSetValue(2, 0,sp[0]);
                    }/////////////////////////////////////End main///////////////////////////////////////////

                    دیدگاه


                      #11
                      پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

                      ممنون از شما، ولی برا تابع 8 بایت باید 0 تا 32 باشه همانطور که گفتین، ولی وقتی از 0 تا 16 رو میریزم تو eeprom، فقط 8 بایت یعنی 0 تا 7 رو میخونه. نمیدونم چرا جواب نمیده؟ :angry:

                      دیدگاه


                        #12
                        پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

                        راستش من بازم متوجه نمیشم، اما اونچیزی که برداشت کردم اینه که میخوایید 32 تا بایت رو ذخیره کنید و بعد بخونید.
                        خوب برای این کار میتونید 4 بار از تابع PAGE استفاده کنید یا 32 بار تابع تک بایتی یا 16 بار تابع دو بایتی.
                        طبق گفته خودتون از تابع PAGE استفاده کردید اما اونچیزی که تو پست قبلی گزاشتید تابع دو بایت هست!

                        دیدگاه


                          #13
                          پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

                          اول ممنون از شما. ولی درسته حق با شما بود. مشکل از آرگومان ورودی داده تابع بود که وقتی از آرایه استفاده میکردم فقط یه page یا هشت بایت مینوشت. نمیدونم چرا؟

                          حالا یه سوال دیگه. الان با تابع Byte_Wr فقط میشه 256 بایت نوشت. حالا اگه eeprom داشته باشیم که از 0 تا 0x7FFF آدرس حافظه اش باشه مثلا 1024 بایت، اون موقع چجوری باید آدرس دهی اش کرد؟

                          دیدگاه


                            #14
                            پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

                            در این صورت باید دو بایت (کامند) آدرس ارسال کنید. و برای اینکار یکسری تغییرات باید در توابع ایجاد کنید.

                            دیدگاه


                              #15
                              پاسخ : مشکل با شبکه بندی EEPROM - 24C02 روی یک باس مشترک

                              ممنون، میشه بگید چه تغییراتی؟ :redface: :rolleyes:

                              دیدگاه

                              لطفا صبر کنید...
                              X