Offbeat Iot
Get started
Using the Alexa integration

Using the Alexa integration

These sections show the websocket JSON sent to the device for the supported Alexa directives together with matching Arduino device examples from microcontroller-examples.

set brightness 
{
  "adjustBrightnessPercent" : 59,
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaBrightnessPercent(const char* endpointId, long brightnessPercent) {
  Serial.print("Set brightness percent on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(brightnessPercent);

  Serial.print("BRIGHTNESS_PERCENT=");
  Serial.println(brightnessPercent);
}

void applyAlexaBrightnessWeight(const char* endpointId, long brightnessWeight) {
  Serial.print("Adjust brightness weight on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(brightnessWeight);

  Serial.print("BRIGHTNESS_WEIGHT=");
  Serial.println(brightnessWeight);
}

void handleAlexaBrightnessCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa brightness command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst brightnessPercent = root[offbeat::alexa::examples::kAdjustBrightnessPercentKey];
  JsonVariantConst brightnessWeight = root[offbeat::alexa::examples::kAdjustBrightnessWeightKey];

  if (!brightnessPercent.isNull()) {
    applyAlexaBrightnessPercent(endpointId, offbeat::alexa::examples::readLong(brightnessPercent));
  } else if (!brightnessWeight.isNull()) {
    applyAlexaBrightnessWeight(endpointId, offbeat::alexa::examples::readLong(brightnessWeight));
  } else {
    Serial.println("No Alexa brightness payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
adjust brightness 
{
  "endpointId" : "the endpoint id",
  "adjustBrightnessWeight" : -3
}
Arduino device example
void applyAlexaBrightnessPercent(const char* endpointId, long brightnessPercent) {
  Serial.print("Set brightness percent on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(brightnessPercent);

  Serial.print("BRIGHTNESS_PERCENT=");
  Serial.println(brightnessPercent);
}

void applyAlexaBrightnessWeight(const char* endpointId, long brightnessWeight) {
  Serial.print("Adjust brightness weight on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(brightnessWeight);

  Serial.print("BRIGHTNESS_WEIGHT=");
  Serial.println(brightnessWeight);
}

void handleAlexaBrightnessCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa brightness command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst brightnessPercent = root[offbeat::alexa::examples::kAdjustBrightnessPercentKey];
  JsonVariantConst brightnessWeight = root[offbeat::alexa::examples::kAdjustBrightnessWeightKey];

  if (!brightnessPercent.isNull()) {
    applyAlexaBrightnessPercent(endpointId, offbeat::alexa::examples::readLong(brightnessPercent));
  } else if (!brightnessWeight.isNull()) {
    applyAlexaBrightnessWeight(endpointId, offbeat::alexa::examples::readLong(brightnessWeight));
  } else {
    Serial.println("No Alexa brightness payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
set color 
{
  "saturation" : 0.7138,
  "brightness" : 0.6524,
  "endpointId" : "the endpoint id",
  "hue" : 350.5
}
Arduino device example
void applyAlexaColorCommand(const char* endpointId, double hue, double saturation, double brightness) {
  Serial.print("Set color on ");
  Serial.println(endpointId);
  offbeat::alexa::examples::printLine("Hue: ", hue, 4);
  offbeat::alexa::examples::printLine("Saturation: ", saturation, 4);
  offbeat::alexa::examples::printLine("Brightness: ", brightness, 4);

  Serial.print("HUE=");
  Serial.println(hue, 4);
  Serial.print("SATURATION=");
  Serial.println(saturation, 4);
  Serial.print("BRIGHTNESS=");
  Serial.println(brightness, 4);
}

void handleAlexaColorCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa color command");
    return;
  }

  JsonVariantConst hueValue = root[offbeat::alexa::examples::kHueKey];
  JsonVariantConst saturationValue = root[offbeat::alexa::examples::kSaturationKey];
  JsonVariantConst brightnessValue = root[offbeat::alexa::examples::kBrightnessKey];
  if (hueValue.isNull() || saturationValue.isNull() || brightnessValue.isNull()) {
    Serial.println("Incomplete Alexa color payload");
    return;
  }

  applyAlexaColorCommand(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readDouble(hueValue),
      offbeat::alexa::examples::readDouble(saturationValue),
      offbeat::alexa::examples::readDouble(brightnessValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
turn on 
{
  "endpointId" : "the endpoint id",
  "powerstate" : "TurnOn"
}
Arduino device example
void applyAlexaPowerState(const char* endpointId, const char* powerState) {
  Serial.print("Apply Alexa power command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(powerState);

  if (strcmp(powerState, "TurnOn") == 0) {
    Serial.println("Turn your relay or transistor on here");
  } else if (strcmp(powerState, "TurnOff") == 0) {
    Serial.println("Turn your relay or transistor off here");
  } else {
    Serial.println("Unsupported Alexa power command");
    return;
  }

  Serial.print("POWERSTATE=");
  Serial.println(powerState);
}

void handleAlexaPowerCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa power command");
    return;
  }

  JsonVariantConst powerStateValue = root[offbeat::alexa::examples::kPowerStateKey];
  if (powerStateValue.isNull()) {
    Serial.println("No Alexa powerstate payload");
    return;
  }

  applyAlexaPowerState(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(powerStateValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
turn off 
{
  "endpointId" : "the endpoint id",
  "powerstate" : "TurnOff"
}
Arduino device example
void applyAlexaPowerState(const char* endpointId, const char* powerState) {
  Serial.print("Apply Alexa power command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(powerState);

  if (strcmp(powerState, "TurnOn") == 0) {
    Serial.println("Turn your relay or transistor on here");
  } else if (strcmp(powerState, "TurnOff") == 0) {
    Serial.println("Turn your relay or transistor off here");
  } else {
    Serial.println("Unsupported Alexa power command");
    return;
  }

  Serial.print("POWERSTATE=");
  Serial.println(powerState);
}

void handleAlexaPowerCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa power command");
    return;
  }

  JsonVariantConst powerStateValue = root[offbeat::alexa::examples::kPowerStateKey];
  if (powerStateValue.isNull()) {
    Serial.println("No Alexa powerstate payload");
    return;
  }

  applyAlexaPowerState(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(powerStateValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
adjust speaker volume using Alexa.StepSpeaker 
{
  "endpointId" : "the endpoint id",
  "volumesteps" : 20
}
Arduino device example
void applyAlexaSpeakerVolume(const char* endpointId, long volumePercent) {
  Serial.print("Set speaker volume on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(volumePercent);

  Serial.print("VOLUME=");
  Serial.println(volumePercent);
}

void applyAlexaSpeakerVolumeSteps(const char* endpointId, long volumeSteps) {
  Serial.print("Adjust speaker volume steps on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(volumeSteps);

  Serial.print("VOLUME_STEPS=");
  Serial.println(volumeSteps);
}

void applyAlexaSpeakerMute(const char* endpointId, bool muted) {
  Serial.print("Set mute on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(muted ? "true" : "false");

  Serial.print("MUTE=");
  Serial.println(muted ? "true" : "false");
}

void handleAlexaSpeakerCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa speaker command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst volumeValue = root[offbeat::alexa::examples::kVolumeKey];
  JsonVariantConst volumeStepsValue = root[offbeat::alexa::examples::kVolumeStepsKey];
  JsonVariantConst muteValue = root[offbeat::alexa::examples::kMuteKey];

  if (!volumeValue.isNull()) {
    applyAlexaSpeakerVolume(endpointId, offbeat::alexa::examples::readLong(volumeValue));
  } else if (!volumeStepsValue.isNull()) {
    applyAlexaSpeakerVolumeSteps(endpointId, offbeat::alexa::examples::readLong(volumeStepsValue));
  } else if (!muteValue.isNull()) {
    applyAlexaSpeakerMute(endpointId, offbeat::alexa::examples::readBool(muteValue));
  } else {
    Serial.println("No Alexa speaker payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
adjust speaker volume using Alexa.Speaker 
{
  "endpointId" : "the endpoint id",
  "volumesteps" : 20
}
Arduino device example
void applyAlexaSpeakerVolume(const char* endpointId, long volumePercent) {
  Serial.print("Set speaker volume on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(volumePercent);

  Serial.print("VOLUME=");
  Serial.println(volumePercent);
}

void applyAlexaSpeakerVolumeSteps(const char* endpointId, long volumeSteps) {
  Serial.print("Adjust speaker volume steps on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(volumeSteps);

  Serial.print("VOLUME_STEPS=");
  Serial.println(volumeSteps);
}

void applyAlexaSpeakerMute(const char* endpointId, bool muted) {
  Serial.print("Set mute on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(muted ? "true" : "false");

  Serial.print("MUTE=");
  Serial.println(muted ? "true" : "false");
}

void handleAlexaSpeakerCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa speaker command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst volumeValue = root[offbeat::alexa::examples::kVolumeKey];
  JsonVariantConst volumeStepsValue = root[offbeat::alexa::examples::kVolumeStepsKey];
  JsonVariantConst muteValue = root[offbeat::alexa::examples::kMuteKey];

  if (!volumeValue.isNull()) {
    applyAlexaSpeakerVolume(endpointId, offbeat::alexa::examples::readLong(volumeValue));
  } else if (!volumeStepsValue.isNull()) {
    applyAlexaSpeakerVolumeSteps(endpointId, offbeat::alexa::examples::readLong(volumeStepsValue));
  } else if (!muteValue.isNull()) {
    applyAlexaSpeakerMute(endpointId, offbeat::alexa::examples::readBool(muteValue));
  } else {
    Serial.println("No Alexa speaker payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
mute speaker using Alexa.StepSpeaker 
{
  "endpointId" : "the endpoint id",
  "mute" : false
}
Arduino device example
void applyAlexaSpeakerVolume(const char* endpointId, long volumePercent) {
  Serial.print("Set speaker volume on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(volumePercent);

  Serial.print("VOLUME=");
  Serial.println(volumePercent);
}

void applyAlexaSpeakerVolumeSteps(const char* endpointId, long volumeSteps) {
  Serial.print("Adjust speaker volume steps on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(volumeSteps);

  Serial.print("VOLUME_STEPS=");
  Serial.println(volumeSteps);
}

void applyAlexaSpeakerMute(const char* endpointId, bool muted) {
  Serial.print("Set mute on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(muted ? "true" : "false");

  Serial.print("MUTE=");
  Serial.println(muted ? "true" : "false");
}

void handleAlexaSpeakerCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa speaker command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst volumeValue = root[offbeat::alexa::examples::kVolumeKey];
  JsonVariantConst volumeStepsValue = root[offbeat::alexa::examples::kVolumeStepsKey];
  JsonVariantConst muteValue = root[offbeat::alexa::examples::kMuteKey];

  if (!volumeValue.isNull()) {
    applyAlexaSpeakerVolume(endpointId, offbeat::alexa::examples::readLong(volumeValue));
  } else if (!volumeStepsValue.isNull()) {
    applyAlexaSpeakerVolumeSteps(endpointId, offbeat::alexa::examples::readLong(volumeStepsValue));
  } else if (!muteValue.isNull()) {
    applyAlexaSpeakerMute(endpointId, offbeat::alexa::examples::readBool(muteValue));
  } else {
    Serial.println("No Alexa speaker payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
set speaker volume 
{
  "volume" : 30,
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaSpeakerVolume(const char* endpointId, long volumePercent) {
  Serial.print("Set speaker volume on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(volumePercent);

  Serial.print("VOLUME=");
  Serial.println(volumePercent);
}

void applyAlexaSpeakerVolumeSteps(const char* endpointId, long volumeSteps) {
  Serial.print("Adjust speaker volume steps on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(volumeSteps);

  Serial.print("VOLUME_STEPS=");
  Serial.println(volumeSteps);
}

void applyAlexaSpeakerMute(const char* endpointId, bool muted) {
  Serial.print("Set mute on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(muted ? "true" : "false");

  Serial.print("MUTE=");
  Serial.println(muted ? "true" : "false");
}

void handleAlexaSpeakerCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa speaker command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst volumeValue = root[offbeat::alexa::examples::kVolumeKey];
  JsonVariantConst volumeStepsValue = root[offbeat::alexa::examples::kVolumeStepsKey];
  JsonVariantConst muteValue = root[offbeat::alexa::examples::kMuteKey];

  if (!volumeValue.isNull()) {
    applyAlexaSpeakerVolume(endpointId, offbeat::alexa::examples::readLong(volumeValue));
  } else if (!volumeStepsValue.isNull()) {
    applyAlexaSpeakerVolumeSteps(endpointId, offbeat::alexa::examples::readLong(volumeStepsValue));
  } else if (!muteValue.isNull()) {
    applyAlexaSpeakerMute(endpointId, offbeat::alexa::examples::readBool(muteValue));
  } else {
    Serial.println("No Alexa speaker payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
adjust speaker volume using Alexa.Speaker volume 
{
  "endpointId" : "the endpoint id",
  "volumesteps" : 30
}
Arduino device example
void applyAlexaSpeakerVolume(const char* endpointId, long volumePercent) {
  Serial.print("Set speaker volume on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(volumePercent);

  Serial.print("VOLUME=");
  Serial.println(volumePercent);
}

void applyAlexaSpeakerVolumeSteps(const char* endpointId, long volumeSteps) {
  Serial.print("Adjust speaker volume steps on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(volumeSteps);

  Serial.print("VOLUME_STEPS=");
  Serial.println(volumeSteps);
}

void applyAlexaSpeakerMute(const char* endpointId, bool muted) {
  Serial.print("Set mute on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(muted ? "true" : "false");

  Serial.print("MUTE=");
  Serial.println(muted ? "true" : "false");
}

void handleAlexaSpeakerCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa speaker command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst volumeValue = root[offbeat::alexa::examples::kVolumeKey];
  JsonVariantConst volumeStepsValue = root[offbeat::alexa::examples::kVolumeStepsKey];
  JsonVariantConst muteValue = root[offbeat::alexa::examples::kMuteKey];

  if (!volumeValue.isNull()) {
    applyAlexaSpeakerVolume(endpointId, offbeat::alexa::examples::readLong(volumeValue));
  } else if (!volumeStepsValue.isNull()) {
    applyAlexaSpeakerVolumeSteps(endpointId, offbeat::alexa::examples::readLong(volumeStepsValue));
  } else if (!muteValue.isNull()) {
    applyAlexaSpeakerMute(endpointId, offbeat::alexa::examples::readBool(muteValue));
  } else {
    Serial.println("No Alexa speaker payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
mute speaker using Alexa.Speaker 
{
  "endpointId" : "the endpoint id",
  "mute" : false
}
Arduino device example
void applyAlexaSpeakerVolume(const char* endpointId, long volumePercent) {
  Serial.print("Set speaker volume on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(volumePercent);

  Serial.print("VOLUME=");
  Serial.println(volumePercent);
}

void applyAlexaSpeakerVolumeSteps(const char* endpointId, long volumeSteps) {
  Serial.print("Adjust speaker volume steps on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(volumeSteps);

  Serial.print("VOLUME_STEPS=");
  Serial.println(volumeSteps);
}

void applyAlexaSpeakerMute(const char* endpointId, bool muted) {
  Serial.print("Set mute on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(muted ? "true" : "false");

  Serial.print("MUTE=");
  Serial.println(muted ? "true" : "false");
}

void handleAlexaSpeakerCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa speaker command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst volumeValue = root[offbeat::alexa::examples::kVolumeKey];
  JsonVariantConst volumeStepsValue = root[offbeat::alexa::examples::kVolumeStepsKey];
  JsonVariantConst muteValue = root[offbeat::alexa::examples::kMuteKey];

  if (!volumeValue.isNull()) {
    applyAlexaSpeakerVolume(endpointId, offbeat::alexa::examples::readLong(volumeValue));
  } else if (!volumeStepsValue.isNull()) {
    applyAlexaSpeakerVolumeSteps(endpointId, offbeat::alexa::examples::readLong(volumeStepsValue));
  } else if (!muteValue.isNull()) {
    applyAlexaSpeakerMute(endpointId, offbeat::alexa::examples::readBool(muteValue));
  } else {
    Serial.println("No Alexa speaker payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
playback fast forward 
{
  "playerControl" : "Next",
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaPlaybackCommand(const char* endpointId, const char* playerControl) {
  Serial.print("Apply playback command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(playerControl);

  if (strcmp(playerControl, "Play") == 0) {
    Serial.println("Start playback here");
  } else if (strcmp(playerControl, "Pause") == 0) {
    Serial.println("Pause playback here");
  } else if (strcmp(playerControl, "Stop") == 0) {
    Serial.println("Stop playback here");
  } else if (strcmp(playerControl, "Next") == 0) {
    Serial.println("Skip to the next item here");
  } else if (strcmp(playerControl, "Prev") == 0) {
    Serial.println("Go to the previous item here");
  } else {
    Serial.println("Unsupported Alexa playback command");
    return;
  }

  Serial.print("PLAYER_CONTROL=");
  Serial.println(playerControl);
}

void handleAlexaPlaybackCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa playback command");
    return;
  }

  JsonVariantConst playerControlValue = root[offbeat::alexa::examples::kPlayerControlKey];
  if (playerControlValue.isNull()) {
    Serial.println("No Alexa playback payload");
    return;
  }

  applyAlexaPlaybackCommand(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(playerControlValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
playback next 
{
  "playerControl" : "Next",
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaPlaybackCommand(const char* endpointId, const char* playerControl) {
  Serial.print("Apply playback command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(playerControl);

  if (strcmp(playerControl, "Play") == 0) {
    Serial.println("Start playback here");
  } else if (strcmp(playerControl, "Pause") == 0) {
    Serial.println("Pause playback here");
  } else if (strcmp(playerControl, "Stop") == 0) {
    Serial.println("Stop playback here");
  } else if (strcmp(playerControl, "Next") == 0) {
    Serial.println("Skip to the next item here");
  } else if (strcmp(playerControl, "Prev") == 0) {
    Serial.println("Go to the previous item here");
  } else {
    Serial.println("Unsupported Alexa playback command");
    return;
  }

  Serial.print("PLAYER_CONTROL=");
  Serial.println(playerControl);
}

void handleAlexaPlaybackCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa playback command");
    return;
  }

  JsonVariantConst playerControlValue = root[offbeat::alexa::examples::kPlayerControlKey];
  if (playerControlValue.isNull()) {
    Serial.println("No Alexa playback payload");
    return;
  }

  applyAlexaPlaybackCommand(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(playerControlValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
playback pause 
{
  "playerControl" : "Pause",
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaPlaybackCommand(const char* endpointId, const char* playerControl) {
  Serial.print("Apply playback command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(playerControl);

  if (strcmp(playerControl, "Play") == 0) {
    Serial.println("Start playback here");
  } else if (strcmp(playerControl, "Pause") == 0) {
    Serial.println("Pause playback here");
  } else if (strcmp(playerControl, "Stop") == 0) {
    Serial.println("Stop playback here");
  } else if (strcmp(playerControl, "Next") == 0) {
    Serial.println("Skip to the next item here");
  } else if (strcmp(playerControl, "Prev") == 0) {
    Serial.println("Go to the previous item here");
  } else {
    Serial.println("Unsupported Alexa playback command");
    return;
  }

  Serial.print("PLAYER_CONTROL=");
  Serial.println(playerControl);
}

void handleAlexaPlaybackCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa playback command");
    return;
  }

  JsonVariantConst playerControlValue = root[offbeat::alexa::examples::kPlayerControlKey];
  if (playerControlValue.isNull()) {
    Serial.println("No Alexa playback payload");
    return;
  }

  applyAlexaPlaybackCommand(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(playerControlValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
playback play 
{
  "playerControl" : "Play",
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaPlaybackCommand(const char* endpointId, const char* playerControl) {
  Serial.print("Apply playback command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(playerControl);

  if (strcmp(playerControl, "Play") == 0) {
    Serial.println("Start playback here");
  } else if (strcmp(playerControl, "Pause") == 0) {
    Serial.println("Pause playback here");
  } else if (strcmp(playerControl, "Stop") == 0) {
    Serial.println("Stop playback here");
  } else if (strcmp(playerControl, "Next") == 0) {
    Serial.println("Skip to the next item here");
  } else if (strcmp(playerControl, "Prev") == 0) {
    Serial.println("Go to the previous item here");
  } else {
    Serial.println("Unsupported Alexa playback command");
    return;
  }

  Serial.print("PLAYER_CONTROL=");
  Serial.println(playerControl);
}

void handleAlexaPlaybackCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa playback command");
    return;
  }

  JsonVariantConst playerControlValue = root[offbeat::alexa::examples::kPlayerControlKey];
  if (playerControlValue.isNull()) {
    Serial.println("No Alexa playback payload");
    return;
  }

  applyAlexaPlaybackCommand(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(playerControlValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
playback previous 
{
  "playerControl" : "Prev",
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaPlaybackCommand(const char* endpointId, const char* playerControl) {
  Serial.print("Apply playback command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(playerControl);

  if (strcmp(playerControl, "Play") == 0) {
    Serial.println("Start playback here");
  } else if (strcmp(playerControl, "Pause") == 0) {
    Serial.println("Pause playback here");
  } else if (strcmp(playerControl, "Stop") == 0) {
    Serial.println("Stop playback here");
  } else if (strcmp(playerControl, "Next") == 0) {
    Serial.println("Skip to the next item here");
  } else if (strcmp(playerControl, "Prev") == 0) {
    Serial.println("Go to the previous item here");
  } else {
    Serial.println("Unsupported Alexa playback command");
    return;
  }

  Serial.print("PLAYER_CONTROL=");
  Serial.println(playerControl);
}

void handleAlexaPlaybackCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa playback command");
    return;
  }

  JsonVariantConst playerControlValue = root[offbeat::alexa::examples::kPlayerControlKey];
  if (playerControlValue.isNull()) {
    Serial.println("No Alexa playback payload");
    return;
  }

  applyAlexaPlaybackCommand(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(playerControlValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
playback rewind 
{
  "playerControl" : "Prev",
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaPlaybackCommand(const char* endpointId, const char* playerControl) {
  Serial.print("Apply playback command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(playerControl);

  if (strcmp(playerControl, "Play") == 0) {
    Serial.println("Start playback here");
  } else if (strcmp(playerControl, "Pause") == 0) {
    Serial.println("Pause playback here");
  } else if (strcmp(playerControl, "Stop") == 0) {
    Serial.println("Stop playback here");
  } else if (strcmp(playerControl, "Next") == 0) {
    Serial.println("Skip to the next item here");
  } else if (strcmp(playerControl, "Prev") == 0) {
    Serial.println("Go to the previous item here");
  } else {
    Serial.println("Unsupported Alexa playback command");
    return;
  }

  Serial.print("PLAYER_CONTROL=");
  Serial.println(playerControl);
}

void handleAlexaPlaybackCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa playback command");
    return;
  }

  JsonVariantConst playerControlValue = root[offbeat::alexa::examples::kPlayerControlKey];
  if (playerControlValue.isNull()) {
    Serial.println("No Alexa playback payload");
    return;
  }

  applyAlexaPlaybackCommand(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(playerControlValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
playback start over 
{
  "playerControl" : "Prev",
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaPlaybackCommand(const char* endpointId, const char* playerControl) {
  Serial.print("Apply playback command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(playerControl);

  if (strcmp(playerControl, "Play") == 0) {
    Serial.println("Start playback here");
  } else if (strcmp(playerControl, "Pause") == 0) {
    Serial.println("Pause playback here");
  } else if (strcmp(playerControl, "Stop") == 0) {
    Serial.println("Stop playback here");
  } else if (strcmp(playerControl, "Next") == 0) {
    Serial.println("Skip to the next item here");
  } else if (strcmp(playerControl, "Prev") == 0) {
    Serial.println("Go to the previous item here");
  } else {
    Serial.println("Unsupported Alexa playback command");
    return;
  }

  Serial.print("PLAYER_CONTROL=");
  Serial.println(playerControl);
}

void handleAlexaPlaybackCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa playback command");
    return;
  }

  JsonVariantConst playerControlValue = root[offbeat::alexa::examples::kPlayerControlKey];
  if (playerControlValue.isNull()) {
    Serial.println("No Alexa playback payload");
    return;
  }

  applyAlexaPlaybackCommand(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(playerControlValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
playback stop 
{
  "playerControl" : "Stop",
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaPlaybackCommand(const char* endpointId, const char* playerControl) {
  Serial.print("Apply playback command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(playerControl);

  if (strcmp(playerControl, "Play") == 0) {
    Serial.println("Start playback here");
  } else if (strcmp(playerControl, "Pause") == 0) {
    Serial.println("Pause playback here");
  } else if (strcmp(playerControl, "Stop") == 0) {
    Serial.println("Stop playback here");
  } else if (strcmp(playerControl, "Next") == 0) {
    Serial.println("Skip to the next item here");
  } else if (strcmp(playerControl, "Prev") == 0) {
    Serial.println("Go to the previous item here");
  } else {
    Serial.println("Unsupported Alexa playback command");
    return;
  }

  Serial.print("PLAYER_CONTROL=");
  Serial.println(playerControl);
}

void handleAlexaPlaybackCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa playback command");
    return;
  }

  JsonVariantConst playerControlValue = root[offbeat::alexa::examples::kPlayerControlKey];
  if (playerControlValue.isNull()) {
    Serial.println("No Alexa playback payload");
    return;
  }

  applyAlexaPlaybackCommand(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(playerControlValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
skip channels 
{
  "skipChannel" : 1,
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaSetChannel(const char* endpointId, long channelNumber) {
  Serial.print("Set channel on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(channelNumber);

  Serial.print("SET_CHANNEL=");
  Serial.println(channelNumber);
}

void applyAlexaSkipChannel(const char* endpointId, long channelOffset) {
  Serial.print("Skip channel on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(channelOffset);

  Serial.print("SKIP_CHANNEL=");
  Serial.println(channelOffset);
}

void handleAlexaChannelCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa channel command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst setChannelValue = root[offbeat::alexa::examples::kSetChannelKey];
  JsonVariantConst skipChannelValue = root[offbeat::alexa::examples::kSkipChannelKey];

  if (!setChannelValue.isNull()) {
    applyAlexaSetChannel(endpointId, offbeat::alexa::examples::readLong(setChannelValue));
  } else if (!skipChannelValue.isNull()) {
    applyAlexaSkipChannel(endpointId, offbeat::alexa::examples::readLong(skipChannelValue));
  } else {
    Serial.println("No Alexa channel payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
change channel 
{
  "endpointId" : "the endpoint id",
  "SetChannel" : 1
}
Arduino device example
void applyAlexaSetChannel(const char* endpointId, long channelNumber) {
  Serial.print("Set channel on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.println(channelNumber);

  Serial.print("SET_CHANNEL=");
  Serial.println(channelNumber);
}

void applyAlexaSkipChannel(const char* endpointId, long channelOffset) {
  Serial.print("Skip channel on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.println(channelOffset);

  Serial.print("SKIP_CHANNEL=");
  Serial.println(channelOffset);
}

void handleAlexaChannelCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa channel command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst setChannelValue = root[offbeat::alexa::examples::kSetChannelKey];
  JsonVariantConst skipChannelValue = root[offbeat::alexa::examples::kSkipChannelKey];

  if (!setChannelValue.isNull()) {
    applyAlexaSetChannel(endpointId, offbeat::alexa::examples::readLong(setChannelValue));
  } else if (!skipChannelValue.isNull()) {
    applyAlexaSkipChannel(endpointId, offbeat::alexa::examples::readLong(skipChannelValue));
  } else {
    Serial.println("No Alexa channel payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
set blind tilt 
{
  "setTiltPercent" : 60,
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaBlindTiltPercent(const char* endpointId, long tiltPercent) {
  long clampedTiltPercent = clampPercent(tiltPercent);
  long tiltDegrees = percentToDegrees(clampedTiltPercent);

  Serial.print("Set blind tilt on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.print(clampedTiltPercent);
  Serial.println("%");

  Serial.print("TILT_PERCENT=");
  Serial.println(clampedTiltPercent);
  Serial.print("TILT_DEGREES=");
  Serial.println(tiltDegrees);
}

void adjustAlexaBlindTiltPercent(const char* endpointId, long tiltPercentDelta) {
  Serial.print("Adjust blind tilt on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.print(tiltPercentDelta);
  Serial.println("%");

  Serial.print("TILT_DELTA_PERCENT=");
  Serial.println(tiltPercentDelta);
  Serial.println("Update your tracked tilt state before driving the motor.");
}

void handleAlexaBlindTiltCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa blind tilt command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst rangeValue = root[offbeat::alexa::examples::kRangeValueKey];
  JsonVariantConst rangeValueDelta = root[offbeat::alexa::examples::kRangeValueDeltaKey];

  if (!rangeValue.isNull()) {
    applyAlexaBlindTiltPercent(
        endpointId, offbeat::alexa::examples::readLong(rangeValue));
  } else if (!rangeValueDelta.isNull()) {
    adjustAlexaBlindTiltPercent(
        endpointId, offbeat::alexa::examples::readLong(rangeValueDelta));
  } else {
    Serial.println("No Alexa blind tilt payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
adjust blind tilt 
{
  "adjustTiltPercent" : 10,
  "endpointId" : "the endpoint id"
}
Arduino device example
void applyAlexaBlindTiltPercent(const char* endpointId, long tiltPercent) {
  long clampedTiltPercent = clampPercent(tiltPercent);
  long tiltDegrees = percentToDegrees(clampedTiltPercent);

  Serial.print("Set blind tilt on ");
  Serial.print(endpointId);
  Serial.print(" to ");
  Serial.print(clampedTiltPercent);
  Serial.println("%");

  Serial.print("TILT_PERCENT=");
  Serial.println(clampedTiltPercent);
  Serial.print("TILT_DEGREES=");
  Serial.println(tiltDegrees);
}

void adjustAlexaBlindTiltPercent(const char* endpointId, long tiltPercentDelta) {
  Serial.print("Adjust blind tilt on ");
  Serial.print(endpointId);
  Serial.print(" by ");
  Serial.print(tiltPercentDelta);
  Serial.println("%");

  Serial.print("TILT_DELTA_PERCENT=");
  Serial.println(tiltPercentDelta);
  Serial.println("Update your tracked tilt state before driving the motor.");
}

void handleAlexaBlindTiltCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa blind tilt command");
    return;
  }

  const char* endpointId = offbeat::alexa::examples::readEndpointId(root);
  JsonVariantConst rangeValue = root[offbeat::alexa::examples::kRangeValueKey];
  JsonVariantConst rangeValueDelta = root[offbeat::alexa::examples::kRangeValueDeltaKey];

  if (!rangeValue.isNull()) {
    applyAlexaBlindTiltPercent(
        endpointId, offbeat::alexa::examples::readLong(rangeValue));
  } else if (!rangeValueDelta.isNull()) {
    adjustAlexaBlindTiltPercent(
        endpointId, offbeat::alexa::examples::readLong(rangeValueDelta));
  } else {
    Serial.println("No Alexa blind tilt payload");
    return;
  }

  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
activate scene 
{
  "endpointId" : "the endpoint id",
  "scenestate" : "TurnOn"
}
Arduino device example
void applyAlexaSceneState(const char* endpointId, const char* sceneState) {
  Serial.print("Apply scene command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(sceneState);

  if (strcmp(sceneState, "TurnOn") == 0) {
    Serial.println("Activate the scene here");
  } else if (strcmp(sceneState, "TurnOff") == 0) {
    Serial.println("Deactivate the scene here");
  } else {
    Serial.println("Unsupported Alexa scene command");
    return;
  }

  Serial.print("SCENESTATE=");
  Serial.println(sceneState);
}

void handleAlexaSceneCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa scene command");
    return;
  }

  JsonVariantConst sceneStateValue = root[offbeat::alexa::examples::kSceneStateKey];
  if (sceneStateValue.isNull()) {
    Serial.println("No Alexa scene payload");
    return;
  }

  applyAlexaSceneState(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(sceneStateValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
deactivate scene 
{
  "endpointId" : "the endpoint id",
  "scenestate" : "TurnOff"
}
Arduino device example
void applyAlexaSceneState(const char* endpointId, const char* sceneState) {
  Serial.print("Apply scene command for ");
  Serial.print(endpointId);
  Serial.print(": ");
  Serial.println(sceneState);

  if (strcmp(sceneState, "TurnOn") == 0) {
    Serial.println("Activate the scene here");
  } else if (strcmp(sceneState, "TurnOff") == 0) {
    Serial.println("Deactivate the scene here");
  } else {
    Serial.println("Unsupported Alexa scene command");
    return;
  }

  Serial.print("SCENESTATE=");
  Serial.println(sceneState);
}

void handleAlexaSceneCommand(uint8_t* payload, size_t length) {
  StaticJsonDocument<256> document;
  JsonObjectConst root;
  offbeat::alexa::examples::ParseStatus status =
      offbeat::alexa::examples::parseRoot(payload, length, document, root);

  if (status == offbeat::alexa::examples::ParseStatus::kInvalidPayload) {
    Serial.println("Unable to parse Alexa scene command");
    return;
  }

  JsonVariantConst sceneStateValue = root[offbeat::alexa::examples::kSceneStateKey];
  if (sceneStateValue.isNull()) {
    Serial.println("No Alexa scene payload");
    return;
  }

  applyAlexaSceneState(
      offbeat::alexa::examples::readEndpointId(root),
      offbeat::alexa::examples::readString(sceneStateValue));
  offbeat::alexa::examples::printEndpoint(root);
  Serial.println("TEST:PASS");
}
Examples