I’ve noticed that nearly 98% of my horn usage is actually for making very quick, short chirps.
Smart BHPian max recently shared this with other enthusiasts.
This thread will detail how I have automated the “Courtesy Horn” or “Friendly Horn” in my car. I got the idea from my daughter – she watched a YouTube video showing the courtesy horn and she asked if I could implement it.
So this is my courtesy horn implementation. I wrote the code for my microcontroller and designed my electronic circuit.
First of all, what is a ‘courtesy horn’?
According to the Western definition, a courtesy horn is used to attract the attention of other drivers in a non-emergency scenario. They are two quick chirps of the horn that sound friendly and not very irritating like a longer or continuous horn.
In the Indian context, this certainly has more use cases. For example, you’re driving down a freeway and you hear the two-wheeled guy in front showing symptoms of an unexpected right turn or lane change. You can then activate it to grab the rider’s attention with two quick chirps instead of a longer horn.
Why automate it?
- First reason: you can always press the horn pad twice in a row with a very short interval in between. However, you will not be able to consistently reproduce the model all the time. Sometimes, you will end up honking a little longer and this will sound irritating to other road users. The horn is a little “hard to press” in many cars and this makes it nearly impossible to always sound a very consistent courtesy horn.
- Second reason: if I can automate it, why not?
I understand that good driving manners include extremely minimal use of the horn. But on our roads, sometimes a car horn can save a life: it can be a distracted driver ahead of you turning right with no indicators or someone crossing the road without checking for oncoming vehicles. The courtesy horn will grab their attention but at the same time won’t be very irritating. I’ve noticed that nearly 98% of my horn usage is actually for making very quick, short chirps.
There may be commercially available trumpet solutions with different types of trumpet designs and sounds, but I did it for the fun and satisfaction a DIY project can give. I hope DIY enthusiasts on the forum find it interesting and useful.
Disclaimer: It is too designed for necessity! The upside is that there is now a microcontroller inside the car, which can also be used for other purposes in the future.
When I started thinking of a solution, the first thing that struck me was the Arduino lying around, unused. So I decided to use it as a controller. As I said in the first post, will this be too engineered a solution for the need? Of course yes. It will be funny? Yup!
The design considerations were:
- The design should have no impact on the functionality of the existing horn. When the horn pad is pressed, the horn should sound as before.
- The project is not expected to introduce new points of failure for existing horn circuits.
- It should not drain the car battery when the car is parked.
This shows a typical horn circuit.
If you were to have a second horn switch for the same horn, without affecting the existing system, here’s how you might get it.
From this, it is very easy to visualize the high-level design of the required system. We just need to display a controller that controls the sub switch, which can produce any model of horn as programmed. In this particular case, the pattern will be the courtesy horn sound: two quick chirps.
This phase has two parts.
- Programming of the microcontroller
- Pilot circuit design to drive the horn relay
Programming of the microcontroller
The microcontroller board I had (Arduino UNO) has several GPIO pins, but for this project we only need to use two pins. One of the pins must be set as the input pin, where the command from the driver’s control button (a tactile switch) must be detected. The other pin will be a digital output pin, which should be used to drive the horn relay.
Since the button press must be detected almost instantly, I decided to use the Arduino’s ISR (Interrupt Service Routine) functionality. ISR will trigger a hardware interrupt to stop whatever the microcontroller is doing, to instantly process the push of the command button. This is essential as the horn should instantly when you press it.
To develop the code, I made a PoC circuit using a breadboard, where the digital output pin directly drives an active buzzer. This gave me the platform to play with while coding the microcontroller.
Here is the final source code, which has gone through a few iterations to refine the delays and timing of the beeps.
Here is a video of how the buzzer circuit worked after this stage.
The horn relay driver circuit
Now, it was time to look at how I’m going to connect the microcontroller with the car’s horn relay system. The car’s electrical system works on a 12 volt system and this also includes the horn relay. Arduino GPIO has a maximum output voltage of 5 volts. Also, the horn relay is grounded and does not expect a voltage to drive it. Instead, it must be grounded to activate the horn. The relay consumed approximately 300-350mA of current when the horn was activated, so the design needed a grounding mechanism capable of handling at least 500mA of current.
This required the design of a driver circuit, which will ground the horn relay with the microcontroller input. Using another relay to drive the horn relay was out of the question as I didn’t want to use a relay to drive another relay. The simplest circuit I could think of was to use a capable PNP transistor that could actually ground the line when its base is grounded. I also wanted to electrically isolate the microcontroller’s GPIO from the driver circuit, so I decided to use a combination of an optocoupler and a transistor.
The idea was to drive the optocoupler from the Arduino’s output line, which in turn will activate the transistor which will ‘ground’ the horn relay line.
The other question concerned the Arduino’s power supply. The documentation says it can work with a 12v input on its Vin pin, however, the car’s battery voltage will rise to more than 14 volts while the engine is running. So I decided to use a voltage regulator to limit the maximum input voltage to the Arduino to 12 volts.
After considering all these factors, here is the final circuit diagram that came to mind. Of course, this took a few iterations on the breadboard to iron out a couple of bugs, including the unpredictable behavior of the touch switch which resulted in an unwanted double trigger. The capacitor placed in parallel with the tactile switch solved this problem perfectly.
A video of the breadboard test.
Read on BHPian intelligentmax’s DIY process for more insights and information.