The number of sensors is proliferating across the Earth's surface and in the spaces surrounding our lives, providing a vast array of data and information to the world. These affordable sensors are the driving force behind the development of the Internet of Things (IoT) and the digital revolution our society is facing. However, connecting to and acquiring data from sensors is not always a straight line or an easy task. Here are five tips to help engineers ease the first hurdle in interface-to-sensor communication.
Tip 1—Start with bus tools
The first step engineers should take when first interfacing with a sensor is to limit the unknown through a bus tool. A bus tool connects to a personal computer (PC) and then to the sensor via I2C, SPI, or another protocol that allows the sensor to "talk." The PC application associated with the bus tool provides a known and working source for sending and receiving data, and is not an unknown, uncertified embedded microcontroller (MCU) driver. Within the bus tool's operating environment, developers can send and receive messages to gain an understanding of how that part works before attempting to operate at the embedded level.
Tip 2—Writing transport interface code in Python
Once developers have experimented with the sensor using bus tools, the next step is to write application code for the sensor. Instead of jumping directly to microcontroller code, the application code is written in Python. Many bus tools come with plug-ins and sample code for writing scripts, and Python is often one of the languages available with .NET. Writing applications in Python is quick and easy, providing a way to test the sensor already in the application without the complexity of testing in an embedded environment. Having high-level code makes it easy for non-embedded engineers to script and test the sensor without the need for an embedded software engineer.
Tip 3—Testing Sensors with MicroPython
One advantage of writing your first application code in Python is that by calling MicroPython, the application's calls to bus tool application programming interfaces (APIs) are easily replaceable. MicroPython operates within real-time embedded software, where there are many sensors for engineers to understand their value. MicroPython runs on a Cortex-M4 processor, which is an excellent environment for debugging application code. Not only is it simple, but there's also no need to write I2C or SPI drivers, as they are already included in MicroPython's libraries. (For more details, read the articles "Using MicroPython for real-time software development" and "5 Advantages of using MicroPython for Embedded Software Programming" on the EDN website.)
Tip 4—Utilize sensor supplier codes
Any sample code "scraped" from a sensor manufacturer will take engineers a long time to understand how the sensor works. Unfortunately, many sensor vendors are not experts in embedded software design, so don't expect to find a beautiful, production-ready architecture and elegant example. Start with the vendor's code, learn how that part works, and then the frustration of refactoring will arise until it can be cleanly integrated into the embedded software. It may start like "spaghetti," but leveraging the manufacturer's understanding of how their sensors work will help save many wasted weekends before product launch.
Tip 5—Use a sensor fusion library
The opportunity lies in the fact that sensor transmission interfaces aren't exactly new, and no one has done this before. All known libraries, such as the "sensor fusion libraries" provided by many chip manufacturers, help developers quickly master, and even better master, the technology, avoiding the cycle of redevelopment or significant modifications to the product architecture. Many sensors can be integrated into general types or categories, which facilitate driver development and, if handled properly, are almost universal or minimally reusable. Explore these sensor fusion libraries and learn about their strengths and weaknesses.
at last
When integrating sensors into embedded systems, there are many ways to improve design timelines and ease of use. Developers who begin their design process with a high-level abstraction and learn how sensors work before integrating them into a lower-level system are unlikely to "go astray." Numerous resources available today can help developers "get off to a good start" without having to begin from scratch.
Disclaimer: This article is a reprint. If it involves copyright issues, please contact us promptly for deletion (QQ: 2737591964 ) . We apologize for any inconvenience.
