Can you describe what you expect to see, and also what you see? I am not understanding.
The TV won't turn off or on, that's what am i saying by don't do anything.
The transmitting IRLED has a narrow beam (20 degrees?). Be sure to have the IRLED close to the IR LED on your tv. Also, verify that your project and the commercial remote send the same signals.
what you mean narrow beam, 20 degrees ? (if its what i understand, my transmitting IR led is 90° from the breadboard)
And it's close like 40 cm and about the signal IR i'm not sure about it, how can i be sure about it ? did you've got a code ?
The broader the beam (90 v 20 degrees), the less power reaches a point (inverse power of four, I believe... 1/x^4).
I admit I'm not too much of a mathematician or physicist compared to the power you just talked about but I understood most. So i try with like 30 degres or 20 compared to the TV receiver?
i would first verify the transmitting code from your project is the same as your remote control. Then, find the right LED and work on the power needed (post #20, @flashko).
How to know it without the arduino code ? this is what i receive :
Protocol=Samsung Address=0x707 Command=0x4 Raw-Data=0xFB040707 32 bits LSB first
Send with: IrSender.sendSamsung(0x707, 0x4, <numberOfRepeats>);
You would need to receive the transmitted code. Documents probably exist which have common and specific IR codes.
a common code for Samsung TV? in the documentation for my TV I don't think I saw a specific IRcode in it. But all remote got a specififc IR code no ?
Consider all IR Remote control codes different.
that's what am i thinking lol and also what is the wiring with the transistor ? I would try it but i can't find it with the IR led ? i tried and now the led does nothing litteraly, like no light.
You see
Why the hell do you code this?
// Receiver output for the first loop must be: Protocol=NEC Address=0x102 Command=0x34 Raw-Data=0xCB340102 (32 bits)
IrSender.sendSamsung(0xFD020707, sCommand, sRepeats);
I was trying some new stuff xD, I saw this command and that's what I tested first and that was my first problem since it didn't work so I tried different things with the code, I just didn't put the code back as it should have been (just on this line : IrSender.sendSamsung(0xFD020707, sCommand, sRepeats); However the code still the same)
i see that tuto and the code that he mentionned are obsolete, it no longer works.
The codes DroneBotWorkshop mentions are for his IR setup (not all IR codes are the same). At 20:35 he describes his IR transmitter. In that project, he mentions the codes that he uses were captured in project 2 (of this video).
IT'S WORKING finally !!! I think it was the position of the IR Led and the resistance like you guys mentionned it !! but i suspect that the IR doesn't deliver all his potentiol, how to remediate ? And also when my code is running like 5 min ago or less and i retry, it don't work ?
1 Like
also got a new problem with this code when i captured the IR code and want to send it it work randomly like sometimes one time and other 2 times :
#include <Arduino.h>
#include "PinDefinitionsAndMore.h" // Define macros for input and output pin etc.
/*
* Specify which protocol(s) should be used for decoding.
* If no protocol is defined, all protocols (except Bang&Olufsen) are active.
* This must be done before the #include <IRremote.hpp>
*/
//#define DECODE_DENON // Includes Sharp
//#define DECODE_JVC
//#define DECODE_KASEIKYO
//#define DECODE_PANASONIC // alias for DECODE_KASEIKYO
//#define DECODE_LG
#define DECODE_NEC // Includes Apple and Onkyo
#define DECODE_SAMSUNG
//#define DECODE_SONY
//#define DECODE_RC5
//#define DECODE_RC6
//#define DECODE_BOSEWAVE
//#define DECODE_LEGO_PF
//#define DECODE_MAGIQUEST
//#define DECODE_WHYNTER
//#define DECODE_FAST
//
#if !defined(RAW_BUFFER_LENGTH)
# if RAMEND <= 0x4FF || RAMSIZE < 0x4FF
#define RAW_BUFFER_LENGTH 120
# elif RAMEND <= 0xAFF || RAMSIZE < 0xAFF // 0xAFF for LEONARDO
#define RAW_BUFFER_LENGTH 400 // 600 is too much here, because we have additional uint8_t rawCode[RAW_BUFFER_LENGTH];
# else
#define RAW_BUFFER_LENGTH 750
# endif
#endif
//#define EXCLUDE_UNIVERSAL_PROTOCOLS // Saves up to 1000 bytes program memory.
//#define EXCLUDE_EXOTIC_PROTOCOLS // saves around 650 bytes program memory if all other protocols are active
//#define NO_LED_FEEDBACK_CODE // saves 92 bytes program memory
//#define RECORD_GAP_MICROS 12000 // Default is 5000. Activate it for some LG air conditioner protocols
//#define SEND_PWM_BY_TIMER // Disable carrier PWM generation in software and use (restricted) hardware PWM.
//#define USE_NO_SEND_PWM // Use no carrier PWM, just simulate an active low receiver signal. Overrides SEND_PWM_BY_TIMER definition
// MARK_EXCESS_MICROS is subtracted from all marks and added to all spaces before decoding,
// to compensate for the signal forming of different IR receiver modules. See also IRremote.hpp line 142.
#define MARK_EXCESS_MICROS 20 // Adapt it to your IR receiver module. 20 is recommended for the cheap VS1838 modules.
//#define DEBUG // Activate this for lots of lovely debug output from the decoders.
#include <IRremote.hpp>
int SEND_BUTTON_PIN = APPLICATION_PIN;
int DELAY_BETWEEN_REPEAT = 50;
// Storage for the recorded code
struct storedIRDataStruct {
IRData receivedIRData;
// extensions for sendRaw
uint8_t rawCode[RAW_BUFFER_LENGTH]; // The durations if raw
uint8_t rawCodeLength; // The length of the code
} sStoredIRData;
bool sSendButtonWasActive;
void storeCode();
void sendCode(storedIRDataStruct *aIRDataToSend);
void setup() {
pinMode(SEND_BUTTON_PIN, INPUT_PULLUP);
Serial.begin(115200);
#if defined(__AVR_ATmega32U4__) || defined(SERIAL_PORT_USBVIRTUAL) || defined(SERIAL_USB) /*stm32duino*/|| defined(USBCON) /*STM32_stm32*/|| defined(SERIALUSB_PID) || defined(ARDUINO_attiny3217)
delay(4000); // To be able to connect Serial monitor after reset or power up and before first print out. Do not wait for an attached Serial Monitor!
#endif
// Start the receiver and if not 3. parameter specified, take LED_BUILTIN pin from the internal boards definition as default feedback LED
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
Serial.print(F("Ready to receive IR signals of protocols: "));
printActiveIRProtocols(&Serial);
Serial.println(F("at pin " STR(IR_RECEIVE_PIN)));
IrSender.begin(); // Start with IR_SEND_PIN as send pin and enable feedback LED at default feedback LED pin
Serial.print(F("Ready to send IR signals at pin " STR(IR_SEND_PIN) " on press of button at pin "));
Serial.println(SEND_BUTTON_PIN);
}
void loop() {
// If button pressed, send the code.
bool tSendButtonIsActive = (digitalRead(SEND_BUTTON_PIN) == LOW); // Button pin is active LOW
/*
* Check for current button state
*/
if (tSendButtonIsActive) {
if (!sSendButtonWasActive) {
Serial.println(F("Stop receiving"));
IrReceiver.stop();
}
/*
* Button pressed -> send stored data
*/
Serial.print(F("Button pressed, now sending "));
if (sSendButtonWasActive == tSendButtonIsActive) {
Serial.print(F("repeat "));
sStoredIRData.receivedIRData.flags = IRDATA_FLAGS_IS_REPEAT;
} else {
sStoredIRData.receivedIRData.flags = IRDATA_FLAGS_EMPTY;
}
Serial.flush(); // To avoid disturbing the software PWM generation by serial output interrupts
sendCode(&sStoredIRData);
delay(DELAY_BETWEEN_REPEAT); // Wait a bit between retransmissions
} else if (sSendButtonWasActive) {
// Restart receiver
Serial.println(F("Button released -> start receiving"));
IrReceiver.start();
} else if (IrReceiver.decode()) {
storeCode();
IrReceiver.resume(); // resume receiver
}
sSendButtonWasActive = tSendButtonIsActive;
delay(100);
}
void storeCode() {
if (IrReceiver.decodedIRData.rawDataPtr->rawlen < 4) {
Serial.print(F("Ignore data with rawlen="));
Serial.println(IrReceiver.decodedIRData.rawDataPtr->rawlen);
return;
}
if (IrReceiver.decodedIRData.flags & IRDATA_FLAGS_IS_REPEAT) {
Serial.println(F("Ignore repeat"));
return;
}
/*
* Copy decoded data
*/
sStoredIRData.receivedIRData = IrReceiver.decodedIRData;
if (sStoredIRData.receivedIRData.protocol == UNKNOWN) {
Serial.print(F("Received unknown code and store "));
Serial.print(IrReceiver.decodedIRData.rawDataPtr->rawlen - 1);
Serial.println(F(" timing entries as raw "));
IrReceiver.printIRResultRawFormatted(&Serial, true); // Output the results in RAW format
sStoredIRData.rawCodeLength = IrReceiver.decodedIRData.rawDataPtr->rawlen - 1;
/*
* Store the current raw data in a dedicated array for later usage
*/
IrReceiver.compensateAndStoreIRResultInArray(sStoredIRData.rawCode);
} else {
IrReceiver.printIRResultShort(&Serial);
IrReceiver.printIRSendUsage(&Serial);
sStoredIRData.receivedIRData.flags = 0; // clear flags -esp. repeat- for later sending
Serial.println();
}
}
void sendCode(storedIRDataStruct *aIRDataToSend) {
if (aIRDataToSend->receivedIRData.protocol == UNKNOWN /* i.e. raw */) {
// Assume 38 KHz
IrSender.sendRaw(aIRDataToSend->rawCode, aIRDataToSend->rawCodeLength, 38);
Serial.print(F("raw "));
Serial.print(aIRDataToSend->rawCodeLength);
Serial.println(F(" marks or spaces"));
} else {
/*
* Use the write function, which does the switch for different protocols
*/
IrSender.write(&aIRDataToSend->receivedIRData);
printIRResultShort(&Serial, &aIRDataToSend->receivedIRData, false);
}
}
Just for testing... increase the delay for the button from 100 to 200... just for testing... this might stop the "2 times" but will cause "no times" (no button read)... just to see if the "debounce" after the button press is long enough to stop the button bounce.