bool ICACHE_FLASH_ATTR write(uint8_t addr, uint8_t *buf, uint8_t length) { i2c_master_start(); i2c_master_writeByte(PCA9685_ADDR | I2C_WRITE); if (i2c_master_getAck()) { // os_printf("addr not ack when tx write cmd \n"); i2c_master_stop(); return false; } i2c_master_writeByte(addr); if (i2c_master_getAck()) { // os_printf("data not ack when tx write byte1 \n"); i2c_master_stop(); return false; } uint8_t i; for(i=0; i<length; i++) { i2c_master_writeByte(buf[i]); if (i2c_master_getAck()) { // os_printf("data not ack when tx write byte %d\n", i); i2c_master_stop(); return false; } } i2c_master_stop(); return true; }
bool rv3029_write(uint8_t regaddr, uint8_t bytes, uint8_t *val) { i2c_master_start(); // Write I²C Address for writing register i2c_master_writeByte(RV3029_ADDR_W); if (i2c_master_getAck()) { os_printf("RV3029: no ACK for write addr\r\n"); i2c_master_stop(); return false; } // Write register address i2c_master_writeByte(regaddr); if(i2c_master_getAck()) { os_printf("RV3029: no ACK for register\r\n"); i2c_master_stop(); return false; } uint8_t i; for (i = 0; i < bytes; ++i) { i2c_master_writeByte(val[i]); if(i2c_master_getAck()) { os_printf("RV3029: no ACK for datawrite\r\n"); i2c_master_stop(); return false; } } i2c_master_stop(); return true; }
static bool ICACHE_FLASH_ATTR singleByteWrite(uint8_t adr, uint8_t reg, uint8_t data){ i2c_master_start(); i2c_master_writeByte((uint8_t)(adr << 1)); if (!i2c_master_checkAck()) { i2c_master_stop(); return false; } i2c_master_writeByte(reg); if (!i2c_master_checkAck()) { i2c_master_stop(); return false; } i2c_master_writeByte(data); if (!i2c_master_checkAck()) { i2c_master_stop(); return false; } i2c_master_stop(); return true; }
// set the current data address, this is the start of the write command // next either send the data to be written, or start a read instead // returns true to indicate success static bool ICACHE_FLASH_ATTR at24c_setAddr(uint16 addr) { uint8 loop; uint8 data[2]; // signal i2c start i2c_master_start(); // write i2c address & direction i2c_master_writeByte((uint8)(AT24C_ADDR << 1)); if (!i2c_master_checkAck()) { //uart0_send("i2c error\r\n"); i2c_master_stop(); return false; } // write data address data[0] = (uint8)(((unsigned)addr) >> 8); data[1] = (uint8)(((unsigned)addr) & 0xff); for (loop = 0; loop < 2; loop++) { i2c_master_writeByte(data[loop]); if (!i2c_master_checkAck()) { //uart0_send("i2c error\r\n"); i2c_master_stop(); return false; } } return true; }
LOCAL void ICACHE_FLASH_ATTR read_cb(void) { uint8_t ack, low, high; wdt_feed(); os_printf("Time=%ld\n", system_get_time()); i2c_master_start(); i2c_master_writeByte(BH1750_ADDR); ack = i2c_master_getAck(); if (ack) { os_printf("I2C:No ack after sending address\n"); i2c_master_stop(); return; } i2c_master_stop(); i2c_master_wait(40000); // why? i2c_master_start(); i2c_master_writeByte(BH1750_ADDR + 1); ack = i2c_master_getAck(); if (ack) { os_printf("I2C:No ack after write command\n"); i2c_master_stop(); return; } low = i2c_master_readByte(); high = i2c_master_readByte(); i2c_master_setAck(1); i2c_master_stop(); os_printf("I2C:read(L/H)=(0x%02x/0x%02x)\n", low, high); }
LOCAL i2c_status ICACHE_FLASH_ATTR io2_set_execute(uint8 address, uint8 command, uint8 data) { i2c_master_start(); /* Send address */ i2c_master_writeByte(address << 1 | 0); if (i2c_master_getAck()) { i2c_master_stop(); return I2C_ADDRESS_NACK; } /* Send command */ i2c_master_writeByte(command); if (i2c_master_getAck()) { goto error; } /* Send data */ i2c_master_writeByte(data); if (i2c_master_getAck()) { goto error; } i2c_master_stop(); return I2C_OK; error: i2c_master_stop(); return I2C_DATA_NACK; }
bool i2c_master_writeBytes(uint8 address, uint8 *values, uint8 length) { i2c_master_start(); i2c_master_writeByte(address); if (!i2c_master_checkAck()) { i2c_master_stop(); #ifdef CONFIG_I2C_MASTER_DEBUG console_printf( "Device not ACKed on address\n" ); #endif return false; } for(uint8 i = 0; i < length; i++){ i2c_master_writeByte(values[i]); if (!i2c_master_checkAck()) { #ifdef CONFIG_I2C_MASTER_DEBUG console_printf( "Device not ACKed on write\n" ); #endif i2c_master_stop(); return false; } } i2c_master_stop(); return true; }
// send a number of bytes to the rtc over i2c // returns true to indicate success static bool ICACHE_FLASH_ATTR ds1307_send(uint8 *data, uint8 len) { int loop; // signal i2c start i2c_master_start(); // write address & direction i2c_master_writeByte((uint8)(DS1307_ADDR << 1)); if (!i2c_master_checkAck()) { //uart0_send("i2c error1\r\n"); i2c_master_stop(); return false; } // send the data for (loop = 0; loop < len; loop++) { i2c_master_writeByte(data[loop]); if (!i2c_master_checkAck()) { //uart0_send("i2c error2\r\n"); i2c_master_stop(); return false; } } // signal i2c stop i2c_master_stop(); return true; }
i2c_status ICACHE_FLASH_ATTR rgb_set(i2c_config *config) { rgb_config_data *config_data = (rgb_config_data *)config->data; i2c_master_start(); /* Send address */ i2c_master_writeByte(config->address << 1 | 0); if (i2c_master_getAck()) { i2c_master_stop(); return I2C_ADDRESS_NACK; } /* Send command */ i2c_master_writeByte(0x03); if (i2c_master_getAck()) goto error; i2c_master_writeByte(config_data->red); if (i2c_master_getAck()) goto error; i2c_master_writeByte(config_data->green); if (i2c_master_getAck()) goto error; i2c_master_writeByte(config_data->blue); if (i2c_master_getAck()) goto error; i2c_master_stop(); return I2C_OK; error: i2c_master_stop(); return I2C_DATA_NACK; }
/************ low level data pushing commands **********/ void LCD_expanderWrite(uint8 _data){ i2c_master_start(); i2c_master_writeByte(LCD_ADDRESS << 1); if (!i2c_master_checkAck()) { i2c_master_stop(); return; } //i2c_master_writeByte((uint8)(_data) | _backlightval); i2c_master_writeByte((uint8)(_data) | LCD_BACKLIGHT); i2c_master_checkAck(); i2c_master_stop(); }
void LSM303_write_byte(char device, char addr,char byte) { i2c_master_start(); i2c_master_writeByte(device | WRITE); i2c_master_readNAck(); i2c_master_writeByte(addr); i2c_master_readNAck(); i2c_master_writeByte(byte); i2c_master_readNAck(); i2c_master_stop(); }
i2c_status ICACHE_FLASH_ATTR tc_read(i2c_config *config) { tc_config_data *config_data = (tc_config_data *)config->data; i2c_master_start(); /* Send address */ i2c_master_writeByte(config->address << 1 | 0); if (i2c_master_getAck()) { i2c_master_stop(); return I2C_ADDRESS_NACK; } /* Send command */ i2c_master_writeByte(0x21); if (i2c_master_getAck()) { i2c_master_stop(); return I2C_DATA_NACK; } i2c_master_stop(); i2c_master_start(); i2c_master_writeByte(config->address << 1 | 1); if (i2c_master_getAck()) { i2c_master_stop(); return I2C_ADDRESS_NACK; } uint8 i; uint8 data[4]; for (i=0; i < 4; i++) { data[i] = i2c_master_readByte(); i2c_master_setAck(i == 3); } i2c_master_stop(); if ((data[2] & 0x01) != 0) { return I2C_COMMUNICATION_FAILED; } sint16 d = data[3] * 256 + (data[2] & 0xFC); float tf = 0.0625 * d; int ti = tf; uint16 td = (tf - ti) * 100; config_data->temperature = d / 4; os_sprintf(config_data->temperature_str, "%d.%02d", ti, td); return I2C_OK; }
// wait for a write operation to complete // by 'acknowledge polling' void ICACHE_FLASH_ATTR at24c_writeWait() { do { i2c_master_start(); i2c_master_writeByte((uint8)((AT24C_ADDR << 1) | 1)); } while (!i2c_master_checkAck()); i2c_master_stop(); }
// write within a page // note if you try to write past a page boundary the write will // wrap back to the start of the same page, so you need to know // how much you're writing and where you're writing it to // you don't need to start writing at the start of a page, but if you // start in the middle you'll be able to write less before wrapping // optionally wait for the eeprom to complete the write // returns true to indicate success bool ICACHE_FLASH_ATTR at24c_writeInPage(uint16 addr, uint8* data, uint8 len, bool wait) { int loop; // set data address (includes i2c setup, // so no need to call i2c_master_start here) if (!at24c_setAddr(addr)) return false; // send the data for (loop = 0; loop < len; loop++) { i2c_master_writeByte(data[loop]); if (!i2c_master_checkAck()) { //uart0_send("i2c error\r\n"); i2c_master_stop(); return false; } } // signal i2c stop i2c_master_stop(); // optionally, wait until the eeprom signals the write is finished if (wait) at24c_writeWait(); return true; }
// read a number of bytes from the rtc over i2c // returns true to indicate success static bool ICACHE_FLASH_ATTR ds1307_recv(uint8 *data, uint8 len) { int loop; // signal i2c start i2c_master_start(); // write address & direction i2c_master_writeByte((uint8)((DS1307_ADDR << 1) | 1)); if (!i2c_master_checkAck()) { //uart0_send("i2c error3\r\n"); i2c_master_stop(); return false; } // read bytes for (loop = 0; loop < len; loop++) { data[loop] = i2c_master_readByte(); // send ack (except after last byte, then we send nack) if (loop < (len - 1)) i2c_master_send_ack(); else i2c_master_send_nack(); } // signal i2c stop i2c_master_stop(); return true; }
static bool ICACHE_FLASH_ATTR commandOnlyWrite(uint8_t adr, uint8_t reg){ i2c_master_start(); i2c_master_writeByte((uint8_t)(adr << 1)); if (!i2c_master_checkAck()) { i2c_master_stop(); return false; } i2c_master_writeByte(reg); if (!i2c_master_checkAck()) { i2c_master_stop(); return false; } i2c_master_stop(); return true; }
LOCAL i2c_status ICACHE_FLASH_ATTR io2_acp_execute(uint8 address, uint8 command, uint16 *data) { uint8 d[2]; i2c_master_start(); /* Send address */ i2c_master_writeByte(address << 1 | 0); if (i2c_master_getAck()) { i2c_master_stop(); return I2C_ADDRESS_NACK; } /* Send command */ i2c_master_writeByte(command); if (i2c_master_getAck()) { goto error; } i2c_master_stop(); i2c_master_start(); /* Send address */ i2c_master_writeByte(address << 1 | 1); if (i2c_master_getAck()) { i2c_master_stop(); return I2C_ADDRESS_NACK; } /* Read data */ d[0] = i2c_master_readByte(); i2c_master_send_ack(); d[1] = i2c_master_readByte(); i2c_master_send_nack(); i2c_master_stop(); *data = 256 * d[1] + d[0]; return I2C_OK; error: i2c_master_stop(); return I2C_DATA_NACK; }
LOCAL i2c_status ICACHE_FLASH_ATTR rgb_on(uint8 address) { i2c_master_start(); /* Send address */ i2c_master_writeByte(address << 1 | 0); if (i2c_master_getAck()) { i2c_master_stop(); return I2C_ADDRESS_NACK; } /* Send command */ i2c_master_writeByte(0x01); if (i2c_master_getAck()) { i2c_master_stop(); return I2C_DATA_NACK; } i2c_master_stop(); return I2C_OK; }
int platform_i2c_send_address( unsigned id, uint16_t address, int direction ){ // Convert enum codes to R/w bit value. // If TX == 0 and RX == 1, this test will be removed by the compiler if ( ! ( PLATFORM_I2C_DIRECTION_TRANSMITTER == 0 && PLATFORM_I2C_DIRECTION_RECEIVER == 1 ) ) { direction = ( direction == PLATFORM_I2C_DIRECTION_TRANSMITTER ) ? 0 : 1; } i2c_master_writeByte( (uint8_t) ((address << 1) | direction )); // Low-level returns nack (0=acked); we return ack (1=acked). return ! i2c_master_getAck(); }
/****************************************************************************** * FunctionName : user_mvh3004_burst_read * Description : burst read mvh3004's internal data * Parameters : uint8 addr - mvh3004's address * uint8 *pData - data point to put read data * uint16 len - read length * Returns : bool - true or false *******************************************************************************/ LOCAL bool ICACHE_FLASH_ATTR user_mvh3004_burst_read(uint8 addr, uint8 *pData, uint16 len) { uint8 ack; uint16 i; i2c_master_start(); i2c_master_writeByte(addr); ack = i2c_master_getAck(); if (ack) { os_printf("addr not ack when tx write cmd \n"); i2c_master_stop(); return false; } i2c_master_stop(); i2c_master_wait(40000); i2c_master_start(); i2c_master_writeByte(addr + 1); ack = i2c_master_getAck(); if (ack) { os_printf("addr not ack when tx write cmd \n"); i2c_master_stop(); return false; } for (i = 0; i < len; i++) { pData[i] = i2c_master_readByte(); i2c_master_setAck((i == (len - 1)) ? 1 : 0); } i2c_master_stop(); return true; }
bool ICACHE_FLASH_ATTR read(uint8_t addr, uint8_t *buf, uint8_t length) { i2c_master_start(); i2c_master_writeByte(PCA9685_ADDR | I2C_WRITE); if (i2c_master_getAck()) { // os_printf("addr not ack when tx write cmd \n"); i2c_master_stop(); return false; } i2c_master_writeByte(addr); if (i2c_master_getAck()) { // os_printf("data not ack when tx write byte1 \n"); i2c_master_stop(); return false; } i2c_master_start(); i2c_master_writeByte(PCA9685_ADDR | I2C_READ); if (i2c_master_getAck()) { // os_printf("addr not ack when tx read cmd \n"); i2c_master_stop(); return false; } uint8_t i = 0; for(i=0; i<length; i++) { buf[i] = i2c_master_readByte(); i2c_master_setAck(0);//(i == (length - 1)) ? 1 : 0); } i2c_master_stop(); return true; }
void LSM303_read_bytes(char device, char addr, char bytes[], char count) { i2c_master_start(); i2c_master_writeByte(device | WRITE); i2c_master_readNAck(); i2c_master_writeByte(addr); i2c_master_readNAck(); i2c_master_start(); i2c_master_writeByte(device | READ); i2c_master_readNAck(); int i; for (i = 0; i < count-1; ++i) { bytes[i] = i2c_master_readByte(); i2c_master_writeAck(); } bytes[count-1] = i2c_master_readByte(); i2c_master_writeNack(); i2c_master_stop(); }
static bool ICACHE_FLASH_ATTR byteRead(uint8_t adr, uint8_t reg, uint8_t data[], uint8_t length){ uint8_t i; i2c_master_start(); i2c_master_writeByte((uint8_t)(adr << 1)); if (!i2c_master_checkAck()) { i2c_master_stop(); return false; } i2c_master_writeByte(reg); if (!i2c_master_checkAck()) { i2c_master_stop(); return false; } i2c_master_start(); i2c_master_writeByte((uint8_t)((adr << 1) | 1)); if (!i2c_master_checkAck()) { i2c_master_stop(); return false; } for(i = 0; i < length-1; i++){ data[i] = i2c_master_readByte(); i2c_master_send_ack(); } data[i] = i2c_master_readByte(); i2c_master_send_nack(); i2c_master_stop(); return true; }
bool i2c_master_readBytes(uint8 address, uint8 *values, uint8 length) { if(values[0] > 0){ if(!i2c_master_writeBytes(address, values, 1)){ return false; } } uint8 timeout = 100; do{ i2c_master_start(); i2c_master_writeByte(address+1); if(!i2c_master_checkAck()){ i2c_master_stop(); i2c_master_wait(1000); continue; } break; }while(--timeout>0); if(timeout == 0){ return false; } #ifdef CONFIG_I2C_MASTER_DEBUG console_printf("Read: "); #endif uint8 readed = 0; while((readed < length) && (--timeout>0)){ uint8 byte = i2c_master_readByte(); values[readed++] = byte; i2c_master_setAck((readed == length)); // send the ACK or NAK as applicable i2c_master_setDC(1, 0); // release SDA #ifdef CONFIG_I2C_MASTER_DEBUG console_printf("%d ", byte); #endif } #ifdef CONFIG_I2C_MASTER_DEBUG console_printf("\n"); #endif i2c_master_stop(); return true; }
/* Wrote a simple I2C bus scanner to find connected i2C devices */ void i2c_bus_scan() { int index = 0; uint8_t result; os_printf("Scanning I2C bus for devices\r\n"); for (index=1; index <=127; index ++) { i2c_master_start(); // Start I2C request i2c_master_writeByte(index<<1| 0b00000001); //DS1307 address + W result = i2c_master_checkAck(); if (result) { os_printf("\tI2C device present at 0x%x\r\n", index); } i2c_master_stop(); } }
bool ICACHE_FLASH_ATTR mcp3221_read(uint8 addr, uint16 *pData) { uint8 ack; i2c_master_start(); i2c_master_writeByte(addr); // reading ack, should be 0 ack = i2c_master_getAck(); if (ack != 0) { DEBUG("addr not ack when tx write cmd, line %d\n", __LINE__); i2c_master_stop(); return false; } // reading high byte, first 4 bit should be zero uint8 temp = i2c_master_readByte(); if ((temp | 0x0f) != 0x0f) { DEBUG("wrong reading\n"); return false; } *pData = temp*256; // return ack 0 for high byte i2c_master_setAck(0); // reading low byte temp = i2c_master_readByte(); *pData += temp; // return ack 1 for lower byte i2c_master_setAck(1); // stop, we dont need continuous reading i2c_master_stop(); return true; }
int platform_i2c_send_byte( unsigned id, uint8_t data ){ i2c_master_writeByte(data); // Low-level returns nack (0=acked); we return ack (1=acked). return ! i2c_master_getAck(); }
uint8 LCD_init(){ i2c_master_start(); i2c_master_writeByte(LCD_ADDRESS << 1); if (!i2c_master_checkAck()) { i2c_master_stop(); return 0; } i2c_master_stop(); _displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS; if (LCD_ROW > 1) { _displayfunction |= LCD_2LINE; } _numlines = LCD_ROW; // for some 1 line displays you can select a 10 pixel high font if ((LCD_DOTSIZE != 0) && (LCD_ROW == 1)) { _displayfunction |= LCD_5x10DOTS; } // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION! // according to datasheet, we need at least 40ms after power rises above 2.7V // before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50 os_delay_us(50000); // Now we pull both RS and R/W low to begin commands LCD_expanderWrite(0); // reset expanderand turn backlight off os_delay_us(1000000); //put the LCD into 4 bit mode // this is according to the hitachi HD44780 datasheet // figure 24, pg 46 // we start in 8bit mode, try to set 4 bit mode LCD_write4bits(0x30); os_delay_us(4500); // wait min 4.1ms // second try LCD_write4bits(0x30); os_delay_us(4500); // wait min 4.1ms // third go! LCD_write4bits(0x30); os_delay_us(150); // finally, set to 4-bit interface LCD_write4bits(0x20); // set # lines, font size, etc. LCD_command(LCD_FUNCTIONSET | _displayfunction); // turn the display on with no cursor or blinking default _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF; LCD_display(); // clear it off LCD_clear(); // Initialize to default text direction (for roman languages) _displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT; // set the entry mode LCD_command(LCD_ENTRYMODESET | _displaymode); LCD_home(); return 1; }
LOCAL i2c_status ICACHE_FLASH_ATTR robko_set(uint8 address, uint8 reg, uint8 *data, uint8 len) { uint8 retry = 0; i2c_status status; do { #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("ROBKO: 0x%02X 0x%02X set %d bytes...\n", address, reg, len); #endif #endif status = I2C_OK; i2c_master_start(); /* Send address for write */ i2c_master_writeByte(address << 1 | 0); if (i2c_master_getAck()) { #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("ROBKO: Address ACK failed [0x%02X] [set SET command] \n", address); #endif #endif status = I2C_ADDRESS_NACK; goto done; } /* Send register */ i2c_master_writeByte(reg); if (i2c_master_getAck()) { #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("ROBKO: Register ACK failed [0x%02X] [set SET command] \n", reg); #endif #endif status = I2C_DATA_NACK; goto done; } /* Write data */ uint8 i = 0; while (i < len) { i2c_master_writeByte(data[i]); if (i2c_master_getAck()) { #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("ROBKO: Data ACK failed [execute SET command] \n"); #endif #endif status = I2C_DATA_NACK; break; } #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("0x%02X ", data[i]); #endif #endif i++; } done: i2c_master_stop(); retry++; } while ( retry < ROBKO_I2C_RETRY && status != I2C_OK ); #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("\nROBKO: Done.\n\n"); #endif #endif return status; }
LOCAL i2c_status ICACHE_FLASH_ATTR robko_read(uint8 address, uint8 reg, uint8 *data, uint8 len) { uint8 retry = 0; i2c_status status; do { #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("ROBKO: 0x%02X 0x%02X reading %d bytes...\n", address, reg, len); #endif #endif status = I2C_OK; i2c_master_start(); /* Send address for write */ i2c_master_writeByte(address << 1 | 0); if (i2c_master_getAck()) { #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("ROBKO: Address ACK failed [0x%02X] [set READ command] \n", address); #endif #endif status = I2C_ADDRESS_NACK; goto done; } /* Send register */ i2c_master_writeByte(reg); if (i2c_master_getAck()) { #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("ROBKO: Register ACK failed [0x%02X] [set READ command] \n", reg); #endif #endif status = I2C_DATA_NACK; goto done; } i2c_master_stop(); i2c_master_start(); /* Send address for read */ i2c_master_writeByte(address << 1 | 1); if (i2c_master_getAck()) { #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("ROBKO: Address ACK failed [0x%02X] [execute READ command] \n", address); #endif #endif status = I2C_ADDRESS_NACK; goto done; } #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("READ: "); #endif #endif /* Read data */ uint8 i = 0; while (true) { data[i] = i2c_master_readByte(); #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("0x%02X ", data[i]); #endif #endif i++; if (i < len) { i2c_master_send_ack(); } else { i2c_master_send_nack(); break; } } done: i2c_master_stop(); retry++; } while ( retry < ROBKO_I2C_RETRY && status != I2C_OK ); #if ROBKO_DEBUG #if ROBKO_VERBOSE_OUTPUT debug("\nROBKO: Done.\n\n"); #endif #endif return status; }