QH-832AC Door-bell modding

In a search for a cheap 433 MHz wireless doorbell I came upon the Quhwa QH-832AC aka QH-C-CE-3V, aka SelectPlus, aka. 1 by One in a local thrift shop (“Action”). It exists in Black and in White.
I wanted my Arduino to be able to receive the signal from the push-button so it could undertake any action necessary when someone would ring the bell (such as switch on a light, release the hounds or whatever).
My usual approach with a new 433 MHz RF device is that I use some kind of sniffer program in my Arduino and try to gather raw data from the transmitter. My standard programs didn’t really work and another program I found gave me some data that I couldn’t really work with, so i was at a loss there.
Searching internet brought me to much interesting info about the SelectPlus, but one site gave me some useful information: Voyager describes a plug-in he wrote for the Nodo and also this site gives valuable information..
I now knew it was a 36 pulse code, possibly with a pre-amble and probably repeated a couple of time. A friend with an analyzer helped me out.
The version I have is the White one with a datecode of 914. If I consider a  short puls (250-275u sec) as a ‘1’ and a long pulse (950-1000 u sec) as a ‘0’, then the pulse train is:
10101100101011001011001101010101010. That is the ‘RAW’ code. As I only had 35 pulses with the first one  actually a bit longer than a ‘short’ and a bit shorter than a ‘long’, that might have been just a preamble.
Converting the code to bits went as follows:

1 01 01 10 01 01 01 10 01 01 10 01 10 10 10 10 10 10
? 1 1 0 1 1 1 0 1 1 0 1 0 0 0 0 0 0

I presumed the first ‘1’ to be a preamble of some sort, or it could in fact be a ’01’.
Anyway the binary code converted to hex is as follows 11011101101000000  => 1BB40. However, if I presume that first preamble to be a ’01’ the address is 3BB40
When I did the same exercise for the black button that gave 11100001100110000  => 1C330 or 111100001100110000=3C330
It seems that the first 13 (14) bits are a unique bell identifier and the last 4 bytes have no specific meaning.

As I find making a send program a little bit easier than a receive program, I  first  focussed on that. These send programs are in fact not so difficult: they  go through the  specific code bit by bit and then send that with the specific pulse width.
When I would use the code 1BB40 and use that to program the doorbell (“Program” meaning unplug the chime and replug it an then send the code), I could get it to work from my Arduino, but it would not respond to the bell button. If I would programit with the bell button it would only sometimes respond to the arduino code.
If I used the 3BB40 code, it would work both ways

const byte rfPin=7;

void setup()
SelectPlus(0x3BB40);// White
//SelectPlus(0x3C330);// Black

void loop()
//SelectPlus_Send(0x3BB40);// 11 1011 1011 0100 0000
void SelectPlus(uint32_t address) {
    int pulseWidth= 325;// Pulse width in uS
    byte repeat = 16;   //  repeat send   
    uint32_t databit;
    uint32_t mask = 0x10000; //0x20000;
    uint32_t sendbuff;

    for (byte j = 0; j <= repeat; j++) {
        // send 3 HIGH pulses for syncing
        digitalWrite(rfPin, HIGH);
        delayMicroseconds(pulseWidth * 3);
        // Send command
        for (int i = 0; i < 18;i++) {  // 18bits

        databit = sendbuff & mask;
// databit=11 1011 1011 0100 0000 & 0x20000
// databit=11 1011 1011 0100 0000 & 10 0000 0000 0000 0000 
// databit=10 0000 0000 0000 0000
sendbuff = (sendbuff << 1);// Shift left 
// sendbuff=   11 1011 1011 0100 0000 <<1
// sendbuff=(1)11 0111 0110 1000 0000
if (databit != mask) // it is at the 4th cycle of the loop
{ // Write 0 
digitalWrite(rfPin, LOW); 
digitalWrite(rfPin, HIGH); 
delayMicroseconds(pulseWidth * 3); 
{ // Write 1 
digitalWrite(rfPin, LOW); 
delayMicroseconds(pulseWidth * 3); 
digitalWrite(rfPin, HIGH); 
digitalWrite(rfPin, LOW); 
delayMicroseconds(pulseWidth * 16); 
'0':     _|   |   (T,3T)
'1':     ___| |    (3T,T) 

Normally this chime will reset itself if unplugged from the mains. After replugging it just waits for the first bel signal to tune into that. I discovered however that if I had the chime programmed for the White code, but I would send the black code some 3-4 times without  replugging it, it would react to the black code and not to the white code, though strangely it still would react to the white button. If I then would send the white code a couple if times it would pick up on that code again and not seldom it would stick, meaning it would react to both the black AND the white code. Obviously this chime still holds a couple of mysteries in its code that I haven’t discovered yet
As I didn’t feel like figuring out yet how my Arduino could receive the code from the wireless button, I decided to do some hardware modification for fun:
On the PCB there are two LEDs printed on the silkscreen. These LEDs seem to be in parallel, so it is sufficient to solder in only one. A small hole in the  cover for it to stick through and voila, an optical signal added. Handy for deaf people

30 thoughts on “QH-832AC Door-bell modding”

  1. As you are an expert on this device I have the following question: we have a doorbell with a terrible sound so I want to use the chime in combination with the QH-C-CE-3v (Rev10). I noticed that the chime sometimes reacts if I make a connection between the holes marked SW2 or near the pushbuttom or the hole R6 with the hole C2. The LED lights up but most of the times no sound. Any suggestions?

    1. Thanks for the compliment but I would hardly call myself an expert. Anyway I will see what I can do, but first I need some clarification as it is not exactly clear to me what you want. You want to replace your doorbell as it has a horrible sound, but then what is it you still want to do with the existing doorbell and chime ‘in combination with the QH-C-CE’? Do I understand correctly that you want to use yr existing pushbutton to actually make the connection on the QH-C-CE’ pushbutton and now u are looking for the proper place to make that connection?

      1. That is correct. I have an Urmet962 doorbell videosystem. When someone pushes the button the Bell rings and I can see this person in the monitor. The existing Bell can be switched off. Inside are many connections. I found two points with a 11-12 voltage dc. Between these points this turns to zero When the Bell ring. Maybe I can do something with this.

      2. the problem is that the button of the URMET carries a voltage that is likely different from the QH as it is still in circuit. A simpel connection of the one button to the other is therefore bound to cause problems as you are basically connecting two different circuits.
        You have several options:
        1 disconnect any circuit connection to yr URMET button and then wire that up in parallel to the QH, but that makes the original function void.
        2 forget about the QH and just wire up another buzzer/bell to yr Urmet that has a pleasant sound
        3 seperate the two button circuits with an optocoupler
        the latter might be the simplest to try. I havent really looked at the circuit around the button itself but if in open state you measure what pole hasthe lowest voltage, connect the emitter of say a 4n25 to that and connect the other pole to the collector.

        Put some 5 volt on the primary side via a 330 ohmresistor and see what that does. If that works thenjust find a point in yr Umet circuit where u can pick up a voltage upon pressing the button

      3. if u have a point in yr urmet system that have 11-12 Volt that drops to 0 when the bell rings, you could attah a seperate bell there throughan inveter. You could do this with a PNP transistor

  2. Have you had any time to figure out the wireless button? I’m working on a project where I want to switch a led strip on and off but I can’t wrap my head around the wireless button.

    1. Well, yes and no. I know the code-as i can send it- but I havent written it into a receive routine yet. As a matter of fact I was just looking at it again. Just need som etime

    2. misschien ben je geholpen met dit stukje code dat ik ergens tegenkwam (maar wellicht had je dat al gevonden). Heb nog geen tijd gehad ernaar te kijken:
      //########################### Plugin-44 Select Plus Wireless Doorbell ###################################
      * This Plugin takes care of reception of the Select Plus wireless doorbell
      * PCB markings: Quhwa QH-C-CE-3V aka QH-832AC.
      * Also sold as “1 by One” wireless doorbell.
      * Auteur : William Jansen (Voyager)
      * Support : http://www.nodo-domotica.nl
      * Datum : 2-1-2015
      * Versie : 1.0
      * Nodo productnummer : n.v.t. meegeleverd met Nodo code.
      * Compatibiliteit : Vanaf Nodo build nummer ???
      * Syntax : “SelectPlus , ”
      * Changelog: v1.0 initial release
      * Technical information:
      * Each frame is 35 bits long. It is composed of:
      * 101011001010110010110011010 10101010
      * The first block appears to be an unique ID
      * The second block appears to be some kind of identifier which might always be 0xAA (10101010)
      #define PLUGIN_ID 44
      #define PLUGIN_NAME “SelectPlus”

      byte Plugin_044_ProtocolCheckID(byte checkID);

      byte Plugin_044_ProtocolValidID[2];
      byte Plugin_044_ProtocolVar[2];
      void setup() {
      // put your setup code here, to run once:


      void loop() {
      // put your main code here, to run repeatedly:


      boolean Plugin_044(byte function, struct NodoEventStruct *event, char *string)
      boolean success=false;

      #ifdef PLUGIN_044_CORE
      if (RawSignal.Number !=SELECTPLUS_PULSECOUNT) return false;
      byte basevar=0;
      unsigned long bitstream1=0; // holds first 10 bits
      unsigned long bitstream2=0; // holds last 26 bits
      byte checksum=0;
      byte bitcounter=0; // counts number of received bits (converted from pulses)
      // get bytes
      for(byte x=1;x 750) {
      if (bitcounter < 27) {
      bitstream1 = (bitstream1 << 1);
      bitcounter++; // only need to count the first 28 bits which appear to be the unique bell number
      } else {
      bitstream2 = (bitstream2 < 0x55
      } else {
      if (bitcounter < 27) {
      bitstream1 = (bitstream1 << 1) | 0x1;
      } else {
      bitstream2 = (bitstream2 < 0xAA
      Serial.print(” ID=”);
      Serial.print(” CRC=”);
      basevar = Plugin_044_ProtocolCheckID(bitstream1);

      event->SourceUnit = 0; // Komt niet van een Nodo unit af, dus unit op nul zetten
      event->Port = VALUE_SOURCE_RF;
      event->Type = NODO_TYPE_PLUGIN_EVENT;
      event->Command = 44; // Nummer van dit device

      if (basevar == 0) return true;
      success = true;
      case PLUGIN_COMMAND:
      if ((event->Par2 > 0) && (Plugin_044_ProtocolCheckID(event->Par1) == 0))
      for (byte x=0; xPar1;
      Plugin_044_ProtocolVar[x] = event->Par2;
      #endif // PLUGIN_044_CORE

      #if NODO_MEGA
      case PLUGIN_MMI_IN:
      char *TempStr=(char*)malloc(INPUT_COMMAND_SIZE);

      if(event->Par1>0 && event->Par1Par2>0 && event->Par2Type = NODO_TYPE_PLUGIN_COMMAND;
      event->Command = 44; // Plugin nummer

      case PLUGIN_MMI_OUT:
      strcpy(string,PLUGIN_NAME); // Eerste argument=het commando deel
      strcat(string,” “);
      #endif //NODO_MEGA
      return success;

      #ifdef PLUGIN_044_CORE
      * Check for valid sensor ID
      byte Plugin_044_ProtocolCheckID(byte checkID)
      for (byte x=0; x<5; x++) if (Plugin_044_ProtocolValidID[x] == checkID) return Plugin_044_ProtocolVar[x];
      return 0;
      #endif //CORE

      1. Nu ik er even naar kijk had ik deze ook al gevonden maar kon er op dat moment weinig van maken. Wel dan proberen we het nog eens!

      2. de code compileert, ik moet enkel even uitzoeken hoe ik hem moet aanroepen. Als ik er aan toe kom laat ik het je weten. Mocht jij het ontdekken dan hoor ik het ook graag

      3. Tom, I came abit further.
        For one thing I discovered a mistake in my bellbutton address. What I thought to be a ‘preamble’ (the isolated ‘1’ pulse) is in fact a ’01’ and therefore translates as a ‘1’. With that the address becomes 3BB40 rather than 1BB40. I previously had my bell working when I programmed it with my arduino on ‘1BB40’ but it wouldnt work with the button then. When I use ‘3BB40’ it works from the knob as well. So that is 18 bits (36 pulses) that need to be sent (and received)
        Apparently the bell itself works on a variety of codes.
        So now it is a matter of writing a receive routine that checks that code

      4. Tom, er is klaarblijkelijk een library https://github.com/bremme/Arduino voor deze deurbel.
        Ik krijg daarmee wel mijn bel aan het rinkelen, maar omdat de bel van de maker toch een andere code heeft, krijg ik de knop nog niet gedetecteerd. En eerlijk gezegd zie ik nog niet waar hij zijn code in het programma heeft staan. (ik zie nu dat hij waarschijnlijk de ontvangen code beschikbaar maakt voor een check)
        Als je met de library aan de gang gaat, een paar van de examples doen het niet, kijk voor voorbeelden in het readme document

    1. Thanks. Somehow your post ended up in my spam box but fortunately I caught it.
      Also, I found the codes 3BB40 rather than 1BB40 and 3C330 rather than 1C330. To work better

  3. Ah handig! maar het lijkt me dat je de code niet kan aanpassen dus hoe weet hij dan of het een zwarte bel is of een witte. Ik zal later even in de code kijken en eventueel eens zelf testen! alvast bedankt voor alles!

    1. voor zover ik begreep stuurt hij de ontvangen code en kun je dus daar op checken. Echter mijn witte bel ontvangt hij niet… althans geeft daar niks van door.
      Me dunkt dat er meer codes zijn dan alleen de witte of de zwarte. Het heeft denk ik meer te maken met de productierun, dat ze zeg om de maand een batch maken met een nieuwe code

  4. Bedankt voor de feedback, ik zal deze codes een uitproberen en eventueel aanpassen als ze beter werken. Als ik wat tijd heb, voorzie ik een config file zodat je de code zelf kan aanpassen. Omdat het bij mij niet altijd werkte met de oude codes heb ik “repeat” aangepast naar 40, daarmee werkt het bij mij altijd.

    Tom: Merk op dat je “./Ring black” of “./Ring white” moet uitvoeren zodra je de deurbel in het stopcontact steekt.

    1. Dank. Het blijft een beetje een vreemde ontvanger. Ik heb zelf gemerkt dat als ik hem programmeer met ‘wit’ en er dan maar vaak genoeg de code ‘zwart’ naar toe stuur, hij plots ook op die code reageert. Soms blijft hij dan op beide codes reageren en soms wordt het er dan maar een.
      Overigens is het me nog niet gelukt de code van de drukknop met een sniffer te detecteren of een arduino erop te laten reageren, hoewel ik de code en de timing toch echt meen te kennen.
      Ik heb trouwens het idee dat per batch niet alleen de code maar ook de timing anders kan zijn.

      1. Het was me ook al opgevallen dat ik zowel wit als zwart kan gebruiken om hem te laten ringen. Misschien heeft dit ook te maken met het SAW (zaag) principe waarop de ontvanger is gebaseerd, ofwel omdat de bel in de eerste minuut in “learning” mode staat. Met sommige RF plugs (bvb Elro) is het me al gelukt om deze te “trainen” met de codes van andere toestellen.

        Mijn doel is eigenlijk het laten reageren van de Pi op de bel (drukknop). Ik heb dus een bestelling geplaatst voor een RF ontvanger, eens ik deze heb ontvangen ga ik hier wat aan sleutelen met deze tool: https://github.com/MPParsley/rpi-433. Hopelijk lukt het daarmee.

      2. ikprobeer dat ook maar nog niet gelukt. Ik noem ergens in mijn comments een library maar die werkt niet voor mij

    1. Ik zag het. Ik realiseerde mij dat er een klein foutje in mijn code zit, dat ook in de jouwe is terechtgekomen, maar vreemd genoeg lijkt de bel er niet zo’n probleem mee te hebben.
      het mask is 0x10000, dat komt goed overeen met de code 1BB40 en 1C330.
      Maar omdat 3BB40 en 3C330 1 bit langer zijn, had ik het mask 0x2000 moeten maken.
      Het werkt natuurlijk, maar feitelijk zend ik vanwege het mask nog steeds 1BB40 en 1c330. Mask zou dus eigenlijk 20000 moeten zijn:
      0011 1011 0100 0100 0000 3b440
      1 0000 0000 0000 0000 10000
      10 0000 0000 0000 0000 20000,
      bij gebruik van mask 0x20000 werken overigens ook weer alle 4 de codes, ook van de bel drukknop.

      Overigens heb ik wel gemerkt dat met het vele testen de bel op een gegeven moment wat in de war kan raken en een reset nodig heeft

  5. Klopt! Bedankt, heb het aangepast.

    Ondertussen eerste proeven gedaan met de RF ontvanger op basis van deze blogpost: http://www.princetronics.com/how-to-read-433-mhz-codes-w-raspberry-pi-433-mhz-receiver/ en deze tool: https://github.com/ninjablocks/433Utils

    Ik krijg succesvolle resultaten voor alle RF apparaten behalve voor de deurbel. Het is me niet heel duidelijk waar het aan ligt; of het nu aan de (goedkope) ontvanger ligt, aan het interval dat anders is of nog iets anders…


  6. Klopt! Bedankt, heb het aangepast.

    Ondertussen eerste proeven gedaan met de RF ontvanger op basis van deze blogpost: http://www.princetronics.com/how-to-read-433-mhz-codes-w-raspberry-pi-433-mhz-receiver/ en deze tool: https://github.com/ninjablocks/433Utils

    Ik krijg succesvolle resultaten voor alle RF apparaten behalve voor de deurbel. Het is me niet heel duidelijk waar het aan ligt; of het nu aan de (goedkope) ontvanger ligt, aan het interval dat anders is of nog iets anders…


    1. Het blijft een enigma. Als je allerlei RF apparaten wel kunt ontvangen zal het probleem denk ik niet enkel aan de ontvanger liggen, tenzij de belknop een geheek eigen modulatie heeft en de bel zelf zeer tolerant is. Ik blijf het proberen

  7. ik heb ook een QH-832AC en wil ook wel wat elektronica eraan vastknopen, maar waar is er een aansluiting naar buiten, ik zie alleen maar een optie voor twee LEDS (parallel), die zou kunnen aansluiten met een optocoupler.

    1. Henk, Ik ken alleen maar de aansluitingen die jij ook noemt. Een optocoupler is inderdaad een goed idee

  8. RFXcom knows this doorbell as “Beyron”. There is a ‘switch 2’ indication on the doorbell print. You can set about 10 alternative connections. by pressing, then shortcutting. The bell is sold in Holland (2018) by Action shops as “selectremote”.

    1. Steve, thanks for your comment, I havent’been paying much attention to this bell for some while, but it remains an interesting item. Action in Holland is exactly where I bought it.
      I was wondering if you could expand a bit on what you say as I am not sure I fully understand it.
      What do you mean with “alternative connections”? I’d be happy to test that a little further

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.