Firmware

Flux is an AI hardware engineer. It writes firmware for the controller and peripherals in your greenhouse monitor project.

Connect firmware to the hardware

Ask Flux to use the controller pins and peripherals from the schematic and the requirements from the Project Specification.

Write firmware for this greenhouse monitor. Read the soil probe at the specified interval and report the moisture value through the selected phone connection.

Add battery status and an LED pattern for startup, sensor readings, and connection status.

See Firmware and Firmware with your hardware.

Open Chat in the project and describe the greenhouse monitor behavior. Select Files to read the firmware starter document, pin map, and bring-up plan.

Write and organize the firmware

Ask Flux to create firmware files from the schematic and project requirements.

Create the firmware starter document and pin map for this monitor from the schematic. Include the probe, status LED, battery monitor, and wireless connection.

Write the sensor-reading function and add a test for dry, damp, and wet soil values.

Select Files, open the Documents panel, and select New to create a project document. Keep source files, the pin map, tests, and bring-up steps with the project.

Build and test firmware

Ask Flux to build and test firmware after each hardware or behavior change.

Build this project's firmware and report the output files and memory use.

Update the pin map and bring-up plan for the new probe connector and status LED in the schematic.

See Build and test firmware and Bring up your board.

Prepare the bring-up steps

Ask Flux to make a test plan that follows the board, firmware, and probe connections.

Create a bring-up checklist for power, programming, sensor readings, battery status, and phone connection.

Compare the firmware pin assignments with the schematic and list the tests for damp and dry soil.

Map schematic connections to firmware

Ask Flux to create a pin map from the greenhouse monitor schematic. Include the function, controller pin, connected net, direction, and notes for each interface.

Create a pin map from this schematic for the probe, status LED, battery monitor, charger, and wireless connection.

Compare the firmware pin assignments with the schematic. Find pin conflicts and list the source files that need updates.

Open Chat with the schematic in the project and ask Flux to create or update the pin map. Select Files to read the project documents. Ask Flux to include I2C addresses, clock settings, boot behavior, active polarity, and power modes when they apply to the controller.

Name each sensor, connector, and indicator in the monitor.
Ask Flux to map each device to its controller pin and schematic net.
Ask it to record bus addresses and timing requirements.
Compare the map with firmware source and the schematic.
Update the map after a board or pin assignment change.

Continue from existing firmware

Ask Flux to use an existing public repository, uploaded ZIP, or source files when the project already has firmware.

Continue from this firmware ZIP. Keep its project structure and add the greenhouse probe driver using the pins in the schematic.

Read this public repository and compare its sensor driver with the monitor schematic. List the files and pin settings that need changes.

Open Chat and share a public repository link, attach the ZIP, or paste the relevant files. Ask Flux to summarize the existing structure before requesting a feature. Flux can connect the source to the project schematic and document the framework, build system, libraries, and board configuration in the firmware starter document.

Identify the firmware source and target controller.
Ask Flux to describe the build and source layout.
Request a driver, feature, or test that matches the monitor hardware.
Ask Flux to update the pin map and firmware documentation.
Select Files to read the updated source and project records.

Build, test, and prepare board bring-up

Ask Flux to build the firmware and run tests for the monitor behavior. Request image files, flash and RAM use, and the largest symbols. Flux can run host tests, static analysis, and memory checks for firmware logic.

Build this monitor firmware. Return the image files, flash and RAM use, and the largest symbols.

Test the soil-moisture conversion for dry, damp, and wet input values. Report the test results and coverage.

Select Files in the project view switcher to find the build outputs and notes. Ask Flux to create a bring-up plan with visual inspection, rail voltages, reset and boot checks, programming, and sensor tests. State the expected result for each test.

Build the current source and save the output with the project.
Add tests for sensor conversion, communication parsing, startup state, and battery reporting.
Ask Flux to record clock, pin, timing, and boot assumptions.
Create a bring-up checklist from the schematic and expected behavior.
Ask Flux for the command you can run on your computer to flash the board.

Connect the board to your computer and run the command Flux gives you. Keep the firmware image, test results, and bring-up plan with the project files.

Keep hardware and firmware revisions aligned

Ask Flux to update firmware and its supporting documents when the board or enclosure changes.

The probe connector moved and the status LED changed pins. Update the firmware, pin map, and bring-up steps.

Use the sensor position from the mechanical model as a named firmware constant in millimeters.

Open Chat after a schematic or mechanical revision. Ask Flux to compare the firmware pin map with the schematic, update code for changed peripherals, and read relevant dimensions from the mechanical model. Record field findings and the next test in Files. See Firmware with your hardware and Firmware prompt examples.

Continue with Simulation and checks.

Last updated on

Was this page helpful?