Tags: IR, Infrared, Wireless, Remote, Control, Module, Kit, HX1838, VS1838, white, arduino, mcu, uae, الامارات,

IR Infrared Wireless Remote Control Module Kit (HX1838 VS1838 ) white

  • 9.00 AED
    • Ex Tax:9.00 AED
    • Product Code: Digital
    • Availability: In Stock
    This is IR Controller (Infrared Remote Control) which you can easily make a remote control projects with it and it's compatible with Arduino's IR receiver, this remote control provides 17 buttons and the flexibility to control devices within a range up to 8m and an effective angle of 60 degrees, com..
    • This is IR Controller (Infrared Remote Control) which you can easily make a remote control projects with it and it's compatible with Arduino's IR receiver, this remote control provides 17 buttons and the flexibility to control devices within a range up to 8m and an effective angle of 60 degrees, compatible to any generic IR receiver.


      Package includes:

      • 1 X IR Remote Control(not contain battery) .
      • 1 X HX1838 remote module.
      • 1 X 1838 Universal Receiving Head.
      • 1 X 3Pin 20cm Dupont cable.

      This Tutorial will help you Decoding Black remote or White remote with Arduino :


      Decoding Any Black remote or White remote with Arduino

      This video shows you how to decode codes of Black Remote or White remote using Arduino. You need to install the library from the provided link. Also you will learn how to decode any remote controller using Arduino.

      In the code you have to select type of your remote. If your remote is black, select 'B' and if your remote is white select 'W' in the code. Also you have select the type of receiver you are using. If you are using PCB version of receiver, then set PCB = 1 and set it =0 if using NON-PCB module.

      Receiver:

      The receiver has the model HX1838 or VS1838B either on PCB or without PCB. In both cases you will see them with 3 pins. Please watch video for instruction


      Source code for decoding Infrared remote controller using Arduino

      
       /*
       * Original code and library from - http://arcfn.com
       * 
       * This code decodes for keys of Black IR remote and White IR remote
       * sold on eBay for Arduino. 
       * You have to select the type of your remote as Black or White in the code bellow
       * and also select your receiver 1838 either as PCB or bare module. See video for details
       * 
       * Modefied/Written by Ahmad Shamshiri
       * on July 28, 2018 at 22:48 in Ajax, Ontario, Canada
       * for Robojax.com
       * Watch video instruction for this code:https://youtu.be/muAkBQb24NI
       * Get other Arduino codes from Robojax.com
       * 
       */
      
      #include <IRremote.h>
      
      int RECV_PIN = 11;
      
      const char type ='W';// W for white, B for black. Must keep single quotes like 'B' or 'W'
      const boolean PCB = 0;// if receiver is PCB set to 1, if not set to 0. See video for details
      
      IRrecv irrecv(RECV_PIN);
      
      // this is array holding codes for White Remote when used with PCB verion of receiver
      unsigned int whiteRemotePCB[] ={
                  0xE318261B, // CH-
                  0x511DBB,   // CH
                  0xEE886D7F,  // CH+
      
                  0x52A3D41F, // |<<
                  0xD7E84B1B, // >>|
                  0x20FE4DBB, // >||          
      
                  0xF076C13B, // -
                  0xA3C8EDDB, // +
                  0x12CEA6E6, // EQ
      
                  0xC101E57B, // 0
                  0x97483BFB, // 100+
                  0xF0C41643, // 200+
      
                  0x9716BE3F, // 1
                  0x3D9AE3F7, // 2
                  0x6182021B, // 3           
      
                  0x8C22657B, // 4 
                  0x488F3CBB, // 5
                  0x449E79F,  // 6
      
                  0x32C6FDF7, // 7
                  0x1BC0157B, // 8
                  0x3EC3FC1B  // 9                          
                  };
      
      // this is array holding codes for White Remote when used with non-PCB verion of receiver            
      unsigned int whiteRemote[] ={
                  0xFFA25D, // CH-
                  0xFF629D,   // CH
                  0xFFE21D,  // CH+
      
                  0xFF22DD, // |<<
                  0xFF02FD, // >>|
                  0xFFC23D, // >||          
      
                  0xFFE01F, // -
                  0xFFA857, // +
                  0xFF906F, // EQ
      
                  0xFF6897, // 0
                  0xFF9867, // 100+
                  0xFFB04F, // 200+
      
                  0xFF30CF, // 1
                  0xFF18E7, // 2
                  0xFF7A85, // 3           
      
                  0xFF10EF, // 4 
                  0xFF38C7, // 5
                  0xFF5AA5,  // 6
      
                  0xFF42BD, // 7
                  0xFF4AB5, // 8
                  0xFF52AD  // 9                          
                  };
      // key lables of white remote
       String whiteRemoteKey[] ={
                  "CH-",
                  "CH",
                  "CH+",
      
                  "|<<",
                  ">>|",
                  ">||",
      
                  "-",
                  "+",
                  "EQ",
      
                  "0",
                  "100+",
                  "200+",
      
                  "1",
                  "2",
                  "3",
      
                  "4",
                  "5",
                  "6",
      
                  "7",
                  "8",
                  "9"
                  };
      
      // this is array holding codes for Black Remote when used with non-PCB verion of receiver
       unsigned int blackRemote[] ={
                  0xFF629D, // ^
                  0xFF22DD,   // <
                  0xFF02FD,  // OK
                  0xFFC23D, // >
                  0xFFA857, // v
      
                  0xFF6897, // 1
                  0xFF9867, // 2
                  0xF0C41643, // 3           
      
                  0xFF30CF, // 4 
                  0xFF18E7, // 5
                  0xFF7A85,  // 6
      
                  0xFF10EF, // 7
                  0xFF38C7, // 8
                  0xFF5AA5,  // 9 
      
                  0xFF42BD, // *
                  0xFF4AB5, // 0
                  0xFF52AD  // #                                      
                  };
      
      // this is array holding codes for Black Remote when used with PCB verion of receiver
       unsigned int blackRemotePCB[] ={
                  0x511DBB, // ^
                  0x52A3D41F,   // <
                  0xD7E84B1B,  // OK
                  0x20FE4DBB, // >
                  0xA3C8EDDB, // v
      
      
                  0xC101E57B, // 1
                  0x97483BFB, // 2
                  0xF0C41643, // 3           
      
                  0x9716BE3F, // 4 
                  0x3D9AE3F7, // 5
                  0x6182021B,  // 6
      
                  0x8C22657B, // 7
                  0x488F3CBB, // 8
                  0x449E79F,  // 9 
      
                  0x32C6FDF7, // *
                  0x1BC0157B, // 0
                  0x3EC3FC1B  // #                                      
                  };
      
      // Black remote key names
       String blackRemoteKey[] ={
                  "^",
                  "<",
                  "OK",
                  ">",
                  "v",
      
                  "1",
                  "2",
                  "3",
      
                  "4",
                  "5",
                  "6",
      
                  "7",
                  "8",
                  "9",
                  
                  "*",
                  "0",
                  "#"
                  };
      
      decode_results results;
      
      
      void setup()
      {
        Serial.begin(9600);
        // In case the interrupt driver crashes on setup, give a clue
        // to the user what's going on.
        Serial.println("Robojax Remote Decoder");
        irrecv.enableIRIn(); // Start the receiver
      
      }
      
      void loop() {
      
        if (irrecv.decode(&results)) {
           //Serial.println(results.value, HEX);
          robojaxValidateCode(results.value);// used the "robojaxValidateCode" bellow
          irrecv.resume(); // Receive the next value
        }
        delay(100);
      }
      
      /*
       * function: robojaxValidateCode
       * validates the remote code and prints correct key name
       * cd is code poassed from the loop
       * Written by A. S. for Robojax
       */
      void robojaxValidateCode(int cd)
      {
      
        // Robojax IR Remote decoder
        int found=0;
      
       if(type =='W' && !PCB)
       {
          // Robojax IR White Remote decoder
          // if tyepe is set to 'W' (white remote) and PCB=0 then check Black remote code
            for(int i=0; i< sizeof(whiteRemote)/sizeof(int); i++)
            {
              if(whiteRemote[i] ==cd)
              {
                
                Serial.print("Key pressed:");
                Serial.println(whiteRemoteKey[i]);
          
                found=1;
              }// if matched
            }// for
       }else if(type =='W' && PCB){
          // Robojax IR White Remote decoder
          // if tyepe is set to 'W' (white remote) and PCB=1 then check Black remote code
            for(int i=0; i< sizeof(whiteRemotePCB)/sizeof(int); i++)
            {
              if(whiteRemotePCB[i] ==cd)
              {
                
                Serial.print("Key pressed:");
                Serial.println(whiteRemoteKey[i]);
          
                found=1;
              }// if matched
            }// for  
       }else if(type =='B' && PCB){
          // Robojax IR White Remote decoder
             // if tyepe is set to 'B' (black remote) and PCB=1 then check Black remote code
             for(int i=0; i< sizeof(blackRemotePCB)/sizeof(int); i++)
            {
              // Robojax IR black Remote decoder
              if(blackRemotePCB[i] ==cd)
              {
      
                Serial.print("Key pressed:");
                Serial.println(blackRemoteKey[i]);
          
                found=1;
              }// if matched
            }// for   
       }else{
      
            // if tyepe is set to 'B' (black remote) and PCB =0 then check Black remote code
             for(int i=0; i< sizeof(blackRemote)/sizeof(int); i++)
            {
              // Robojax IR black Remote decoder
              if(blackRemote[i] ==cd)
              {
                if(blackRemoteKey[i] == "OK"){
                  digitalWrite(9,HIGH);
                }
                Serial.print("Key pressed:");
                Serial.println(blackRemoteKey[i]);
          
                found=1;
              }// if matched
            }// for  
       }// else
        if(!found){
          if(cd !=0xFFFFFFFF)
            {
          Serial.println("Key unkown");
            }
        }// found
      }
      
         

      Tags: ir; kit; wireless; remote; wireless

    There are no reviews for this product.

    Write a review

    Please login or register to review