Year 12 HSC Design and Technology MDP

Support
1

Hello,

My name is Lyla Nardo, and I’m a Year 12 Design and Technology student working on my Major Project. I’m exploring the design of a haptic feedback steering wheel cover that provides tactile warnings to drivers when they are exceeding the speed limit. The intention is to create a system that supports driver awareness in a non-visual, non-auditory way — allowing the driver to keep their eyes on the road and reduce cognitive overload.

The inspiration for this idea came from my experience as a learner driver, where I found myself paying too much attention to the speedometer rather than the road. I wanted to explore whether a more intuitive, tactile form of feedback could help address this.

I’m also aware that similar driver-assistance features exist in many newer cars, but from my research so far, I haven’t been able to find any accessible or retrofit solutions for older vehicles. That’s something I’m interested in exploring further through this project.

The current concept involves a modular system with three main components:

  • A vision system that detects speed limit signs in real time
  • A processing unit that interprets this data and compares it to vehicle speed
  • A haptic feedback system (vibration motors embedded in a steering wheel cover) that alerts the driver when speeding

In early research and prototyping planning, we’ve been investigating different technical approaches. Initially, we considered using an Arduino for the entire system, but identified that it is not suitable for real-time vision processing. From there, we explored a more distributed system using:

An Arduino (or similar microcontroller) to control the haptic feedback
A separate vision-capable device (such as a Raspberry Pi or an AI camera like the OAK-1) to handle image processing and AI inference

We’ve also been looking into tools like Codex to support development, particularly for Python-based vision processing and microcontroller integration. At this stage, I’m aiming to use existing pre-trained models for traffic or speed sign detection rather than training a model from scratch.

I should also mention that I’m very new to electronics and programming, so I’m trying to design a solution that is realistic for my experience level. I’m particularly interested in approaches that are well-supported, beginner-friendly, and where AI tools can help do a lot of the heavy lifting in terms of coding and implementation.

I’m reaching out to see if you might be able to offer any advice around:

  • The feasibility of this system architecture
  • Suitable hardware choices for a project at this scale and experience level
  • Any considerations around real-world implementation, safety, or reliability
  • Or any general guidance you think would be valuable at this early stage

I’d really appreciate any insights you’re able to share, as I’m trying to ensure the project is both technically sound and grounded in real-world engineering practices.

Am I on the right track with my hardware decisions, if not any advice on this would be greatly appreciated?

1 Like
2

Hi Lyla,

Welcome to the forum! What an amazing project, and building it with a first hand problem in mind will make it so much easier :smiley:

A quick preface:
I’d treat it as a proof-of-concept only, not something to rely on in a real car. Any automotive grade system has to undergo a very comprehensive compliance process, making that known in your portfolio ought to get you some points.
Some reasoning:
Vision-based speed sign detection can miss signs, misread temporary signs, or struggle with lighting, rain, glare, occlusion, and roadside clutter. If you frame that as a design limitation and engineering consideration, that’s actually strong project thinking.

I’d also be careful around vehicle integration. For safety, I would not tap into fixed vehicle wiring or steering systems for a build. A bench prototype or demo rig would be a much safer way to validate the concept. You could simulate vehicle speed in software or with a knob/slider and show how the haptic response changes when the detected limit is exceeded.

Back to the project (and not spoiling too much)

Keeping the hardware (and software) modular is a great idea, it should save time when developing and debugging.
The dual system with a microcontroller and computer might prove difficult to get reliable, but using the Pi’s GPIO ought to be enough for basic alerts? Is there any particular feature you would be looking to use in a microcontroller?

A pre-trained model for vision is definitely the way to go. Working backwards from this would be a great starting point)

When developing with AI or LLM’s make sure you can still interrogate the code, and understand what is happening - from high-level systems to low-level implementation.

We’re happy to answer some more in-depth questions, narrow down part selection - but given the fact its a major work, adding some detailed requirements for those parts will net you more marks.

PS: popping these resources here if you haven’t come across them, at least they will all be here!

https://core-electronics.com.au/projects/vehicle-gps-logger-and-speedometer/ and https://core-electronics.com.au/projects/3d-printed-gps-speedometer/

3

Ha ! The biggest difference I noticed when moving from New Zealand was how frequently the speed limit in Sydney changes; and how many road signs compete for drivers attention. Got me also thinking that a dashboard mounted vision system to detect and remember speed limit signs would be useful. Mind you that was … lets see, 25 years ago … before even the original Raspberry Pi. Since then I have thought of it several times … but got used to driving in Australia - so no longer a priority :wink:

  1. vision has drawbacks as Liam mentioned. Also note that signs are not located at the same angle, so you will need a fairly wide-angle lens; and that the size of the signs will increase rapidly as you approach.
    Try mounting a mobile phone on the dash and recording the view to the left (where the speed signs should be) as you drive. Play the video and notice how different it looks. We don’t realise how wonderful our eyes and brain are at focusing on the “important” elements from what we see.
  2. I have noticed vehicle GPS systems which can inform the current speed limit - which I assume is stored as part of their database. Possibly using GPS might be an alternative (or backup) way to get the current speed limit.
  3. For determining current vehicle speed, a GPS could be worth considering. Alternatively I expect that an ODBC-II (On Board Diagnostics standard that is used on most cars) adaptor interface should include vehicle speed - though this looks as though it opens another interfacing challenge.
  4. Raspberry Pi are great little machines (I have 4) … but since the chip shortages during covid they seem very expensive in Australia, especially if you add a HAT or two. There are several other similar Single Board Computers which also run linux OS (so large software base) - or you might find that doing both AI for basic vision processing and AI for speed sign detection is too much for a small machine.
    You might also consider using a mobile phone instead of raspberry Pi - it also has CPU, camera and memory built-in, and also has extensive software to build on.
1 Like
4

Hey @Lyla318697,

Just throwing out another idea that would get a prototype going and might be a tad easier and more reliable. Most state governments provide an up-to-date database of every road and its speed limits. You would then just have to download it, and get an inexpensive GPS module to figure out which road you are one. It is a little easier said than done, but just throwing out another approach!

  1. Download the road speed limit data from your local state government; they offer this for free and it’s only a few mb. One with GPS coordinates associated with it would be great. You should be able to download this on a Raspberry Pi and run it all offline. I have done similar things and have been able to run it on a microcontroller like an ESP32, but that was quite tricky to shrink it all down to work on it.

Another map option is a wonderful open source project called OpenStreeMap. It’s like a community-made rival to Google Maps, and it has speed limits in it. If you are in a major city, it is likely pretty good, but in a regional town it might not have the speed limit data.

  1. Get a GPS module. You can start with an inexpensive one for testing, and nab a more expensive and accurate one later if needed. Or you can write the code and create a way to input a dummy GPS coordinate for testing.

  2. Take your GPS coordinate, and use it to find which road you are on. This might be the hardest part, but it is a common enough problem that there is a lot of info about it (and ChatGPT can help write this). You are chasing something called a “map matching algorithm”.

  3. Just compare the road you are on to the speed limit and vibrate the wheel!

Again, just throwing it out here as another way to do the project.

Best of luck!

1 Like