| /* IRLibSendBase.cpp | |
| * Part of IRLib Library for Arduino receiving, decoding, and sending | |
| * infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information. | |
| */ | |
| /* | |
| * This module contains the base classes for sending. You will not create instances | |
| * of these classes, rather you will use them as base classes in creating derived | |
| * protocol specific decoders. Each protocol specific send class begins | |
| * by calling enableIROut(uint8_t kHz) to set the carrier frequency. | |
| * It then calls mark(int usec) and space(inc usec) to transmit marks and | |
| * spaces of varying length of microseconds in the manner which the protocol defines. | |
| */ | |
| /* | |
| * Most of the protocols have a header consisting of a mark/space of a particular length followed by | |
| * a series of variable length mark/space signals. Depending on the protocol they very the lengths of the | |
| * mark or the space to indicate a data bit of "0" or "1". Most also end with a stop bit of "1". | |
| * The basic structure of the sending and decoding these protocols led to lots of redundant code. | |
| * Therefore I have implemented generic sending and decoding routines. You just need to pass a bunch of customized | |
| * parameters and it does the work. This reduces compiled code size with only minor speed degradation. | |
| * You may be able to implement new protocols by simply passing the proper values to these generic routines. | |
| * The decoding routines do not encode stop bits. So you have to tell this routine whether or not to send one. | |
| * Some protocols have a fixed amount of space between frames while others require that the entire frame | |
| * be a particularly length despite the fact that the data transmission time may be veritable. Pass this | |
| * frame length of time the parameter maxExtent. It's default value is zero. | |
| */ | |
| void IRsendBase::sendGeneric(uint32_t data, uint8_t numBits, uint16_t headMark, uint16_t headSpace, | |
| uint16_t markOne, uint16_t markZero, uint16_t spaceOne, uint16_t spaceZero, | |
| uint8_t kHz, bool useStop, uint32_t maxExtent) { | |
| extent=0; | |
| data = data << (32 - numBits); | |
| enableIROut(kHz); | |
| //Some protocols do not send a header when sending repeat codes. So we pass a zero value to indicate skipping this. | |
| if(headMark) mark(headMark); | |
| if(headSpace) space(headSpace); | |
| for (uint8_t i = 0; i <numBits; i++) { | |
| if (data & TOPBIT) { | |
| mark(markOne); space(spaceOne); | |
| } | |
| else { | |
| mark(markZero); space(spaceZero); | |
| } | |
| data <<= 1; | |
| } | |
| if(useStop) mark(markOne); //stop bit of "1" | |
| if(maxExtent) { | |
| Serial.print("maxExtent="); Serial.println(maxExtent); | |
| Serial.print("extent="); Serial.println(extent); | |
| Serial.print("Difference="); Serial.println(maxExtent-extent); | |
| space(maxExtent-extent); | |
| } | |
| else space(spaceOne); | |
| }; | |
| void IRsendBase::enableIROut(uint8_t khz) { | |
| //NOTE: the comments on this routine accompanied the original early version of IRremote library | |
| //which only used TIMER2. The parameters defined in IRLibTimer.h may or may not work this way. | |
| // Enables IR output. The khz value controls the modulation frequency in kilohertz. | |
| // The IR output will be on pin 3 (OC2B). | |
| // This routine is designed for 36-40KHz; if you use it for other values, it's up to you | |
| // to make sure it gives reasonable results. (Watch out for overflow / underflow / rounding.) | |
| // TIMER2 is used in phase-correct PWM mode, with OCR2A controlling the frequency and OCR2B | |
| // controlling the duty cycle. | |
| // There is no prescaling, so the output frequency is 16MHz / (2 * OCR2A) | |
| // To turn the output on and off, we leave the PWM running, but connect and disconnect the output pin. | |
| // A few hours staring at the ATmega documentation and this will all make sense. | |
| // See my Secrets of Arduino PWM at http://www.righto.com/2009/07/secrets-of-arduino-pwm.html for details. | |
| // Disable the Timer2 Interrupt (which is used for receiving IR) | |
| IRLib_didIROut=true; //Tell the receiver we probably trashed his timer settings | |
| IR_RECV_DISABLE_INTR; //Timer2 Overflow Interrupt | |
| pinMode(IR_SEND_PWM_PIN, OUTPUT); | |
| digitalWrite(IR_SEND_PWM_PIN, LOW); // When not sending PWM, we want it low | |
| IR_SEND_CONFIG_KHZ(khz); | |
| } | |
| IRsendBase::IRsendBase () { | |
| pinMode(IR_SEND_PWM_PIN, OUTPUT); | |
| digitalWrite(IR_SEND_PWM_PIN, LOW); // When not sending PWM, we want it low | |
| } | |
| //The Arduino built in function delayMicroseconds has limits we wish to exceed | |
| //Therefore we have created this alternative | |
| void IRLibDelayUSecs(uint16_t time) { | |
| if(time){if(time>16000) {delayMicroseconds(time % 1000); delay(time/1000); } else delayMicroseconds(time);}; | |
| } | |
| void IRsendBase::mark(uint16_t time) { | |
| IR_SEND_PWM_START; | |
| IR_SEND_MARK_TIME(time); | |
| extent+=time; | |
| } | |
| void IRsendBase::space(uint16_t time) { | |
| IR_SEND_PWM_STOP; | |
| IRLibDelayUSecs(time); | |
| extent+=time; | |
| } | |