// // Created by MightyPork on 2018/01/02. // #include "comm/messages.h" #include "unit_base.h" #include "utils/avrlibc.h" #include "unit_i2c.h" // I2C master /** Private data structure */ struct priv { uint8_t periph_num; //!< 1 or 2 bool anf; //!< Enable analog noise filter uint8_t dnf; //!< Enable digital noise filter (1-15 ... max spike width) uint8_t speed; //!< 0 - Standard, 1 - Fast, 2 - Fast+ I2C_TypeDef *periph; GPIO_TypeDef *port; uint32_t ll_pin_scl; uint32_t ll_pin_sda; }; // ------------------------------------------------------------------------ /** Load from a binary buffer stored in Flash */ static void UI2C_loadBinary(Unit *unit, PayloadParser *pp) { struct priv *priv = unit->data; uint8_t version = pp_u8(pp); (void)version; priv->periph_num = pp_u8(pp); priv->anf = pp_bool(pp); priv->dnf = pp_u8(pp); priv->speed = pp_u8(pp); } /** Write to a binary buffer for storing in Flash */ static void UI2C_writeBinary(Unit *unit, PayloadBuilder *pb) { struct priv *priv = unit->data; pb_u8(pb, 0); // version pb_u8(pb, priv->periph_num); pb_bool(pb, priv->anf); pb_u8(pb, priv->dnf); pb_u8(pb, priv->speed); } // ------------------------------------------------------------------------ /** Parse a key-value pair from the INI file */ static bool UI2C_loadIni(Unit *unit, const char *key, const char *value) { bool suc = true; struct priv *priv = unit->data; if (streq(key, "device")) { priv->periph_num = (uint8_t) avr_atoi(value); } else if (streq(key, "analog-filter")) { priv->anf = str_parse_yn(value, &suc); } else if (streq(key, "digital-filter")) { priv->dnf = (uint8_t) avr_atoi(value); } else if (streq(key, "speed")) { priv->speed = (uint8_t) avr_atoi(value); } else { return false; } return suc; } /** Generate INI file section for the unit */ static void UI2C_writeIni(Unit *unit, IniWriter *iw) { struct priv *priv = unit->data; iw_comment(iw, "Peripheral number (I2Cx)"); iw_entry(iw, "device", "%d", (int)priv->periph_num); iw_comment(iw, "Speed: 1-Standard, 2-Fast, 3-Fast+"); iw_entry(iw, "speed", "%d", (int)priv->speed); iw_comment(iw, "Analog noise filter enable (Y,N)"); iw_entry(iw, "analog-filter", "%s", str_yn(priv->anf)); iw_comment(iw, "Digital noise filter bandwidth (0-15)"); iw_entry(iw, "digital-filter", "%d", (int)priv->dnf); } // ------------------------------------------------------------------------ /** Allocate data structure and set defaults */ static bool UI2C_preInit(Unit *unit) { bool suc = true; struct priv *priv = unit->data = calloc_ck(1, sizeof(struct priv), &suc); CHECK_SUC(); // some defaults priv->periph_num = 1; priv->speed = 1; priv->anf = true; priv->dnf = 0; return true; } /** Finalize unit set-up */ static bool UI2C_init(Unit *unit) { bool suc = true; struct priv *priv = unit->data; if (!(priv->periph_num >= 1 && priv->periph_num <= 2)) { unit->status = E_BAD_CONFIG; dbg("!! Bad I2C periph"); return false; } if (!(priv->speed >= 1 && priv->speed <= 3)) { unit->status = E_BAD_CONFIG; dbg("!! Bad I2C speed"); return false; } if (priv->dnf > 15) { unit->status = E_BAD_CONFIG; dbg("!! Bad I2C DNF bw"); return false; } // assign and claim the peripheral if (priv->periph_num == 1) { suc = rsc_claim(unit, R_I2C1); CHECK_SUC(); priv->periph = I2C1; } else { suc = rsc_claim(unit, R_I2C2); CHECK_SUC(); priv->periph = I2C2; } // This is written for F072, other platforms will need adjustments char portname; uint8_t pin_scl; uint8_t pin_sda; uint32_t af_i2c; uint32_t timing; // magic constant from CubeMX #if GEX_PLAT_F072_DISCOVERY // scl - 6 or 8 for I2C1, 10 for I2C2 // sda - 7 or 9 for I2C1, 11 for I2C2 portname = 'B'; if (priv->periph_num == 1) { pin_scl = 8; pin_sda = 9; } else { pin_scl = 10; pin_sda = 12; } af_i2c = LL_GPIO_AF_1; if (priv->speed == 1) timing = 0x00301D2B; // Standard else if (priv->speed == 2) timing = 0x0000020B; // Fast else timing = 0x00000001; // Fast+ #elif GEX_PLAT_F103_BLUEPILL #error "NO IMPL" #elif GEX_PLAT_F303_DISCOVERY #error "NO IMPL" #elif GEX_PLAT_F407_DISCOVERY #error "NO IMPL" #else #error "BAD PLATFORM!" #endif // first, we have to claim the pins Resource r_sda = pin2resource(portname, pin_sda, &suc); Resource r_scl = pin2resource(portname, pin_scl, &suc); CHECK_SUC(); rsc_claim(unit, r_sda); rsc_claim(unit, r_scl); CHECK_SUC(); GPIO_TypeDef *port = port2periph(portname, &suc); uint32_t ll_pin_scl = pin2ll(pin_scl, &suc); uint32_t ll_pin_sda = pin2ll(pin_sda, &suc); CHECK_SUC(); // configure AF if (pin_scl < 8) LL_GPIO_SetAFPin_0_7(port, ll_pin_scl, af_i2c); else LL_GPIO_SetAFPin_8_15(port, ll_pin_scl, af_i2c); if (pin_sda < 8) LL_GPIO_SetAFPin_0_7(port, ll_pin_sda, af_i2c); else LL_GPIO_SetAFPin_8_15(port, ll_pin_sda, af_i2c); LL_GPIO_SetPinMode(port, ll_pin_scl, LL_GPIO_MODE_ALTERNATE); LL_GPIO_SetPinMode(port, ll_pin_sda, LL_GPIO_MODE_ALTERNATE); // set as OpenDrain (this may not be needed - TODO check) LL_GPIO_SetPinOutputType(port, ll_pin_scl, LL_GPIO_OUTPUT_OPENDRAIN); LL_GPIO_SetPinOutputType(port, ll_pin_sda, LL_GPIO_OUTPUT_OPENDRAIN); if (priv->periph_num == 1) { __HAL_RCC_I2C1_CLK_ENABLE(); } else { __HAL_RCC_I2C2_CLK_ENABLE(); } /* Disable the selected I2Cx Peripheral */ LL_I2C_Disable(priv->periph); LL_I2C_ConfigFilters(priv->periph, priv->anf ? LL_I2C_ANALOGFILTER_ENABLE : LL_I2C_ANALOGFILTER_DISABLE, priv->dnf); LL_I2C_SetTiming(priv->periph, timing); LL_I2C_DisableClockStretching(priv->periph); LL_I2C_Enable(priv->periph); LL_I2C_DisableOwnAddress1(priv->periph); // OA not used LL_I2C_SetMode(priv->periph, LL_I2C_MODE_I2C); // not using SMBus return true; } /** Tear down the unit */ static void UI2C_deInit(Unit *unit) { struct priv *priv = unit->data; // de-init the pins & peripheral only if inited correctly if (unit->status == E_SUCCESS) { LL_I2C_DeInit(priv->periph); if (priv->periph_num == 1) { __HAL_RCC_I2C1_CLK_DISABLE(); } else { __HAL_RCC_I2C2_CLK_DISABLE(); } LL_GPIO_SetPinMode(priv->port, priv->ll_pin_sda, LL_GPIO_MODE_ANALOG); LL_GPIO_SetPinMode(priv->port, priv->ll_pin_scl, LL_GPIO_MODE_ANALOG); } // Release all resources rsc_teardown(unit); // Free memory free(unit->data); unit->data = NULL; } // ------------------------------------------------------------------------ enum PinCmd_ { CMD_WRITE = 0, CMD_READ = 1, }; static void i2c_reset(struct priv *priv) { LL_I2C_Disable(priv->periph); HAL_Delay(1); LL_I2C_Enable(priv->periph); } static bool i2c_wait_until_flag(struct priv *priv, TF_ID frame_id, uint32_t flag, bool stop_state, const char *msg) { uint32_t t_start = HAL_GetTick(); while (((priv->periph->ISR & flag)!=0) != stop_state) { if (HAL_GetTick() - t_start > 10) { com_respond_err(frame_id, msg); i2c_reset(priv); return false; } } } /** Handle a request message */ static bool UI2C_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command, PayloadParser *pp) { struct priv *priv = unit->data; uint8_t addrsize; // 7 or 10 uint16_t addr; uint32_t len; uint32_t t_start; switch (command) { case CMD_WRITE:; addrsize = pp_u8(pp); // 7 or 10 addr = pp_u16(pp); t_start = HAL_GetTick(); while (LL_I2C_IsActiveFlag_BUSY(priv->periph)) { if (HAL_GetTick() - t_start > 10) { com_respond_err(frame_id, "BUSY TIMEOUT"); i2c_reset(priv); return false; } } // if (!i2c_wait_until_flag(priv, frame_id, I2C_ISR_BUSY, 0, "BUSY TIMEOUT")) return false; uint32_t chunk_remain; while (pp_length(pp) > 0) { len = pp_length(pp); chunk_remain = (uint8_t) ((len > 255) ? 255 : len), // if more than 255, first chunk is 255 LL_I2C_HandleTransfer(priv->periph, (addrsize == 7) ? addr << 1 : addr, // Address must be shifted to left by one if 7-bit mode is used. Bit 0 serves for R/W flag (addrsize == 7) ? LL_I2C_ADDRSLAVE_7BIT : LL_I2C_ADDRSLAVE_10BIT, // translate to LL bitfields (uint32_t) chunk_remain, (len > 255) ? LL_I2C_MODE_RELOAD : LL_I2C_MODE_AUTOEND, // Autoend if this is the last chunk LL_I2C_GENERATE_START_WRITE); for (; chunk_remain > 0; chunk_remain--) { t_start = HAL_GetTick(); while (!LL_I2C_IsActiveFlag_TXIS(priv->periph)) { if (HAL_GetTick() - t_start > 10) { com_respond_err(frame_id, "TXIS TIMEOUT"); i2c_reset(priv); return false; } } uint8_t byte = pp_u8(pp); LL_I2C_TransmitData8(priv->periph, byte); } } t_start = HAL_GetTick(); while (!LL_I2C_IsActiveFlag_STOP(priv->periph)) { if (HAL_GetTick() - t_start > 10) { com_respond_err(frame_id, "STOPF TIMEOUT"); i2c_reset(priv); return false; } } break; case CMD_READ: addrsize = pp_u8(pp); // 7 or 10 addr = pp_u16(pp); len = pp_u16(pp); // TODO support > 255? if (len > 256) { com_respond_err(frame_id, "TOO LONG"); return false; } LL_I2C_HandleTransfer(priv->periph, (addrsize == 7) ? addr << 1 : addr, addrsize == 7 ? LL_I2C_ADDRSLAVE_7BIT : LL_I2C_ADDRSLAVE_10BIT, (uint32_t) pp_length(pp), LL_I2C_MODE_AUTOEND, // ? LL_I2C_GENERATE_START_READ); for (uint32_t i = 0; i < len; i++) { t_start = HAL_GetTick(); while (!LL_I2C_IsActiveFlag_RXNE(priv->periph)) { // wait for RXNE if (HAL_GetTick() - t_start > 10) { com_respond_err(frame_id, "RX TIMEOUT"); return false; } } uint8_t b = LL_I2C_ReceiveData8(priv->periph); unit_tmp512[i] = b; } com_respond_buf(frame_id, MSG_SUCCESS, (uint8_t *) unit_tmp512, len); break; default: com_respond_bad_cmd(frame_id); return false; } return true; } // ------------------------------------------------------------------------ /** Unit template */ const UnitDriver UNIT_I2C = { .name = "I2C", .description = "I2C master", // Settings .preInit = UI2C_preInit, .cfgLoadBinary = UI2C_loadBinary, .cfgWriteBinary = UI2C_writeBinary, .cfgLoadIni = UI2C_loadIni, .cfgWriteIni = UI2C_writeIni, // Init .init = UI2C_init, .deInit = UI2C_deInit, // Function .handleRequest = UI2C_handleRequest, };