denonavr 1.1.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

denonavr/denonavr.py

@@ -10,7 +10,7 @@ This module implements the interface to Denon AVR receivers.
 import asyncio
 import logging
 import time
-from typing import Awaitable, Callable, Dict, List, Literal, Optional, Union
+from typing import Callable, Dict, List, Literal, Optional, Union
 
 import attr
 import httpx
@@ -27,6 +27,7 @@ from .const import (
     EcoModes,
     HDMIAudioDecodes,
     HDMIOutputs,
+    Illuminations,
     PanelLocks,
     RoomSizes,
     TransducerLPFs,
@@ -232,14 +233,12 @@ class DenonAVR(DenonAVRFoundation):
         """Send telnet commands to the receiver."""
         self._device.telnet_api.send_commands(*commands)
 
-    def register_callback(
-        self, event: str, callback: Callable[[str, str, str], Awaitable[None]]
-    ):
+    def register_callback(self, event: str, callback: Callable[[str, str, str], None]):
         """Register a callback for telnet events."""
         self._device.telnet_api.register_callback(event, callback=callback)
 
     def unregister_callback(
-        self, event: str, callback: Callable[[str, str, str], Awaitable[None]]
+        self, event: str, callback: Callable[[str, str, str], None]
     ):
         """Unregister a callback for telnet events."""
         self._device.telnet_api.unregister_callback(event, callback=callback)
@@ -738,6 +737,26 @@ class DenonAVR(DenonAVRFoundation):
         """
         return self._device.headphone_eq
 
+    @property
+    def illumination(self) -> Optional[str]:
+        """
+        Return the illumination status for the device.
+
+        Only available on Marantz devices and when using Telnet.
+
+        Possible values are: "Auto", "Bright", "Dim", "Dark", "Off"
+        """
+        return self.illumination
+
+    @property
+    def auto_lip_sync(self) -> Optional[bool]:
+        """
+        Return the auto lip sync status for the device.
+
+        Only available on Marantz devices and when using Telnet.
+        """
+        return self.auto_lip_sync
+
     ##########
     # Getter #
     ##########
@@ -1210,3 +1229,43 @@ class DenonAVR(DenonAVRFoundation):
         :param quick_select_number: Quick select number to set. Valid values are 1-5.
         """
         await self._device.async_quick_select_memory(quick_select_number)
+
+    async def async_hdmi_cec_on(self) -> None:
+        """Turn on HDMI CEC on receiver via HTTP get command."""
+        await self._device.async_hdmi_cec_on()
+
+    async def async_hdmi_cec_off(self) -> None:
+        """Turn off HDMI CEC on receiver via HTTP get command."""
+        await self._device.async_hdmi_cec_off()
+
+    async def async_illumination(self, mode: Illuminations):
+        """
+        Set illumination mode on receiver via HTTP get command.
+
+        Only available for Marantz devices.
+        """
+        await self._device.async_illumination(mode)
+
+    async def async_auto_lip_sync_on(self) -> None:
+        """
+        Turn on auto lip sync on receiver via HTTP get command.
+
+        Only available on Marantz devices.
+        """
+        await self._device.async_auto_lip_sync_on()
+
+    async def async_auto_lip_sync_off(self) -> None:
+        """
+        Turn off auto lip sync on receiver via HTTP get command.
+
+        Only available on Marantz devices.
+        """
+        await self._device.async_auto_lip_sync_off()
+
+    async def async_auto_lip_sync_toggle(self) -> None:
+        """
+        Toggle auto lip sync on receiver via HTTP get command.
+
+        Only available on Marantz devices and when using Telnet.
+        """
+        await self._device.async_auto_lip_sync_toggle()

denonavr/dirac.py

@@ -35,14 +35,10 @@ class DenonAVRDirac(DenonAVRFoundation):
 
     def setup(self) -> None:
         """Ensure that the instance is initialized."""
-        self._device.telnet_api.register_callback(
-            "PS", self._async_dirac_filter_callback
-        )
+        self._device.telnet_api.register_callback("PS", self._dirac_filter_callback)
         self._is_setup = True
 
-    async def _async_dirac_filter_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _dirac_filter_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle Dirac filter change event."""
         if event == "PS" and parameter[0:5] == "DIRAC":
             self._dirac_filter = DIRAC_FILTER_MAP_LABELS[parameter[6:]]

denonavr/foundation.py

@@ -41,6 +41,8 @@ from .const import (
     ECO_MODE_MAP_LABELS,
     HDMI_OUTPUT_MAP,
     HDMI_OUTPUT_MAP_LABELS,
+    ILLUMINATION_MAP,
+    ILLUMINATION_MAP_LABELS,
     MAIN_ZONE,
     POWER_STATES,
     SETTINGS_MENU_STATES,
@@ -61,6 +63,7 @@ from .const import (
     EcoModes,
     HDMIAudioDecodes,
     HDMIOutputs,
+    Illuminations,
     PanelLocks,
     ReceiverType,
     ReceiverURLs,
@@ -220,6 +223,13 @@ class DenonAVRDeviceInfo:
     _headphone_eq: Optional[bool] = attr.ib(
         converter=attr.converters.optional(convert_on_off_bool), default=None
     )
+    _illumination: Optional[str] = attr.ib(
+        converter=attr.converters.optional(str), default=None
+    )
+    _illuminations = get_args(Illuminations)
+    _auto_lip_sync: Optional[bool] = attr.ib(
+        converter=attr.converters.optional(convert_on_off_bool), default=None
+    )
     _is_setup: bool = attr.ib(converter=bool, default=False, init=False)
     _allow_recovery: bool = attr.ib(converter=bool, default=True, init=True)
     _setup_lock: asyncio.Lock = attr.ib(default=attr.Factory(asyncio.Lock))
@@ -239,16 +249,12 @@ class DenonAVRDeviceInfo:
         else:
             raise ValueError(f"Invalid zone {self.zone}")
 
-    async def _async_power_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _power_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a power change event."""
         if self.zone == zone and parameter in POWER_STATES:
             self._power = parameter
 
-    async def _async_settings_menu_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _settings_menu_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a settings menu event."""
         if (
             event == "MN"
@@ -257,23 +263,17 @@ class DenonAVRDeviceInfo:
         ):
             self._settings_menu = parameter[4:]
 
-    async def _async_dimmer_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _dimmer_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a dimmer change event."""
         if event == "DIM" and parameter[1:] in DIMMER_MODE_MAP_LABELS:
             self._dimmer = DIMMER_MODE_MAP_LABELS[parameter[1:]]
 
-    async def _async_auto_standby_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _auto_standby_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a auto standby change event."""
         if zone == "Main" and event == "STBY":
             self._auto_standby = parameter
 
-    async def _async_auto_sleep_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _auto_sleep_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a sleep change event."""
         if event != "SLP":
             return
@@ -283,18 +283,14 @@ class DenonAVRDeviceInfo:
         else:
             self._sleep = int(parameter)
 
-    async def _async_room_size_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _room_size_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a room size change event."""
         if parameter[:3] != "RSZ":
             return
 
         self._room_size = parameter[4:]
 
-    async def _async_trigger_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _trigger_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a trigger change event."""
         if event != "TR":
             return
@@ -308,35 +304,29 @@ class DenonAVRDeviceInfo:
 
         self._triggers[int(values[0])] = values[1]
 
-    async def _async_delay_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _delay_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a delay change event."""
         if event == "PS" and parameter[0:5] == "DELAY":
             self._delay = int(parameter[6:])
 
-    async def _async_eco_mode_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _eco_mode_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an Eco-mode change event."""
         if event == "ECO" and parameter in ECO_MODE_MAP_LABELS:
             self._eco_mode = ECO_MODE_MAP_LABELS[parameter]
 
-    async def _async_hdmi_output_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _hdmi_output_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a HDMI output change event."""
         if event == "VS" and parameter[0:4] == "MONI":
             self._hdmi_output = HDMI_OUTPUT_MAP_LABELS[parameter]
 
-    async def _async_hdmi_audio_decode_callback(
+    def _hdmi_audio_decode_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a HDMI Audio Decode mode change event."""
         if event == "VS" and parameter[0:5] == "AUDIO":
             self._hdmi_audio_decode = parameter[6:]
 
-    async def _async_video_processing_mode_callback(
+    def _video_processing_mode_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a Video Processing Mode change event."""
@@ -345,7 +335,7 @@ class DenonAVRDeviceInfo:
                 parameter[3:]
             ]
 
-    async def _async_tactile_transducer_callback(
+    def _tactile_transducer_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a tactile transducer change event."""
@@ -365,9 +355,7 @@ class DenonAVRDeviceInfo:
         elif key == "TTRLPF":
             self._tactile_transducer_lpf = f"{int(value)} Hz"
 
-    async def _async_speaker_preset_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _speaker_preset_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a speaker preset change event."""
         if event != "SP":
             return
@@ -375,7 +363,7 @@ class DenonAVRDeviceInfo:
         if parameter[0:2] == "PR":
             self._speaker_preset = int(parameter[3:])
 
-    async def _async_bt_callback(self, zone: str, event: str, parameter: str) -> None:
+    def _bt_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Bluetooth change event."""
         if event != "BT" or parameter[0:2] != "TX":
             return
@@ -385,9 +373,7 @@ class DenonAVRDeviceInfo:
         else:
             self._bt_output_mode = BLUETOOTH_OUTPUT_MAP_LABELS[parameter[3:]]
 
-    async def _async_delay_time_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _delay_time_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a delay time change event."""
         # do not match "DELAY" as it's another event
         if event != "PS" or parameter[0:3] != "DEL" or parameter[0:5] == "DELAY":
@@ -395,33 +381,48 @@ class DenonAVRDeviceInfo:
 
         self._delay_time = int(parameter[4:])
 
-    async def _async_audio_restorer_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _audio_restorer_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an audio restorer change event."""
         if event != "PS" or parameter[0:4] != "RSTR":
             return
 
         self._audio_restorer = AUDIO_RESTORER_MAP_LABELS[parameter[5:]]
 
-    async def _async_graphic_eq_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _graphic_eq_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Graphic EQ change event."""
         if parameter[0:3] != "GEQ":
             return
 
         self._graphic_eq = parameter[4:]
 
-    async def _async_headphone_eq_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _headphone_eq_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Headphone EQ change event."""
         if parameter[0:3] != "HEQ":
             return
 
         self._headphone_eq = parameter[4:]
 
+    def _illumination_callback(self, zone: str, event: str, parameter: str) -> None:
+        """Handle an illumination change event."""
+        if event != "ILB" or parameter[0:3] != "ILL":
+            return
+
+        self._illumination = ILLUMINATION_MAP_LABELS[parameter[4:]]
+
+    def _auto_lip_sync_callback(self, zone: str, event: str, parameter: str) -> None:
+        """Handle a auto lip sync change event."""
+        if event != "PS" or parameter[0:3] != "HOS":
+            return
+
+        if parameter[6:] == "HOSALS":
+            auto_lip_sync = parameter[5:]
+        elif parameter[3:] == "HOS":
+            auto_lip_sync = parameter[4:]
+        else:
+            return
+
+        self._auto_lip_sync = auto_lip_sync
+
     def get_own_zone(self) -> str:
         """
         Get zone from actual instance.
@@ -459,32 +460,32 @@ class DenonAVRDeviceInfo:
                 power_event = "Z2"
             elif self.zone == ZONE3:
                 power_event = "Z3"
-            self.telnet_api.register_callback(power_event, self._async_power_callback)
-
-            self.telnet_api.register_callback("MN", self._async_settings_menu_callback)
-            self.telnet_api.register_callback("DIM", self._async_dimmer_callback)
-            self.telnet_api.register_callback("PS", self._async_delay_callback)
-            self.telnet_api.register_callback("ECO", self._async_eco_mode_callback)
-            self.telnet_api.register_callback("VS", self._async_hdmi_output_callback)
-            self.telnet_api.register_callback(
-                "VS", self._async_hdmi_audio_decode_callback
-            )
-            self.telnet_api.register_callback(
-                "VS", self._async_video_processing_mode_callback
-            )
+            self.telnet_api.register_callback(power_event, self._power_callback)
+
+            self.telnet_api.register_callback("MN", self._settings_menu_callback)
+            self.telnet_api.register_callback("DIM", self._dimmer_callback)
+            self.telnet_api.register_callback("PS", self._delay_callback)
+            self.telnet_api.register_callback("ECO", self._eco_mode_callback)
+            self.telnet_api.register_callback("VS", self._hdmi_output_callback)
+            self.telnet_api.register_callback("VS", self._hdmi_audio_decode_callback)
             self.telnet_api.register_callback(
-                "SS", self._async_tactile_transducer_callback
-            )
-            self.telnet_api.register_callback("STBY", self._async_auto_standby_callback)
-            self.telnet_api.register_callback("SLP", self._async_auto_sleep_callback)
-            self.telnet_api.register_callback("PS", self._async_room_size_callback)
-            self.telnet_api.register_callback("TR", self._async_trigger_callback)
-            self.telnet_api.register_callback("SP", self._async_speaker_preset_callback)
-            self.telnet_api.register_callback("BT", self._async_bt_callback)
-            self.telnet_api.register_callback("PS", self._async_delay_time_callback)
-            self.telnet_api.register_callback("PS", self._async_audio_restorer_callback)
-            self.telnet_api.register_callback("PS", self._async_graphic_eq_callback)
-            self.telnet_api.register_callback("PS", self._async_headphone_eq_callback)
+                "VS", self._video_processing_mode_callback
+            )
+            self.telnet_api.register_callback("SS", self._tactile_transducer_callback)
+            self.telnet_api.register_callback("STBY", self._auto_standby_callback)
+            self.telnet_api.register_callback("SLP", self._auto_sleep_callback)
+            self.telnet_api.register_callback("PS", self._room_size_callback)
+            self.telnet_api.register_callback("TR", self._trigger_callback)
+            self.telnet_api.register_callback("SP", self._speaker_preset_callback)
+            self.telnet_api.register_callback("BT", self._bt_callback)
+            self.telnet_api.register_callback("PS", self._delay_time_callback)
+            self.telnet_api.register_callback("PS", self._audio_restorer_callback)
+            self.telnet_api.register_callback("PS", self._graphic_eq_callback)
+            self.telnet_api.register_callback("PS", self._headphone_eq_callback)
+
+            if not self.is_denon:
+                self.telnet_api.register_callback("ILB", self._illumination_callback)
+                self.telnet_api.register_callback("SS", self._auto_lip_sync_callback)
 
             self._is_setup = True
             _LOGGER.debug("Finished device setup")
@@ -729,6 +730,7 @@ class DenonAVRDeviceInfo:
 
         if device_info is None:
             self.manufacturer = "Denon"
+            self.telnet_api.is_denon = self.is_denon
             self.model_name = "Unknown"
             self.serial_number = None
             _LOGGER.warning(
@@ -744,6 +746,7 @@ class DenonAVRDeviceInfo:
         if self.friendly_name is None and "friendlyName" in device_info:
             self.friendly_name = device_info["friendlyName"]
         self.manufacturer = device_info["manufacturer"]
+        self.telnet_api.is_denon = self.is_denon
         self.model_name = device_info["modelName"]
         self.serial_number = device_info["serialNumber"]
 
@@ -1051,11 +1054,36 @@ class DenonAVRDeviceInfo:
         """
         return self._headphone_eq
 
+    @property
+    def illumination(self) -> Optional[str]:
+        """
+        Return the illumination status for the device.
+
+        Only available on Marantz devices and when using Telnet.
+
+        Possible values are: "Auto", "Bright", "Dim", "Dark", "Off"
+        """
+        return self._illumination
+
+    @property
+    def auto_lip_sync(self) -> Optional[bool]:
+        """
+        Return the auto lip sync status for the device.
+
+        Only available on Marantz devices and when using Telnet.
+        """
+        return self._auto_lip_sync
+
     @property
     def telnet_available(self) -> bool:
         """Return true if telnet is connected and healthy."""
         return self.telnet_api.connected and self.telnet_api.healthy
 
+    @property
+    def is_denon(self) -> bool:
+        """Return true if the receiver is a Denon device."""
+        return "denon" in self.manufacturer.lower()
+
     ##########
     # Getter #
     ##########
@@ -1402,15 +1430,15 @@ class DenonAVRDeviceInfo:
             raise AvrCommandError("Quick select number must be between 1 and 5")
 
         if self.telnet_available:
-            if "denon" in self.manufacturer.lower():
-                command = self.telnet_commands.command_quick_select_memory
+            if self.is_denon:
+                command = self.telnet_commands.command_quick_select_mode
             else:
-                command = self.telnet_commands.command_smart_select_memory
+                command = self.telnet_commands.command_smart_select_mode
             await self.telnet_api.async_send_commands(
                 command.format(number=quick_select_number)
             )
         else:
-            if "denon" in self.manufacturer.lower():
+            if self.is_denon:
                 command = self.urls.command_quick_select_mode
             else:
                 command = self.urls.command_smart_select_mode
@@ -1426,15 +1454,15 @@ class DenonAVRDeviceInfo:
             raise AvrCommandError("Quick select number must be between 1 and 5")
 
         if self.telnet_available:
-            if "denon" in self.manufacturer.lower():
-                command = self.telnet_commands.command_quick_select_mode
+            if self.is_denon:
+                command = self.telnet_commands.command_quick_select_memory
             else:
-                command = self.telnet_commands.command_smart_select_mode
+                command = self.telnet_commands.command_smart_select_memory
             await self.telnet_api.async_send_commands(
                 command.format(number=quick_select_number)
             )
         else:
-            if "denon" in self.manufacturer.lower():
+            if self.is_denon:
                 command = self.urls.command_quick_select_memory
             else:
                 command = self.urls.command_smart_select_memory
@@ -1518,11 +1546,17 @@ class DenonAVRDeviceInfo:
                 self.urls.command_video_processing_mode.format(mode=processing_mode)
             )
 
-    async def async_status(self) -> str:
+    async def async_status(self) -> None:
         """Get status of receiver via HTTP get command."""
-        if "denon" not in self.manufacturer.lower():
+        if not self.is_denon:
             raise AvrCommandError("Status command is only supported for Denon devices")
-        return await self.api.async_get_command(self.urls.command_status)
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_status
+            )
+        else:
+            await self.api.async_get_command(self.urls.command_status)
 
     async def async_system_reset(self) -> None:
         """DANGER! Reset the receiver via HTTP get command."""
@@ -1812,6 +1846,108 @@ class DenonAVRDeviceInfo:
         else:
             await self.async_headphone_eq_on()
 
+    async def async_hdmi_cec_on(self) -> None:
+        """Turn on HDMI CEC on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_denon_hdmi_cec_on
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_on
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_denon_hdmi_cec_on
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_on
+            )
+
+    async def async_hdmi_cec_off(self) -> None:
+        """Turn off HDMI CEC on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_denon_hdmi_cec_off
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_off
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_denon_hdmi_cec_off
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_off
+            )
+
+    async def async_illumination(self, mode: Illuminations):
+        """
+        Set illumination mode on receiver via HTTP get command.
+
+        Only available on Marantz devices.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Illumination is only available for Marantz devices")
+
+        if mode not in self._illuminations:
+            raise AvrCommandError("Invalid illumination mode")
+
+        mapped_mode = ILLUMINATION_MAP[mode]
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_illumination.format(mode=mapped_mode)
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_illumination.format(mode=mapped_mode)
+            )
+
+    async def async_auto_lip_sync_on(self) -> None:
+        """
+        Turn on auto lip sync on receiver via HTTP get command.
+
+        Only available on Marantz devices.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Auto lip sync is only available for Marantz devices")
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_auto_lip_sync.format(mode="ON")
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_auto_lip_sync.format(mode="ON")
+            )
+
+    async def async_auto_lip_sync_off(self) -> None:
+        """
+        Turn off auto lip sync on receiver via HTTP get command.
+
+        Only available on Marantz devices.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Auto lip sync is only available for Marantz devices")
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_auto_lip_sync.format(mode="OFF")
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_auto_lip_sync.format(mode="OFF")
+            )
+
+    async def async_auto_lip_sync_toggle(self) -> None:
+        """
+        Toggle auto lip sync on receiver via HTTP get command.
+
+        Only available on Marantz devices and when using Telnet.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Auto lip sync is only available for Marantz devices")
+
+        if self._auto_lip_sync:
+            await self.async_auto_lip_sync_off()
+        else:
+            await self.async_auto_lip_sync_on()
+
 
 @attr.s(auto_attribs=True, on_setattr=DENON_ATTR_SETATTR)
 class DenonAVRFoundation: