отвечаю...использованые в проекте драйвера полный ацтой.не могет и упирается где-то на
да, протупил, так я не искал.
Драйвера USB-COM на компе и т.д.. При другой usb-булке можно заметно поднять скорость.отвечаю...использованые в проекте драйвера полный ацтой.
Это хорошо.и таки да, сюрприз, сюрприз, в нормальных драйверах у I2C есть колбэки по прирыванию, более того есть Polling, DMA and Interrupts весь нитернет примерами забит...
Если i2c по прерываниям, то:Время оцифровки (через которое требуется считывание) INA219 - 84 us
Время оцифровки INA226 - 140 us
не надо так драйвера писать... ардуинщики засмеют...В прерываниях это от 8 прерываний на чтение
читали?
Что мы можем почерпнуть из указанных доков?более того есть Polling, DMA and Interrupts весь нитернет примерами забит...
Меньше с контроллером I2C, HAL от ST не получается если работать с ним по прерываниям. Такие убогие встроенные контроллеры во все STM.не надо так драйвера писать... ардуинщики засмеют...
int I2CBusWriteWord(unsigned char i2c_addr, unsigned char reg_addr, unsigned short reg_data)
{
int ret = 0;
// u8 r = irq_disable();
while(1) {
//Start By Master, write Slave Address & Register Pointer
reg_i2c_id = i2c_addr;
reg_i2c_adr = reg_addr; //
//write data MSByte
reg_i2c_do = (unsigned char)(reg_data >> 8);
//write data LSByte
reg_i2c_di = (unsigned char)(reg_data);
reg_i2c_ctrl = FLD_I2C_CMD_START | FLD_I2C_CMD_ID | FLD_I2C_CMD_ADR | FLD_I2C_CMD_DO | FLD_I2C_CMD_DI | FLD_I2C_CMD_STOP; // 0x3f
while(reg_i2c_status & FLD_I2C_CMD_BUSY );
if (reg_i2c_status & FLD_I2C_NAK) break;
ret = 1;
break;
}
// irq_restore(r);
return ret;
}
_attribute_ram_code_ int I2CBusReadWord(unsigned char i2c_addr, unsigned char reg_addr, void *preg_data)
{
int ret = 0;
unsigned char * p = (unsigned char *) preg_data;
// u8 r = irq_disable();
while(1) {
//Start By Master Write, write Slave Address & Register Pointer
reg_i2c_id = i2c_addr;
reg_i2c_adr = reg_addr; //address
reg_i2c_ctrl = FLD_I2C_CMD_START | FLD_I2C_CMD_ID | FLD_I2C_CMD_ADR | FLD_I2C_CMD_STOP; // 0x33
while(reg_i2c_status & FLD_I2C_CMD_BUSY );
if (reg_i2c_status & FLD_I2C_NAK) break;
// Start By Master Read, Write Slave Address, Read data MSByte
reg_i2c_id |= FLD_I2C_WRITE_READ_BIT; //SlaveID & 0xfe,.i.e write data. Read:High Write:Low
reg_i2c_ctrl = FLD_I2C_CMD_START | FLD_I2C_CMD_ID | FLD_I2C_CMD_READ_ID | FLD_I2C_CMD_DI; // 0x59
while(reg_i2c_status & FLD_I2C_CMD_BUSY );
p[1] = reg_i2c_di;
// Read data LSByte, Stop By Master
reg_i2c_ctrl = FLD_I2C_CMD_READ_ID | FLD_I2C_CMD_DI | FLD_I2C_CMD_NAK | FLD_I2C_CMD_STOP; // 0xE8
while(reg_i2c_status & FLD_I2C_CMD_BUSY );
p[0] = reg_i2c_di;
ret = 1;
break;
}
// irq_restore(r);
return ret;
}
void I2CBusDeInit(void) {
#if (MCU_CORE_TYPE == MCU_CORE_8266)
BM_CLR(reg_gpio_ie(GPIO_PF1), GPIO_PF1 & 0xff); // disable input
BM_SET(reg_gpio_config_func(GPIO_PE7), GPIO_PE7 & 0xff);
BM_CLR(reg_gpio_ie(GPIO_PE7), GPIO_PE7 & 0xff); // disable input
BM_SET(reg_gpio_oen(GPIO_PE7), GPIO_PE7 & 0xff); // disable output
analog_write(0x14, (analog_read(0x14) & (~((3 << 2) | (3 <<6))))
| (GPIO_PULL_UP_1M << 2) // PE7
| (GPIO_PULL_UP_1M << 6) // PF1
);
#endif
BM_CLR(reg_rst_clk0, FLD_CLK_I2C_EN);
}
void I2CBusInit(unsigned int clk_hz) {
// int ret = 0;
#if (MCU_CORE_TYPE == MCU_CORE_8266)
u32 gpio_sda = GPIO_PE7;
u32 gpio_scl = GPIO_PF1;
gpio_set_func(gpio_sda, AS_I2C); //disable gpio function
gpio_set_func(gpio_scl, AS_I2C); //disable gpio function
gpio_setup_up_down_resistor(gpio_sda, PM_PIN_PULLUP_10K);
gpio_setup_up_down_resistor(gpio_scl, PM_PIN_PULLUP_10K);
gpio_set_input_en(gpio_sda, 1);
gpio_set_input_en(gpio_scl, 1);
#else
u32 gpio_sda = GPIO_PA3;
u32 gpio_scl = GPIO_PA4;
gpio_setup_up_down_resistor(gpio_sda, PM_PIN_PULLUP_10K); // 10k pull_up resistor
gpio_setup_up_down_resistor(gpio_scl, PM_PIN_PULLUP_10K); // 10k pull_up resistor
gpio_set_func(gpio_sda, AS_I2C); // disable gpio function
gpio_set_func(gpio_scl, AS_I2C); // disable gpio function
#endif
// FI2C = (System Clock/(address 0x73[7:4]+1)) / (4 *clock speed configured in address 0x00)
// System Clock / (8 * address 0x00)
// default reg_i2c_speed = 0x13
reg_i2c_speed = (CLOCK_SYS_CLOCK_HZ/4)/clk_hz;
BM_SET(reg_i2c_mode, FLD_I2C_MODE_MASTER); // enable master mode.
BM_SET(reg_rst_clk0, FLD_CLK_I2C_EN); // enable i2c clock
BM_CLR(reg_spi_sp, FLD_SPI_ENABLE); // force PADs act as I2C; i2c and spi share the hardware of IC
//Start/Stop By Master, SDA & SCL = "1"
reg_i2c_ctrl = FLD_I2C_CMD_START | FLD_I2C_CMD_STOP; // launch stop cycle
while(reg_i2c_status & FLD_I2C_CMD_BUSY);
}
я ж говорб там рядом лежит код который собственно документ обсуждаетЧто мы можем почерпнуть из указанных доков?
У вас что регистрации там нет? Почты тоже нет?я ж говорб там рядом лежит код который собственно документ обсуждает
Status I2C_Master_BufferRead(I2C_TypeDef* I2Cx, uint8_t* pBuffer, uint32_t NumByteToRead, I2C_ProgrammingModel Mode, uint8_t SlaveAddress)
{
__IO uint32_t temp = 0;
__IO uint32_t Timeout = 0;
/* Enable I2C errors interrupts (used in all modes: Polling, DMA and Interrupts */
I2Cx->CR2 |= I2C_IT_ERR;
if (Mode == DMA) /* I2Cx Master Reception using DMA */
{
/* Configure I2Cx DMA channel */
I2C_DMAConfig(I2Cx, pBuffer, NumByteToRead, I2C_DIRECTION_RX);
/* Set Last bit to have a NACK on the last received byte */
I2Cx->CR2 |= CR2_LAST_Set;
/* Enable I2C DMA requests */
I2Cx->CR2 |= CR2_DMAEN_Set;
Timeout = 0xFFFF;
/* Send START condition */
I2Cx->CR1 |= CR1_START_Set;
/* Wait until SB flag is set: EV5 */
while ((I2Cx->SR1&0x0001) != 0x0001)
{
if (Timeout-- == 0)
return Error;
}
Timeout = 0xFFFF;
/* Send slave address */
/* Set the address bit0 for read */
SlaveAddress |= OAR1_ADD0_Set;
Address = SlaveAddress;
/* Send the slave address */
I2Cx->DR = Address;
/* Wait until ADDR is set: EV6 */
while ((I2Cx->SR1&0x0002) != 0x0002)
{
if (Timeout-- == 0)
return Error;
}
/* Clear ADDR flag by reading SR2 register */
temp = I2Cx->SR2;
if (I2Cx == I2C1)
{
/* Wait until DMA end of transfer */
while (!DMA_GetFlagStatus(DMA1_FLAG_TC7));
/* Disable DMA Channel */
DMA_Cmd(I2C1_DMA_CHANNEL_RX, DISABLE);
/* Clear the DMA Transfer Complete flag */
DMA_ClearFlag(DMA1_FLAG_TC7);
}
else /* I2Cx = I2C2*/
{
/* Wait until DMA end of transfer */
while (!DMA_GetFlagStatus(DMA1_FLAG_TC5));
/* Disable DMA Channel */
DMA_Cmd(I2C2_DMA_CHANNEL_RX, DISABLE);
/* Clear the DMA Transfer Complete flag */
DMA_ClearFlag(DMA1_FLAG_TC5);
}
/* Program the STOP */
I2Cx->CR1 |= CR1_STOP_Set;
/* Make sure that the STOP bit is cleared by Hardware before CR1 write access */
while ((I2Cx->CR1&0x200) == 0x200);
}
Timeout = 0xFFFF;
/* Send START condition */
I2Cx->CR1 |= CR1_START_Set;
/* Wait until SB flag is set: EV5 */
while ((I2Cx->SR1&0x0001) != 0x0001)
{
if (Timeout-- == 0)
return Error;
}
// Start I2C transmission
_p_twim->ADDRESS = txAddress;
_p_twim->TASKS_RESUME = 0x1UL;
_p_twim->TXD.PTR = (uint32_t)txBuffer._aucBuffer;
_p_twim->TXD.MAXCNT = txBuffer.available();
_p_twim->TASKS_STARTTX = 0x1UL; // шлепнули старт
while(!_p_twim->EVENTS_TXSTARTED && !_p_twim->EVENTS_ERROR); // ждем когда выполнится
_p_twim->EVENTS_TXSTARTED = 0x0UL;
if (txBuffer.available()) { // шлепнули байтики
while(!_p_twim->EVENTS_LASTTX && !_p_twim->EVENTS_ERROR); // ждем когда вылезут
}
_p_twim->EVENTS_LASTTX = 0x0UL;
if (stopBit || _p_twim->EVENTS_ERROR) // шлепнули стоп
{
_p_twim->TASKS_STOP = 0x1UL;
while(!_p_twim->EVENTS_STOPPED); // ждем когда выполнится
_p_twim->EVENTS_STOPPED = 0x0UL;
}
else
{
_p_twim->TASKS_SUSPEND = 0x1UL;
while(!_p_twim->EVENTS_SUSPENDED);
_p_twim->EVENTS_SUSPENDED = 0x0UL;
}
if (_p_twim->EVENTS_ERROR)
{
_p_twim->EVENTS_ERROR = 0x0UL;
uint32_t error = _p_twim->ERRORSRC;
_p_twim->ERRORSRC = error;
if (error == TWIM_ERRORSRC_ANACK_Msk)
{
return 2;
}
else if (error == TWIM_ERRORSRC_DNACK_Msk)
{
return 3;
}
else
{
return 4;
}
}
ох как раздухарился...While на каждый бит/байт в шину i2с :
чем теорией по древу растекаться , да тактики подчитывать не проще ли взять и на практике это всё подтвердить...// ждем когда выполнится
откуда такие умозаключения? что опять ... Л - логика?У вас что регистрации там нет? Почты тоже нет?