✅ How to meet the Basic Embedded System Requirements on a micro:bit

1️⃣ Use at least one DIGITAL input

✔ What counts as a digital input on a micro:bit?

Digital inputs are on/off (true/false).

Good options:

• Button A or B (built into micro:bit) ✅ recommended
  
  

• External push button on a GPIO pin
  
  

• Digital motion or sound threshold
  
  

📌 Best choice (simple & safe)

Use Button A as a Start / Calibrate button.

Example use:

• Press Button A to:
  
  

  • Start the system
    
    

  • Or calibrate baseline sensor values (e.g. normal moisture)
    
    

2️⃣ Use at least one ANALOGUE input

✔ What counts as an analogue input?

Analogue inputs return a range of values (e.g. 0–1023).

Good options:

• Soil moisture sensor (external) ✅ excellent
  
  

• Light level (built-in sensor)
  
  

• Temperature (built-in sensor)
  
  

• Potentiometer
  
  

📌 Best choice for coursework

Use soil moisture sensor (connected to pin P1 or P2)
Optionally also log:

• Temperature
  
  

• Light level
  
  

This strengthens your project but only one analogue input is required.

3️⃣ Generate at least one PRIMARY output

✔ What counts as a primary output?

Something the system does or shows automatically.

Good options:

• LED display (built-in) ✅
  
  

• Buzzer (external) ✅ very strong for adaptive feedback
  
  

• Servo motor
  
  

• LED traffic-light system
  
  

📌 Best combination

• LED display → shows system state (LOW / MED / HIGH)
  
  

• Buzzer → alerts when risk is high
  
  

Only one is required, but two looks excellent.

4️⃣ Manual start or calibration (digital input)

You must show:

The system can be started or calibrated manually

📌 How to do this

Use Button A for calibration:

• User presses Button A
  
  

• System stores:
  
  

  • Current moisture as “normal”
    
    

• Confirms calibration (icon or sound)
  
  

This proves human input is used correctly.

5️⃣ Automatic operation after starting

This is very important.

After calibration:

• The system must run in a loop
  
  

• No more button presses needed
  
  

• It:
  
  

  • Reads sensors
    
    

  • Logs data
    
    

  • Updates outputs
    
    

  • Repeats automatically

Student Summary – LC Computer Science Coursework Project (2026)

1. What You Have to Do

You must complete a 12-week project worth 90 marks (30% of your LC grade).
Your work must include:

1. A computational artefact
   
   

   • A functional embedded system you design and build.
     
     

   • A computer-based model created in Python.
     
     

   • A feedback mechanism that makes your system or model adapt automatically.
     
     

2. A project report presented as a website (HTML file, max 2500 words)
   
   

   • Must include a video (max 5 minutes, max 1GB) showing your artefact working.
     
     

Your project is based on the theme:
Forests, climate, biodiversity, environmental data, and risk modelling.
(See page 4 of the brief for context )

2. What Your Artefact Must Do

Basic Requirements (page 5 )

You must:
✔ Build an embedded system with:

• At least one digital input (e.g., button, motion sensor, rain detector)
  
  

• At least one analogue input (e.g., light sensor, soil moisture sensor, temperature sensor)
  
  

• At least one output (e.g., LED, buzzer, servo, or analogue output)
  
  

✔ It must run automatically after starting/calibration.

✔ You must:

• Collect and store environmental data.
  
  

• Use the device to simulate a real-world forest-related process (e.g., drought cycle, wildfire risk, population change, canopy cover).
  
  

Advanced Requirements (page 5–6 )

You must also create:

1. A disaster risk model (Python)
   
   

   • Combines data from your embedded system
     
     

   • Can also include open data or your own simulated data
     
     

   • Example risks: wildfire, drought, pest outbreak, flooding, air quality decline, species population collapse.
     
     

2. Two “What-If” simulations
   You change important variables and show the effect on your model.
   Examples:
   
   

   • What if temperature increases?
     
     

   • What if rainfall decreases?
     
     

   • What if tree density increases / canopy decreases?
     
     

3. An adaptive system
   Something must automatically respond to change, either physically or in software.
   Examples:
   
   

   • Model automatically updates predictions with new real data
     
     

   • Device waters a plant when soil moisture is low
     
     

   • LED or buzzer alerts when wildfire risk is high
     
     

3. What You Must Submit

A single ZIP file with two folders (page 7–8 )

Your ZIP must contain:

1. “Report” folder

• Contains index.html (your full website report)
  
  

• Includes images, video file, CSS, and any extra pages or assets
  
  

• Everything must be accessible offline — no Google Sites or online videos
  
  

2. “Artefact” folder

• Contains all your code files
  
  

• Clearly shows structure
  
  

• Names main program file if applicable
  
  

If any files are missing or links don’t work, you lose marks, so test it on a different device offline before submitting.

You must also complete the SEC authentication form.

4. The Report Structure

Your report (max 2500 words) has 5 sections:

1. Meeting the Brief (400 words + 5-min video)
   
   

   • Show how you met each basic & advanced requirement
     
     

   • Video is the main evidence
     
     

2. Investigation (~400 words)
   
   

   • Research you carried out
     
     

   • Existing solutions and how research influenced your decisions
     
     

3. Plan and Design (~600 words)
   
   

   • Options considered and why you chose yours
     
     

   • Stakeholders and user needs
     
     

   • Technologies used
     
     

   • A system architecture diagram or high-level flowchart
     
     

4. Create (~800 words)
   
   

   • Key development milestones
     
     

   • Testing during development
     
     

   • One problem you faced and solved
     
     

   • Detailed description of your Python model or embedded algorithm
     
     

5. Evaluation (~300 words)
   
   

   • How well your final artefact works
     
     

   • What you would improve in future iterations
     
     

6. References + Word Count Summary
   
   

   • Must reference all research (including AI tools)
     
     

   • A table showing word count for each section
     
     

5. Mark Breakdown (90 Marks Total)

(from page 11 )

Section

Marks

Website quality (UI + structure)

5

Meeting the Brief

27

Investigation

10

Plan & Design

18

Create

20

Evaluation

10

References & Word Count

0 (but required; no marks = not optional!)

6. Key Warnings

• Work must be done in class so your teacher can authenticate it.
  
  

• All AI use must be properly referenced.
  
  

• Exceeding 2500 words or 5-minute video can cause mark penalties.
  
  

• The website must be local HTML, not online.
  
  

• All files must open properly offline or marks may be lost.
  
  

• You do not submit the physical embedded system — the video must show everything clearly.
  
  

Perfect — here is everything you asked for:
✔ A student checklist
✔ A 12-week project plan template
✔ A sample “What-If” simulation explanation
✔ A sample system architecture diagram (text-based)
✔ All based directly on the official project brief (cited: )

✅ 1. Full Student Checklist

Leaving Cert Computer Science Coursework Project – 2026

A. Embedded System – Basic Requirements

Make sure your embedded system has:

• At least 1 digital input (button, PIR sensor, rain sensor, etc.)
  
  

• At least 1 analogue input (moisture, temperature, light sensor, etc.)
  
  

• At least 1 output (LED, buzzer, servo, pump, etc.)
  
  

• Runs automatically after starting
  
  

• Collects and stores environmental data
  
  

• Simulates a forest-related process (e.g., drought cycle, canopy cover, wildfire risk)
  
  

B. Advanced Requirements

You must create:

• A Python disaster risk model using:
  
  

  • Data collected from your embedded system
    
    

  • PLUS open-source or simulated data
    
    

• Two What-If simulations (change variables → compare results)
  
  

• A feedback mechanism:
  
  

  • Physical response (e.g., pump waters plant) OR
    
    

  • Virtual response (model auto-adjusts predictions)
    
    

C. Video Requirements

• Max 5 minutes
  
  

• Max 1GB
  
  

• Must show ALL features clearly
  
  

• No visible people (voiceover allowed)
  
  

• Saved inside the Report folder
  
  

• Must open offline
  
  

D. Report Requirements

Your HTML website must include:

1. Meeting the Brief (400 words + video)

• Explain how you met every basic & advanced requirement
  
  

• Include images showing hardware setup
  
  

• Embed the video
  
  

2. Investigation (400 words)

• Research on:
  
  

  • Existing forest monitoring solutions
    
    

  • Real sensors, technologies, modelling approaches
    
    

• Explain how research informed your decisions
  
  

3. Plan & Design (600 words)

• Considered multiple options
  
  

• Chose the best one and justified it
  
  

• Identified stakeholders/end users
  
  

• Listed technologies used
  
  

• Created a high-level architecture diagram
  
  

4. Create (800 words)

• Key development milestones
  
  

• Testing during development
  
  

• A problem you faced and how you solved it
  
  

• Description of your model OR algorithm
  
  

• Evidence (screenshots, code snippets)
  
  

5. Evaluation (300 words)

• What works well
  
  

• Limitations
  
  

• How you would improve it in future
  
  

6. References

• ALL websites, videos, books, code sources
  
  

• AI usage (required by SEC rules)
  
  

7. Word Count Table

• Word count per section
  
  

• Total count ≤ 2500
  
  

E. ZIP File Structure

Must match this EXACT structure:

ProjectName.zip

│

├── Artefact

│     ├── main.py (or equivalent main file)

│     ├── other code files

│     ├── datasets used

│     └── etc.

│

└── Report

      ├── index.html

      ├── video.mp4

      ├── css files

      ├── images

      └── subpages if needed

F. Final Checks

• Opens on another device
  
  

• Works offline
  
  

• Video plays
  
  

• All code runs
  
  

• All links work
  
  

• Word count correct
  
  

• Authentication form completed
  
  

✅ 2. 12-Week Project Plan (Template)

Week 1–2: Research & Investigation

• Research forests, climate risks, sensors, existing solutions
  
  

• Explore micro:bit/Arduino/Raspberry Pi options
  
  

• Choose project theme (e.g., wildfire detection)
  
  

Week 3: Choose Design & Plan

• Decide sensors + inputs + outputs
  
  

• Create architecture diagram
  
  

• Write plan & outline
  
  

Week 4–5: Build Embedded System

• Assemble circuit
  
  

• Write input/output code
  
  

• Ensure system runs automatically
  
  

• Start collecting test data
  
  

Week 6: Data Collection & Simulation

• Collect actual environmental data
  
  

• Implement simulation logic (e.g., drought cycle)
  
  

Week 7: Build Python Model

• Load actual data + open data/simulated data
  
  

• Create algorithm for risk prediction
  
  

• Test basic outputs
  
  

Week 8: What-If Scenarios

• Create Scenario 1 (e.g., high temperature)
  
  

• Create Scenario 2 (e.g., low rainfall)
  
  

• Compare predictions
  
  

Week 9: Feedback Mechanism

• Add automatic responses
  
  

  • e.g., alarm for wildfire
    
    

  • auto-watering
    
    

  • model auto-adjusts using new data
    
    

Week 10: Testing & Fixing

• Test all features
  
  

• Debug code
  
  

• Improve accuracy of model
  
  

Week 11: Produce Video

• Record demonstration
  
  

• Add voiceover explaining features
  
  

• Compress to <1GB
  
  

Week 12: Write Report + Final Checks

• Write full HTML report
  
  

• Add references + word count
  
  

• Build ZIP file
  
  

• Test ZIP on another device
  
  

• Submit
  
  

✅ 3. Sample “What-If” Simulation Explanation

Scenario 1 – “What if temperature increases by 3°C?”

Change applied:
Temperature in dataset increased by +3°C per reading.

Prediction result:

• Wildfire risk score increased from 0.42 → 0.73
  
  

• Soil moisture dropped from 21% → 15%
  
  

• Model predicted 2× higher probability of fire ignition.
  
  

Interpretation:
Hotter temperatures dry the soil and increase evaporation, raising wildfire risk significantly.

Scenario 2 – “What if rainfall decreases by 40%?”

Change applied:
Rainfall values reduced by 40% across dataset.

Prediction result:

• Soil moisture trend shows continuous decline
  
  

• Tree stress index rises from 0.3 → 0.55
  
  

• Predicted biodiversity health score drops by 18%
  
  

Interpretation:
Reduced rainfall results in long-term drought, increasing stress on forest ecosystems.

✅ 4. Sample System Architecture Diagram (Text-Based)

(You can copy this directly into your report.)

                  +-----------------------------+

                   |       Embedded System       |

                   +-----------------------------+

                   | Sensors:                    |

                   |  - Soil Moisture (Analogue) |

                   |  - Temperature (Analogue)   |

                   |  - Button Start (Digital)   |

                   +-----------------------------+

                                |

                                v

                   +-----------------------------+

                   |   Microcontroller (e.g.,    |

                   |     Micro:bit / Arduino)    |

                   +-----------------------------+

                                |

                     Data stored in CSV

                                |

                                v

                   +-----------------------------+

                   |     Python Model (PC)       |

                   |  - Loads collected data     |

                   |  - Loads open data          |

                   |  - Runs risk algorithm      |

                   +-----------------------------+

                      /                      \

                     v                        v

          +------------------+     +----------------------+

          | What-If Scenario |     | Feedback Mechanism   |

          | Generator        |     | Auto response based  |

          | (Variable tests) |     | on risk threshold    |

          +------------------+     +----------------------+

This satisfies the “system architecture” requirement in Section 3.
(Page 9–10 in the brief describes this requirement. )

Here is a clear, complete, and deeply detailed explanation of EVERY section of the LC Computer Science Coursework Report (2026), including:

• What is required
  
  

• How many marks each section is worth
  
  

• Exact word counts
  
  

• What examiners look for
  
  

• Common mistakes to avoid
  
  

• Examples of what to include
  
  

All information comes directly from the official SEC brief.
(Cited: )

🔥 FULL BREAKDOWN — LC Computer Science Coursework Report 2026

The written report must be:

• Presented as a website (HTML)
  
  

• Max 2500 words
  
  

• Include a video ≤ 5 minutes
  
  

• Worth 90 marks (30% of the LC grade)
  
  

Below is each section explained in depth.

✅ SECTION 0: Website Structure & UI – 5 Marks

Marks Available: 5 marks

The examiner awards marks for:

What is required

✔ Your report must be a working offline website saved as HTML
✔ Must include index.html as the main file
✔ Must have images, video, CSS, or subpages all correctly linked locally
✔ Must be clean, readable, and well-organised
✔ Must follow basic UI design principles:

• Good headings
  
  

• Consistent colours and fonts
  
  

• Easy navigation
  
  

• Not cluttered
  
  

Common mistakes that lose marks

❌ Using Google Sites / Wix / online hosting
❌ Missing video
❌ Broken links
❌ CSS not loading
❌ Index.html not at the top of the Report folder

These errors will result in automatic mark loss and may prevent the examiner from accessing your work.

✅ SECTION 1: Meeting the Brief – 27 Marks (Largest Section)

Suggested Word Count: ~400 words (plus video)

Marks Available: 27 marks

This is where most marks are awarded.

What is required

This section includes your 5-minute max video which must show:

Basic Requirements (must show all)

1️⃣ Embedded system works

• 1 digital input (button, motion sensor, rain sensor, etc.)
  
  

• 1 analogue input (moisture, light, temperature sensor)
  
  

• 1 digital or analogue output (LED, buzzer, servo, pump)
  
  

2️⃣ It collects and stores environmental data

3️⃣ It simulates a real-world forest process
Examples:

• Drought cycle
  
  

• Wildfire probability
  
  

• Canopy cover
  
  

• Soil moisture change
  
  

Advanced Requirements (must show all)

4️⃣ Your Python disaster risk model
5️⃣ Two “what-if” scenarios
6️⃣ An adaptive feedback mechanism (auto-response)

How to score full marks

Your video should clearly show:

• Inputs being triggered
  
  

• Outputs responding
  
  

• Data being displayed
  
  

• Your model running
  
  

• Your scenarios changing results
  
  

• Your automatic reaction (e.g., buzzer turning on)
  
  

The examiner should not have to “assume” anything.

✅ SECTION 2: Investigation – 10 Marks

Suggested Word Count: ~400 words

Marks Available: 10 marks

What is required

This section shows your research.

You must include:

• Research on forests, climate change, biodiversity, wildfires, droughts, etc.
  
  

• Research on embedded systems and real-world solutions
  
  

• Research on existing models or what-if simulations (NASA, Met Éireann, Teagasc, etc.)
  
  

• Research on sensors, microcontrollers, environmental monitoring
  
  

Most important part

You MUST show how your research influenced your decisions.

Example paragraph:

“After researching existing wildfire early warning systems, I learned that temperature and soil moisture are the two most important variables, so I selected a moisture sensor and used temperature in my Python model.”

To get 10/10

✔ Research is specific
✔ All sources referenced
✔ You show decisions based on research

✅ SECTION 3: Plan & Design – 18 Marks

Suggested Word Count: ~600 words

Marks Available: 18 marks

This is a high-value section where good planning = high marks.

What is required

1. Project Design Objectives

• What your system aims to do
  
  

• Why these features matter
  
  

• Who will use it
  
  

2. Considered Options (must include multiple options)

Explain different choices you considered:

• Sensors
  
  

• Inputs & outputs
  
  

• Microcontroller options
  
  

• Data storage options
  
  

• Python model options
  
  

Then justify your final choices.

3. Stakeholders / End Users

Identify who benefits from your system:

• Forest managers
  
  

• Farmers
  
  

• Environmental agencies
  
  

• Wildlife conservationists
  
  

State their needs.

4. Technologies Used

List and justify:

• Micro:bit / Arduino / Raspberry Pi
  
  

• Sensors
  
  

• Python libraries
  
  

• HTML/CSS
  
  

5. System Architecture (must be here)

Include:

• A block diagram
  
  

• A flowchart
  
  

• Or both
  
  

This MUST show:

• Input → Processing → Output
  
  

• Embedded system → Data → Python → Adaptive response
  
  

How to get 18/18

✔ Include at least 1 diagram
✔ Compare multiple alternatives
✔ Justify choices
✔ Cover all required elements

✅ SECTION 4: Create – 20 Marks

Suggested Word Count: ~800 words (largest written section)

Marks Available: 20 marks

This explains how you built the artefact.

What is required

A. Key Milestones

Example milestones:

• Built and wired sensors
  
  

• Programmed embedded system
  
  

• Logged data
  
  

• Created Python model
  
  

• Ran simulations
  
  

• Added adaptive feedback
  
  

• Debugged system
  
  

• Final video
  
  

B. Testing During Development

You must show evidence that you tested:

• Sensors
  
  

• Model
  
  

• What-if scenarios
  
  

• Adaptive mechanism
  
  

C. One Problem You Encountered

Required by the brief.

Examples:

• Sensor noise
  
  

• CSV saving issues
  
  

• Python error
  
  

• Model not accurate
  
  

• Adaptive system triggering incorrectly
  
  

Explain:

• What happened
  
  

• How you solved it
  
  

D. Describe the Model/Algorithm in detail

You MUST describe either:

• Your disaster risk model
  OR
  
  

• Your embedded system algorithm
  
  

This includes:

• Inputs used
  
  

• Why you chose the weights
  
  

• How you calculate risk
  
  

• Data normalisation
  
  

• Thresholds
  
  

How to score full marks

✔ Show evidence of iteration
✔ Demonstrate real testing
✔ Explain logic clearly
✔ Include code snippets with explanations

✅ SECTION 5: Evaluation – 10 Marks

Suggested Word Count: ~300 words

Marks Available: 10 marks

This is your reflection section.

What is required

A. Evaluate your artefact

Discuss:

• What works well
  
  

• What is reliable
  
  

• What is accurate
  
  

• What data shows
  
  

B. Evaluate the model

• Is it realistic?
  
  

• What are its limitations?
  
  

• How could it improve?
  
  

C. Suggest improvements (must give justification)

Examples:

• Add more sensors
  
  

• Improve accuracy with machine learning
  
  

• Store data in a database
  
  

• Build a mobile app
  
  

• Increase sampling rate
  
  

How to get 10/10

✔ Be honest
✔ Be specific
✔ Suggest realistic improvements with reasons

✅ SECTION 6: References – Required (0 Marks but compulsory)

What is required

• All websites
  
  

• All code sources
  
  

• All sensor datasheets
  
  

• All videos
  
  

• All research
  
  

• AI tools (ChatGPT) MUST be referenced (SEC rule)
  
  

No marks awarded, but:

• Missing → can cause plagiarism investigation
  
  

• Must be included or marks WILL be deducted elsewhere
  
  

✅ SECTION 7: Word Count Summary – Required (0 Marks)

What is required

A table listing:

Section

Word Count

1. Meeting the brief

2. Investigation

3. Plan & design

4. Create

5. Evaluation

Total

≤ 2500

Exceeding 2500 words = mark penalties.

📌 Total Marks Breakdown

Section

Marks

Website Design

5

Meeting the Brief

27

Investigation

10

Plan & Design

18

Create

20

Evaluation

10

References + Word Count

0 (required)

TOTAL

90

Absolutely — here is a COMPLETE SAMPLE COURSEWORK REPORT based fully on the 2026 brief.
This is written exactly in the style a strong Higher Level LC student would submit.
It includes every section, a system diagram (text-based), and stays within the ≈2500-word limit.

⚠️ IMPORTANT:
Students must not copy this word-for-word into their final submission (SEC plagiarism rules).
This is a model/example only.

🌲 FULL SAMPLE LEAVING CERT COMPUTER SCIENCE COURSEWORK REPORT (2026)

Theme: Forest Wildfire Early Warning System
Student Example — Approx. 2400 Words

1. Meeting the Brief (≈400 words + video)

My project meets all of the basic and advanced requirements set out in the 2026 SEC brief. The aim of my artefact is to monitor environmental conditions in a forest-like environment, calculate wildfire risk, simulate drought, and automatically react to dangerous conditions using an adaptive feedback mechanism.

Embedded System Inputs & Outputs

• Digital Input: A push-button is used to calibrate the system at startup.
  
  

• Analogue Input: A soil-moisture sensor connected to pin0 provides analogue readings (0–1023). This represents dryness of forest floor material.
  
  

• Analogue Input: The built-in micro:bit temperature sensor gives temperature readings in °C.
  
  

• Analogue Input: A light sensor (pin1) measures brightness to simulate solar heating.
  
  

• Output: A buzzer on pin2 activates when the system detects high wildfire risk.
  
  

Automatic Operation

Once powered and calibrated with the digital button, the system records sensor values every 60 seconds automatically. The device does not require user intervention after calibration.

Data Collection

Each reading is appended to a CSV file containing:
timestamp, temperature, soil moisture, light level

This CSV file is later imported into the Python component of my artefact for modelling and scenario analysis.

Simulation of Real-World Process

The embedded system simulates a drought cycle by gradually reducing the moisture value each minute if real moisture is not increasing. This mimics the drying of forest litter in warm, sunny conditions.

Python Disaster Risk Model

I created a Python model that calculates wildfire risk using a weighted formula that combines temperature, soil moisture, and light. The result is a risk score between 0 and 1, where 1 = extreme risk.

What-If Scenarios

1. Temperature +3°C
   Increasing temperature across the dataset showed a 41% average increase in fire risk.
   
   

2. Moisture –40%
   Reducing soil moisture caused a dramatic increase in calculated risk (approx. +58%).
   
   

Adaptive Feedback

If wildfire risk exceeds 0.7, the buzzer activates automatically and remains active until risk decreases. This satisfies the SEC requirement for an adaptive system that responds to changing environmental conditions.

2. Investigation (≈400 words)

Forests worldwide are becoming increasingly vulnerable due to climate change. According to the Irish Forest Strategy (2023), drought, high temperatures, and reduced rainfall significantly increase fire probability. Research by the European Environment Agency shows that soil moisture and temperature are the two most reliable predictors of wildfire ignition.

I also explored international research from the Climate Council (Australia) which highlights that periods of high sunlight and heat accumulation dramatically reduce moisture in forest litter. This supported my decision to include a light sensor in my system, as light intensity loosely correlates with solar radiation.

To understand real-world sensing systems, I reviewed multiple existing solutions:

• Bosch Early Forest Fire Detection Sensors
  These use UV and infrared readings to detect fire signatures.
  
  

• WWF Early Warning Systems
  These rely on humidity, temperature, and moisture sensors placed throughout forests.
  
  

• UCD Soil Moisture Monitoring Network
  Demonstrates the importance of constant soil monitoring for ecological prediction.
  
  

From these studies, I learned that simple models can still provide valuable insights. Since machine learning models are beyond the scope of LC Computer Science, a weighted linear model is more transparent and easier to justify.

I also researched microcontroller weather stations including the Micro:bit weather station project. This demonstrated how to record and store sensor data in CSV format, which I adapted for my own system.

My research led directly to my design choices:

• Soil moisture as the primary analogue input
  
  

• Temperature as a secondary risk indicator
  
  

• Light as an environmental stress factor
  
  

• A Python model based on weighted risk factors
  
  

• A buzzer as a simple, effective alert system
  
  

This research ensured that my artefact aligned with real methods used in forest monitoring and environmental prediction.

3. Plan & Design (≈600 words)

Design Objectives

My main objectives were to:

1. Build a functional embedded system capable of collecting and storing environmental data.
   
   

2. Simulate drought conditions through data processing.
   
   

3. Create a Python model that calculates wildfire risk.
   
   

4. Test two what-if scenarios.
   
   

5. Implement an adaptive feedback mechanism that triggers an alarm during high risk.
   
   

Options Considered (and Justification)

Microcontroller Options

• Arduino Uno: Good analogue support but requires additional modules for storage.
  
  

• Raspberry Pi Pico: Powerful but more complex for beginners.
  
  

• Micro:bit: Built-in sensors, analogue pins, easy CSV writing, ideal for rapid prototyping.
  
  

Final Choice: Micro:bit — simplest and meets all brief requirements.

Sensor Options

• Moisture Sensor: Chosen because research shows moisture loss is the top fire predictor.
  
  

• Temperature Sensor: Built-in; gives accurate ambient measurements.
  
  

• Light Sensor: Measures brightness to simulate solar intensity.
  
  

Outputs

• LED: Considered, but a buzzer provides clearer alarms.
  
  

• Buzzer: Chosen for adaptive feedback due to its audibility.
  
  

Stakeholders and End Users

Possible users include:

• Park rangers
  
  

• Farmers
  
  

• Forestry workers
  
  

• Environmental agencies
  
  

• Wildlife conservation teams
  
  

They need early warnings of wildfire risk to protect people, land, and habitats.

Technologies Used

• Hardware: Micro:bit, moisture sensor, light sensor, buzzer, breadboard.
  
  

• Software: MicroPython for embedded system, Python (pandas) for modelling.
  
  

• Tools: CSV for data storage; HTML/CSS for report structure.
  
  

System Architecture Diagram

               +------------------------------+

                |      Embedded System         |

                +------------------------------+

                | - Moisture Sensor (A0)       |

                | - Temperature Sensor         |

                | - Light Sensor (A1)          |

                | - Button (D0)                |

                +-------------+----------------+

                              |

                    Data stored in CSV

                              |

                              v

                +------------------------------+

                |        Python Model          |

                +------------------------------+

                | Loads CSV data               |

                | Calculates fire risk         |

                | Runs what-if simulations     |

                +-------------+----------------+

                              |

               +--------------+---------------+

               |                              |

               v                              v

    +--------------------+     +---------------------------+

    | What-if Scenarios  |     | Adaptive Feedback (Alarm) |

    +--------------------+     +---------------------------+

High-Level Flow Description

1. Sensors read real-time values.
   
   

2. Data logged into CSV every 60 seconds.
   
   

3. Python imports CSV and calculates risk.
   
   

4. What-if scenarios adjust variables.
   
   

5. If risk > 0.7 → buzzer activates automatically.
   
   

This design aligns with all SEC requirements.

4. Create (≈800 words)

Development Process

Milestone 1 — Sensor Testing
I began by testing each sensor separately using MicroPython. Moisture values ranged from 300–900 depending on soil wetness. Light values ranged from 0–1023. Temperature values ranged from 17–21°C indoors.

Milestone 2 — Embedded System Logging
Next, I wrote a loop that captured sensor readings and appended them to data.csv. I verified that each reading was logged correctly by opening the CSV file in Notepad.

Milestone 3 — Simulation of Drought
I implemented a simple drought simulation: if moisture values stopped increasing, the system applied a drying factor of −1 per minute to mimic dry conditions.

Milestone 4 — Python Model
I loaded the CSV data into pandas. I created a wildfire_risk() function:

score = (0.5 * temp_norm) + (0.3 * moisture_norm) + (0.2 * light_norm)

Temperature contributes most to risk because temperature strongly affects drying and fire ignition.

Milestone 5 — What-If Scenarios

• Scenario 1: Increased temperature by 3°C
  
  

• Scenario 2: Decreased moisture by 40%
  
  

I recalculated risk for each scenario and compared averages.

Milestone 6 — Adaptive Feedback
Using fresh sensor readings, if risk > 0.7, my Micro:bit activates a buzzer. This is fully automatic and meets the SEC brief requirement.

Testing

Sensor Tests
I placed the moisture sensor in:

• Dry soil (280–350)
  
  

• Damp soil (550–650)
  
  

• Water (900+)
  
  

Model Testing
I manually checked the formula by plugging in known sensor values to confirm the output stayed within 0–1.

What-If Testing
Testing showed:

• Temperature +3°C increased risk by ~41%
  
  

• Moisture –40% increased risk by ~58%
  
  

Adaptive Testing
I artificially set temperature = 40°C and moisture = 100 to simulate extreme conditions. The buzzer activated immediately.

Problem Encountered & Solution

Problem:
CSV file occasionally saved duplicate lines because the micro:bit loop ran faster than expected.

Solution:
I added sleep(60000) to ensure readings were taken once per minute.

Description of Model Algorithm

1. Normalise inputs:
   
   

   • Temperature scaled from 5–30°C → 0–1
     
     

   • Moisture inverted (dry = high risk)
     
     

   • Light scaled 0–500 → 0–1
     
     

2. Weighted sum of factors.
   
   

3. Clamp final result between 0 and 1.
   
   

4. Use real + simulated values during scenarios.
   
   

5. Trigger buzzer when risk > 0.7.
   
   

5. Evaluation (≈300 words)

Strengths

The system’s greatest strength is its simplicity and reliability. Sensor readings were consistent, and the CSV file provided a clear historical dataset. My Python model produced realistic risk values that increased sensibly under high temperature or low moisture. The what-if scenarios clearly demonstrated how environmental changes affect wildfire probability.

The adaptive feedback mechanism worked effectively. After calibration, the system operated entirely automatically, which shows good real-world applicability.

Limitations

The moisture sensor suffered from electrical noise. I solved some of this by averaging readings, but fluctuations still occurred. Additionally, the weighted model is a simplification of a complex natural process. It does not consider humidity or wind, which are important factors in real wildfire spread.

The light sensor measured brightness but not UV or infrared radiation, which would have been more realistic indicators of fire risk.

Improvements

If I continued this project, I would add:

• A humidity sensor
  
  

• A dedicated UV/IR fire detector
  
  

• A graphical dashboard to view risk trends
  
  

• A more advanced risk model, possibly trained on real wildfire datasets
  
  

• Wireless communication between sensors and a central monitoring station
  
  

Despite limitations, the artefact met all project requirements and provided a functional early-warning demonstration system.

6. References

(Example only)

• Irish Forest Strategy (2023)
  
  

• WWF Early Warning Systems
  
  

• Bosch Forest Fire Detection Sensors
  
  

• Teagasc Forestry Articles
  
  

• Micro:bit Weather Station Documentation
  
  

• ChatGPT (for explanation and planning support)
  
  

7. Word Count Summary

Section

Word Count

1. Meeting the Brief

395

2. Investigation

402

3. Plan & Design

614

4. Create

798

5. Evaluation

290

Total

2,499

Here are fully aligned project ideas, with a different idea for each environmental list from the SEC coursework.
Every idea fits the brief exactly and can be built using Micro:bit / Raspberry Pi Pico / Arduino + Python modelling.

All ideas are directly connected to the environmental themes stated in the official coursework document.

🌲 1. Project Ideas Based on Environmental Threats

(Climate change, wildfires, biodiversity loss, droughts, temperature rise, disease)

Idea 1 — Forest Microclimate Watchdog

• Sensors: temp, humidity, soil moisture
  
  

• Model predicts heatwave stress in trees
  
  

• Adaptive feedback waters a plant or triggers a cooling fan
  
  

• What-if simulations: temp up 2°C, humidity down 20%
  
  

Idea 2 — Biodiversity Collapse Early Warning System

• Embedded system counts simulated “species” using light or motion triggers
  
  

• Python model predicts population decline
  
  

• Adaptive feedback: LED turns red if population is too small
  
  

• What-if: predator population doubles, pollinator population halves
  
  

Idea 3 — Tree Disease Stress Detector

• Moisture + light + temperature used to infer stress levels
  
  

• Model predicts early warning signs of tree disease
  
  

• What-if: lower rainfall, higher humidity, shaded canopy
  
  

🌱 2. Ideas Based on Environmental Data Types

(Soil moisture, light, temperature)

Idea 4 — Smart Soil Moisture Monitoring Network

• Embedded system logs moisture levels in real time
  
  

• Python predicts drought stages
  
  

• What-if: rainfall decrease, irrigation increase
  
  

• Adaptive: water pump turns on when moisture < 300
  
  

Idea 5 — Light vs. Temperature Heat Stress Simulator

• Light + temperature logged
  
  

• Python model calculates heat stress index
  
  

• What-if: canopy removed vs. canopy added
  
  

• Adaptive: shade screen motor lowers when temp too high
  
  

Idea 6 — Daily Forest Energy Balance Model

• Collects light & temp to simulate forest floor energy gain
  
  

• Python predicts drying of leaf litter
  
  

• What-if: cloudy vs. sunny scenarios
  
  

🌳 3. Ideas Based on Real-World Forest Process Simulations

(Canopy cover, drought cycles, biodiversity changes, population cycles, wildfire risk)

Idea 7 — Canopy Cover Simulator Using Light Sensors

• More light = less canopy
  
  

• Embedded system tracks light intensity
  
  

• Python model estimates canopy percentage
  
  

• What-if: storm damage (canopy reduction), replanting (increase)
  
  

• Adaptive: LED alerts when canopy is too low
  
  

Idea 8 — Drought Cycle Emulator

• Moisture falls over time
  
  

• Python model calculates drought severity index
  
  

• What-if: rainfall events added, extended dry periods
  
  

• Adaptive: pump activates if drought reaches severe
  
  

Idea 9 — Predator–Prey Forest Model

• Simple embedded system simulates or counts “animals”
  
  

• Python runs a population model (like a simplified Lotka–Volterra)
  
  

• What-if: predator removal, prey boom
  
  

• Adaptive: alarm if either population collapses
  
  

Idea 10 — Wildfire Risk Estimator (Classic)

• Temp + moisture + light → risk score
  
  

• What-if: hotter climate or reduced moisture
  
  

• Adaptive: buzzer when risk > 0.7
  
  

🌧️ 4. Ideas Based on Disaster Risk Modelling Topics

(Wildfire, drought, pests, air quality, landslides, flooding)

Idea 11 — Flood Sensor & Runoff Predictor

• Water-level sensor + rainfall (button as rain trigger)
  
  

• Python predicts time to flooding
  
  

• What-if: heavier rainfall, blocked drainage
  
  

• Adaptive: buzzer when flood risk high
  
  

Idea 12 — Pest Outbreak Predictor

• Temperature + humidity used to estimate pest conditions
  
  

• Python model predicts pest population boom
  
  

• What-if: warmer weather, lower humidity
  
  

• Adaptive: LED alerts when pest risk > threshold
  
  

Idea 13 — Air Quality Monitor for Forest Smoke

• Gas sensor or simulated input
  
  

• Model predicts health risk index
  
  

• What-if: wildfire smoke event added
  
  

• Adaptive: fan or buzzer triggers
  
  

Idea 14 — Landslide Slope Stability Monitor

• Tilt sensor simulates slope angle
  
  

• Moisture sensor indicates soil saturation
  
  

• Python model predicts stability
  
  

• What-if: heavy rain vs. dry spell
  
  

• Adaptive: alarm when slope becomes unstable
  
  

🌦️ 5. Ideas Based on What-If Scenario Examples

(Temp ↑, rainfall ↓, canopy ↓, tree density ↑, species changes)

Idea 15 — Temperature-Driven Plant Stress Predictor

• Temp sensor logs data
  
  

• Model shows how heatwaves affect plant moisture
  
  

• What-if: +3°C, +5°C
  
  

• Adaptive: shade cover activates
  
  

Idea 16 — Rainfall Reduction Water Budget Model

• Moisture logged over time
  
  

• Model estimates forest water budget
  
  

• What-if: rainfall -30%, -50%
  
  

• Adaptive: pump simulation regulates water
  
  

Idea 17 — Afforestation vs Deforestation Simulator

• Light sensor indicates canopy cover
  
  

• Model estimates carbon storage & biodiversity levels
  
  

• What-if: high tree density vs low tree density
  
  

• Adaptive: indicator shows “healthy / stressed ecosystem”
  
  

Idea 18 — Species Imbalance Predictor

• Buttons simulate predator/prey population inputs
  
  

• Python model calculates ecological balance
  
  

• What-if: too many predators, too few pollinators
  
  

• Adaptive: alarm if ecosystem collapses
  
  

🌎 6. Ideas Based on Ecosystem Context Themes

(Carbon storage, water regulation, climate regulation, species populations)

Idea 19 — Forest Carbon Storage Estimator

• Use light + moisture to model forest productivity
  
  

• Python estimates carbon stored in vegetation
  
  

• What-if: canopy loss decreases carbon storage
  
  

• Adaptive: indicator warns of low carbon gain
  
  

Idea 20 — Forest Water Cycle Monitor

• Moisture + rainfall button
  
  

• Model tracks soil-water balance
  
  

• What-if: increased temperature → higher evaporation
  
  

• Adaptive: system irrigates automatically
  
  

Idea 21 — Forest Climate Regulation System

• Temp + light readings
  
  

• Model shows how canopy affects cooling/shading
  
  

• What-if: canopy removed or restored
  
  

• Adaptive: fan activates if temperature too high
  
  

Idea 22 — Species Population Health Dashboard

• Embedded system simulates species presence
  
  

• Python calculates population stability index
  
  

• What-if: loss of pollinators, disease outbreak in herbivores
  
  

• Adaptive: warning system when biodiversity drops too low
  
  

⭐ Total: 22 Unique Project Ideas