STM32 I2C Driver Development

@tshibsamuel477

Hi there, I read your offer carefully and understand that you need a clean C-based I2C driver for STM32, supporting both master and slave modes at 100 kHz Standard-mode, with blocking and non-blocking transfers. I can develop the source/header files, initialization routines, ACK/NACK handling, start/stop sequencing, timeout recovery, CubeIDE integration, example project, README, and logic-analyzer-ready validation workflow. My experience with STM32, HAL/LL drivers, embedded C, I2C communication, interrupts, DMA, and firmware debugging fits this project well. Just send me a message and we can discuss the board details. Best regards, Samuel Tshibangu

@mahmoudralizadeh

Hi, I've built I2C, SPI, and UART drivers on STM32 (both HAL and LL) for motor-control and sensor-fusion projects, including interrupt- and DMA-driven transfer paths with proper bus-fault recovery, so this maps directly onto work I've already done. Proposed approach: Runtime-selectable master/slave init via a single config struct, keeping HAL-Init calls clean and warning-free in CubeIDE. State-machine-based transaction handling (not blocking spin-loops) for the interrupt/DMA paths, with explicit states for START, address phase, data phase, and STOP — this is what makes ACK/NACK and timeout recovery robust rather than fragile. Bus recovery routine: detects SCL/SDA stuck-low conditions and issues the standard clock-out + STOP sequence to un-wedge the bus, with a watchdog timeout so a fault never hangs the app. Blocking API kept minimal, mainly for simple polling use-cases you may want during bring-up/debug. Example project with two boards (or one board using two I2C peripherals if you only have one board available) running master↔slave read/write loops, verified against a logic analyzer at 100 kHz before delivery. README covering clock config (PCLK1/timing register values for 100 kHz Sm), pull-up resistor guidance, and wiring diagram. A couple of quick questions to lock down timeline: Which STM32 series/part (F1/F3/F4/L4, etc.) and how many I2C-capable boards do you have available for loopback testing? Do you have a logic analyzer already, or should I account for verifying purely via UART debug prints and provide capture instructions for you to run yourself? Happy to share a short code sample (a DMA-based I2C read routine from a past project) if useful before you decide. Looking forward to your thoughts on timeline and budget.

@elect2eng

Hello, I have good knowledge and understanding of I2C operation. Do you want a conditional compilation so that the same code can be used as master or slave condition and or blocked read/non-blocking etc...? I have stm32f103 board with me,. Which is your processor? Usually, it is clumsy in cube IDE to change the processor type... I have seen someone has asked for more clarification. Please share the full spec or sequence of operation you need

@nevorek

God day. I've done similar work. I have hardware for testing STM32F4 and F1 and also logic analyser for showing diagrams. I can show code example in PM. Time: 2-3 days for coding and 1-2 days for good testing.

@Zainrais0786

I can develop a clean, well-documented I2C driver written in C for your stm32 board which will operate in both slave and master modes while staying in 100KHz mode. Hi, I am Zain. I can easily handle the task including • STM32 / Cube IDE / Cube MX • Firmware Development • C / C++ • Embedded Systems • Circuit Design • PCB Design • KiCAD / Altium • Mixed Signal PCB Designs / High Frequency PCB Designs • Simulations etc. Lets chat. Best regards

@Webslinger01

You need an I2C driver that works in both master and slave modes, handles bus faults cleanly, and integrates into your existing CubeIDE project without friction. I've done this exact thing multiple times — the last one was for a multi-sensor industrial controller where I2C reliability was critical. Here's what I bring to this: → I've written a dual-mode I2C driver for an STM32-based system that passed 500+ consecutive logic-analyzer captures with zero ACK/NACK errors → You'll get clean source and header files with line-level comments, blocking and interrupt-based transfer functions, and a ready-to-build CubeIDE example project → The driver will handle both master and slave roles at runtime via a simple initialization routine, with proper error recovery for bus faults or time-outs → I'll deliver the full package — source, example, README, and a logic-analyzer-verified demo — within 3 days My approach: → First, I'll clarify any board-specific pinout or clock details with you to avoid surprises → Then I'll write the driver with clear separation between master and slave logic, including start/stop sequencing and ACK/NACK handling → Finally, I'll build and test the example project, capture the waveforms, and hand everything over with a README covering API usage and wiring For this scope, the cost would be $13500. Happy to walk you through my approach and past work on a chat — just let me know when works.

@salmanali11053

Hi, Your requirement is much more than simply enabling I2C. A robust driver needs reliable START/STOP sequencing, ACK/NACK handling, clock stretching, bus recovery, timeout management, and clean support for both master and slave modes. That's exactly the kind of embedded firmware I work on. I have 11+ years of experience developing STM32 firmware in C using STM32CubeIDE for automotive and industrial systems. My work includes STM32 peripherals (I2C, SPI, UART, CAN, DMA, GPIO, Interrupts), RTOS, and production-quality embedded drivers with clear documentation. ✓ Clean, modular I2C driver with runtime Master/Slave selection ✓ Blocking and interrupt/DMA transfer APIs ✓ Bus fault & timeout recovery ✓ Well-commented source and headers ✓ CubeIDE example project demonstrating bidirectional communication at 100 kHz ✓ README with integration, clock configuration, and wiring details A few questions before we begin: • Which STM32 MCU/board revision are you using? • Should the implementation use HAL APIs internally or a register-level (LL) driver? I can start immediately and keep the implementation clean, maintainable, and easy to integrate into your existing project. Regards, Salman Ali

@soniaer987

Your STM32 I2C driver needs are exactly the kind of focused embedded work I enjoy — clean, well-structured, and with clear acceptance criteria. Getting the timing and error recovery right in both master and slave modes is what separates a reliable driver from one that fails in the field. Here's what I bring to this: → I've written multiple I2C drivers from scratch for STM32, including one for a multi-sensor industrial monitor that needed robust bus recovery after line faults → I deliver source and header files with line-level comments, blocking and non-blocking transfer functions, and a README covering clock setup and wiring → I can handle the full deliverable set — initialization with runtime mode selection, interrupt and DMA support, and a demo project that exercises both roles at 100 kHz → I have the STM32CubeIDE environment ready and can start immediately, with a first version ready for your review within 4 days My approach: → I'd start by clarifying your specific STM32 variant and pinout to lock down the HAL or LL configuration → Then build the driver module with clear separation between master and slave logic, including ACK/NACK handling and timeout-based recovery → Finally, I'd wire up the demo project with logic-analyzer validation and deliver everything as a clean CubeIDE workspace For this scope, the cost would be $12500. Happy to walk you through my approach and past work on a chat.

@anjalin0309

Hello, Your project matches my embedded firmware background, and I'd be happy to help develop a reliable I2C driver for your STM32 platform. I have experience working with STM32 microcontrollers using **STM32CubeIDE**, developing peripheral drivers and embedded applications in C. I understand the importance of implementing robust I2C communication with correct START/STOP generation, ACK/NACK handling, timeout management, and error recovery to ensure dependable communication. I can develop a well-structured and documented driver that integrates cleanly into your existing CubeIDE project. The implementation can support both **master and slave modes**, with runtime initialization, blocking and interrupt-driven transfers, and clear APIs for read/write operations. I'll also provide a demonstration project, comprehensive source comments, and a README explaining integration, clock configuration, and hardware connection requirements. Before starting, I'd like to review your STM32 variant, board revision, and pin assignments to ensure the driver is optimized for your hardware and to minimize development iterations. I believe in maintaining clear communication throughout the project and delivering clean, maintainable code that is easy to extend in the future. I look forward to discussing your project. Best regards, Anjali

@shenglin0617

Hi, I can develop a clean and production-ready STM32 I2C driver module that integrates smoothly into your STM32CubeIDE HAL-based project. I have extensive STM32 firmware experience with multiple MCU families and have implemented reliable communication drivers including I2C, UART/RS485, and industrial protocols. For this project, I will provide a structured C module supporting runtime Master/Slave selection, blocking APIs, and interrupt/DMA-based non-blocking transfers. My implementation will focus on real-world reliability: correct START/STOP handling, ACK/NACK processing, timeout protection, bus recovery for stuck lines, and clean HAL integration without compiler warnings. I will also provide a test project demonstrating bidirectional Master-Slave communication at 100kHz and documentation covering API usage, clock configuration, and hardware considerations. I can deliver well-commented, maintainable firmware suitable for integration into your final product. I look forward to helping with this project. Best regards, ShengLin Gu.

@copulas

Hello, Our team is based in Japan, blending strong technical skills with Japanese discipline, punctuality, and attention to detail. We'll work efficiently to complete your project perfectly — and as quickly as possible. Expect clear communication, reliable delivery, and a deep commitment to quality. Whether it's a small fix or a full build, we’ll treat your project with the care it deserves. Let’s make it happen. Warmly Regards.

@caodx

Hello, I have solid experience developing STM32 firmware and can deliver a clean, well-documented I2C driver in C supporting both Master and Slave modes at 100 kHz. The driver will include blocking and interrupt/DMA transfers, proper START/STOP, ACK/NACK handling, timeout and bus-error recovery, and will compile cleanly in STM32CubeIDE. I’ll also provide a demo project, README, and assist with integration. Please share your STM32 model, board revision, and I2C pinout.

@Engineer1337

Hi sir , I can do your project , I am fulltime free for your project , I will hand you all files that you need

@heenafullstacken

I would approach STM32 I2C Driver Development as a measurable robotics system, with perception, communication, and control validated separately before the complete demonstration. I can develop the ROS/ROS2 package structure, integrate sensors or actuators, build OpenCV/YOLO perception, prepare launch and configuration files, and supply repeatable setup and test instructions. To recommend the right package design, please tell me the ROS distribution, target robot or simulator, available sensors, and the exact behaviour that will mark the project successful. Robotics profile: https://www.freelancer.in/u/heenafullstacken Kind regards, Heena | A Plus IT House

@vinaykumarc5

Hello, I am Vinay Kumar, an Embedded Firmware Engineer with strong experience in STM32, ARM Cortex-M, and Embedded C. I specialize in low-level peripheral driver development including I2C, SPI, UART, GPIO, Timers, ADC, DMA, and Interrupts, with hands-on experience using STM32CubeIDE, HAL, and CMSIS. This project perfectly matches my expertise. I have been teaching ARM Cortex-M3/M4 and STM32 driver development for over 3 years through VinTech Embedded Academy, where I have trained many students in writing peripheral drivers from scratch. I also maintain a complete ARM Cortex-M learning series on YouTube. For your project, I will deliver: ✔ Clean, modular, and well-commented I2C driver in C ✔ Master and Slave mode support with runtime configuration ✔ Blocking and Interrupt-based transfer APIs (DMA support can also be added if required) ✔ Proper START/STOP generation, ACK/NACK handling, arbitration/error recovery, and timeout mechanisms ✔ STM32CubeIDE compatible project with clear integration steps ✔ Example application demonstrating reliable master/slave communication at 100 kHz ✔ README with API documentation, clock configuration, and hardware connection details Best Regards, Vinay Kumar Embedded Firmware Engineer Founder – VinTech Embedded Academy

@Shannonkb21

We recently helped a client achieve seamless communication between their STM32 devices using a custom I2C driver — and judging by your post, it sounds like we could do the same for you. We've worked on I2C driver development for microcontrollers and would love to bring that experience to your project. From your post, it sounds like you're looking for something clean and well-documented, specifically around the dual master-slave functionality with strict adherence to the 100 kHz Standard-mode specification. We specialize in embedded systems programming and have 75+ 5-star reviews on similar projects, ranking in the top 1% among 75 million users! I would love to help you with your project! The worst that can happen is you walk away with free consultation. Regards, Shannonkb21

@nasralden

Hello Your project requires much more than simply calling the STM32 HAL I2C APIs—it requires a reliable, reusable driver with proper protocol handling, error recovery, and clean documentation. This is exactly the kind of embedded firmware work I specialize in. I can develop a well-structured I2C driver in C that integrates cleanly with STM32CubeIDE and supports both Master and Slave modes at 100 kHz Standard Mode, including: Runtime selection between Master and Slave modes Blocking and interrupt-based non-blocking read/write APIs Proper START/STOP sequencing and ACK/NACK handling Robust timeout and bus error recovery Clean, modular source code with detailed comments Example CubeIDE project demonstrating Master-to-Slave and Slave-to-Master communication README covering API usage, clock configuration, and hardware wiring Support to verify the implementation until it runs correctly on your board Before starting, I'd like to confirm a few hardware details (STM32 part number, board revision, I2C peripheral, and pinout) so the driver matches your platform perfectly and we avoid unnecessary delays. I look forward to working with you.

@tatumm17

I can implement a clean STM32 I2C driver in C that supports both master and slave at 100 kHz, with correct START/STOP, ACK/NACK, and robust error handling, fitting neatly into your existing STM32CubeIDE HAL project. I’ve shipped STM32 I2C modules using both HAL and LL, including blocking and IRQ/DMA paths, and validated them with logic analyzers to confirm timing, bus recovery, and multi-role operation across revisions. My approach: define a clear API for runtime role selection, provide blocking and non-blocking transfers, plus a small demo project and README covering clocks and wiring. I would love to chat more about your project! Regards

@onurbaranyilmaz

Hello, I have NUCLEO-F446RE board that has several I2C peripherals to facilitate testing of my driver in master and slave modes. It is possible for me to create two I2C peripherals and perform a full transaction at 100 kHz speed. It allows testing of blocking, interrupt-driven and DMA modes, START/STOP processing, ACK/NACK mechanism, timeouts, bus errors and recovery, data integrity and other aspects. I have experience using STM32CubeIDE, STM32 HAL library, embedded C programming, peripheral setting, debugging, hardware communication protocols. In addition, I graduated from Computer Science University program. The delivery will contain commented source and header files, runtime selection of role, blocking/non-blocking read/write functions, timeout and bus recovery support, CubeIDE example, repeated data integrity tests, and README file with instructions regarding clock configuration, pinout configuration, connections and API. Let me know about your target board, pinout, slave address and integration issues.