125 lines
4.7 KiB
C++
125 lines
4.7 KiB
C++
// Copyright 2020 Christian (nikize)
|
|
/// @file
|
|
/// @brief Doshisha protocol support
|
|
/// @see https://www.doshisha-led.com/
|
|
|
|
// Supports:
|
|
// Brand: Doshisha, Model: CZ-S32D LED Light
|
|
// Brand: Doshisha, Model: CZ-S38D LED Light
|
|
// Brand: Doshisha, Model: CZ-S50D LED Light
|
|
// Brand: Doshisha, Model: RCZ01 remote
|
|
|
|
#include "IRrecv.h"
|
|
#include "IRsend.h"
|
|
#include "IRutils.h"
|
|
|
|
|
|
const uint16_t kDoshishaHdrMark = 3412;
|
|
const uint16_t kDoshishaHdrSpace = 1722;
|
|
const uint16_t kDoshishaBitMark = 420;
|
|
const uint16_t kDoshishaOneSpace = 1310;
|
|
const uint16_t kDoshishaZeroSpace = 452;
|
|
|
|
// basic structure of bits, and mask
|
|
const uint64_t kRcz01SignatureMask = 0xffffffff00;
|
|
const uint64_t kRcz01Signature = 0x800B304800;
|
|
const uint8_t kRcz01CommandMask = 0xFE;
|
|
const uint8_t kRcz01ChannelMask = 0x01;
|
|
|
|
// Known commands - Here for documentation rather than actual usage
|
|
const uint8_t kRcz01CommandSwitchChannel = 0xD2;
|
|
const uint8_t kRcz01CommandTimmer60 = 0x52;
|
|
const uint8_t kRcz01CommandTimmer30 = 0x92;
|
|
const uint8_t kRcz01CommandOff = 0xA0;
|
|
|
|
const uint8_t kRcz01CommandLevelDown = 0x2C;
|
|
const uint8_t kRcz01CommandLevelUp = 0xCC;
|
|
// below are the only ones that turns it on
|
|
const uint8_t kRcz01CommandLevel1 = 0xA4;
|
|
const uint8_t kRcz01CommandLevel2 = 0x24;
|
|
const uint8_t kRcz01CommandLevel3 = 0xC4;
|
|
const uint8_t kRcz01CommandLevel4 = 0xD0;
|
|
|
|
const uint8_t kRcz01CommandOn = 0xC0;
|
|
const uint8_t kRcz01CommandNightLight = 0xC8;
|
|
// end Known commands
|
|
|
|
#if SEND_DOSHISHA
|
|
/// Send a Doshisha formatted message.
|
|
/// Status: STABLE / Works on real device.
|
|
/// @param[in] data The message to be sent.
|
|
/// @param[in] nbits The number of bits of message to be sent.
|
|
/// @param[in] repeat The number of times the command is to be repeated.
|
|
void IRsend::sendDoshisha(const uint64_t data, const uint16_t nbits,
|
|
const uint16_t repeat) {
|
|
sendGeneric(kDoshishaHdrMark, kDoshishaHdrSpace,
|
|
kDoshishaBitMark, kDoshishaOneSpace,
|
|
kDoshishaBitMark, kDoshishaZeroSpace,
|
|
kDoshishaBitMark, kDefaultMessageGap,
|
|
data, nbits, 38, true, repeat, kDutyDefault);
|
|
}
|
|
|
|
/// Encode Doshisha combining constant values with command and channel.
|
|
/// Status: STABLE / Working.
|
|
/// @param[in] command The command code to be sent.
|
|
/// @param[in] channel The one bit channel 0 for CH1 and 1 for CH2
|
|
/// @return The corresponding Doshisha code.
|
|
uint64_t IRsend::encodeDoshisha(const uint8_t command, const uint8_t channel) {
|
|
uint64_t data = kRcz01Signature |
|
|
(command & kRcz01CommandMask) |
|
|
(channel & kRcz01ChannelMask);
|
|
return data;
|
|
}
|
|
#endif // SEND_DOSHISHA
|
|
|
|
#if DECODE_DOSHISHA
|
|
/// Decode the supplied Doshisha message.
|
|
/// Status: STABLE / Works on real device.
|
|
/// @param[in,out] results Ptr to the data to decode & where to store the decode
|
|
/// result.
|
|
/// @param[in] offset The starting index to use when attempting to decode the
|
|
/// raw data. Typically/Defaults to kStartOffset.
|
|
/// @param[in] nbits The number of data bits to expect.
|
|
/// @param[in] strict Flag indicating if we should perform strict matching.
|
|
/// @return A boolean. True if it can decode it, false if it can't.
|
|
bool IRrecv::decodeDoshisha(decode_results *results, uint16_t offset,
|
|
const uint16_t nbits, const bool strict) {
|
|
if (results->rawlen < 2 * nbits + kHeader + kFooter - 1 + offset)
|
|
return false; // Can't possibly be a valid message.
|
|
if (strict && nbits != kDoshishaBits)
|
|
return false;
|
|
|
|
uint64_t data = 0;
|
|
// Match Header + Data
|
|
if (!matchGeneric(results->rawbuf + offset, &data,
|
|
results->rawlen - offset, nbits,
|
|
kDoshishaHdrMark, kDoshishaHdrSpace,
|
|
kDoshishaBitMark, kDoshishaOneSpace,
|
|
kDoshishaBitMark, kDoshishaZeroSpace,
|
|
kDoshishaBitMark, 0,
|
|
true, kTolerance, kMarkExcess, true)) return false;
|
|
|
|
// e.g. data = 0x800B3048C0, nbits = 40
|
|
|
|
// RCZ01 remote commands starts with a lead bit set
|
|
if ((data & kRcz01SignatureMask) != kRcz01Signature) {
|
|
DPRINT(" decodeDoshisha data ");
|
|
DPRINT(uint64ToString(data, 16));
|
|
DPRINT(" masked ");
|
|
DPRINT(uint64ToString(data & kRcz01SignatureMask, 16));
|
|
DPRINT(" not matching ");
|
|
DPRINT(uint64ToString(kRcz01Signature, 16));
|
|
DPRINTLN(" .");
|
|
return false; // expected lead bits not matching
|
|
}
|
|
|
|
// Success
|
|
results->decode_type = decode_type_t::DOSHISHA;
|
|
results->bits = nbits;
|
|
results->value = data;
|
|
results->command = data & kRcz01CommandMask;
|
|
results->address = data & kRcz01ChannelMask;
|
|
return true;
|
|
}
|
|
#endif // DECODE_DOSHISHA
|