conson-xp 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

xp/cli/commands/conbus/conbus_linknumber_commands.py

@@ -9,9 +9,12 @@ from xp.cli.utils.decorators import (
     connection_command,
 )
 from xp.cli.utils.serial_number_type import SERIAL
-from xp.models.conbus.conbus_linknumber import ConbusLinknumberResponse
-from xp.services.conbus.conbus_linknumber_get_service import ConbusLinknumberGetService
-from xp.services.conbus.conbus_linknumber_set_service import ConbusLinknumberSetService
+from xp.models import ConbusDatapointResponse
+from xp.models.conbus.conbus_writeconfig import ConbusWriteConfigResponse
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
+from xp.services.conbus.write_config_service import WriteConfigService
+from xp.services.telegram.telegram_datapoint_service import TelegramDatapointService
 
 
 @conbus_linknumber.command("set", short_help="Set link number for a module")
@@ -33,23 +36,27 @@ def set_linknumber_command(
         \b
         xp conbus linknumber set 0123450001 25
     """
-    service = (
-        ctx.obj.get("container").get_container().resolve(ConbusLinknumberSetService)
-    )
 
-    def on_finish(response: ConbusLinknumberResponse) -> None:
-        """Handle successful completion of link number set command.
+    def on_finish(response: "ConbusWriteConfigResponse") -> None:
+        """Handle successful completion of light level on command.
 
         Args:
-            response: Link number response object.
+            response: Light level response object.
         """
         click.echo(json.dumps(response.to_dict(), indent=2))
 
+    service: WriteConfigService = (
+        ctx.obj.get("container").get_container().resolve(WriteConfigService)
+    )
+
+    data_value = f"{link_number: 02d}"
     with service:
-        service.set_linknumber(
+        service.write_config(
             serial_number=serial_number,
-            link_number=link_number,
+            datapoint_type=DataPointType.LINK_NUMBER,
+            data_value=data_value,
             finish_callback=on_finish,
+            timeout_seconds=0.5,
         )
 
 
@@ -68,20 +75,28 @@ def get_linknumber_command(ctx: click.Context, serial_number: str) -> None:
         \b
         xp conbus linknumber get 0123450001
     """
-    service = (
-        ctx.obj.get("container").get_container().resolve(ConbusLinknumberGetService)
+    service: ConbusDatapointService = (
+        ctx.obj.get("container").get_container().resolve(ConbusDatapointService)
+    )
+    telegram_service: TelegramDatapointService = (
+        ctx.obj.get("container").get_container().resolve(TelegramDatapointService)
     )
 
-    def on_finish(response: ConbusLinknumberResponse) -> None:
+    def on_finish(service_response: ConbusDatapointResponse) -> None:
         """Handle successful completion of link number get command.
 
         Args:
-            response: Link number response object.
+            service_response: Link number response object.
         """
-        click.echo(json.dumps(response.to_dict(), indent=2))
+        linknumber_value = telegram_service.get_linknumber(service_response.data_value)
+        result = service_response.to_dict()
+        result["linknumber_value"] = linknumber_value
+        click.echo(json.dumps(result, indent=2))
 
     with service:
-        service.get_linknumber(
+        service.query_datapoint(
             serial_number=serial_number,
+            datapoint_type=DataPointType.LINK_NUMBER,
             finish_callback=on_finish,
+            timeout_seconds=0.5,
         )

xp/cli/commands/conbus/conbus_msactiontable_commands.py

@@ -2,6 +2,7 @@
 
 import json
 from dataclasses import asdict
+from typing import Union
 
 import click
 from click import Context
@@ -12,7 +13,9 @@ from xp.cli.utils.decorators import (
 )
 from xp.cli.utils.serial_number_type import SERIAL
 from xp.cli.utils.xp_module_type import XP_MODULE_TYPE
-from xp.models.actiontable.actiontable import ActionTable
+from xp.models.actiontable.msactiontable_xp20 import Xp20MsActionTable
+from xp.models.actiontable.msactiontable_xp24 import Xp24MsActionTable
+from xp.models.actiontable.msactiontable_xp33 import Xp33MsActionTable
 from xp.services.conbus.actiontable.msactiontable_service import (
     MsActionTableService,
 )
@@ -33,7 +36,9 @@ def conbus_download_msactiontable(
         serial_number: 10-digit module serial number.
         xpmoduletype: XP module type.
     """
-    service = ctx.obj.get("container").get_container().resolve(MsActionTableService)
+    service: MsActionTableService = (
+        ctx.obj.get("container").get_container().resolve(MsActionTableService)
+    )
 
     def progress_callback(progress: str) -> None:
         """Handle progress updates during MS action table download.
@@ -43,7 +48,9 @@ def conbus_download_msactiontable(
         """
         click.echo(progress, nl=False)
 
-    def finish_callback(action_table: ActionTable) -> None:
+    def on_finish(
+        action_table: Union[Xp20MsActionTable | Xp24MsActionTable | Xp33MsActionTable],
+    ) -> None:
         """Handle successful completion of MS action table download.
 
         Args:
@@ -73,6 +80,6 @@ def conbus_download_msactiontable(
             serial_number=serial_number,
             xpmoduletype=xpmoduletype,
             progress_callback=progress_callback,
-            finish_callback=finish_callback,
+            finish_callback=on_finish,
             error_callback=error_callback,
         )

xp/cli/commands/conbus/conbus_output_commands.py

@@ -34,7 +34,9 @@ def xp_output_on(ctx: click.Context, serial_number: str, output_number: int) ->
         \b
         xp conbus output on 0011223344 0  # Turn on output 0
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusOutputService)
+    service: ConbusOutputService = (
+        ctx.obj.get("container").get_container().resolve(ConbusOutputService)
+    )
 
     def on_finish(response: ConbusOutputResponse) -> None:
         """Handle successful completion of output on command.
@@ -70,7 +72,9 @@ def xp_output_off(ctx: click.Context, serial_number: str, output_number: int) ->
         \b
         xp conbus output off 0011223344 1    # Turn off output 1
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusOutputService)
+    service: ConbusOutputService = (
+        ctx.obj.get("container").get_container().resolve(ConbusOutputService)
+    )
 
     def on_finish(response: ConbusOutputResponse) -> None:
         """Handle successful completion of output off command.

xp/cli/commands/conbus/conbus_receive_commands.py

@@ -36,7 +36,7 @@ def receive_telegrams(ctx: Context, timeout: float) -> None:
         xp conbus receive 5.0
     """
 
-    def finish(response_received: ConbusReceiveResponse) -> None:
+    def on_finish(response_received: ConbusReceiveResponse) -> None:
         """Handle successful completion of telegram receive operation.
 
         Args:
@@ -52,6 +52,8 @@ def receive_telegrams(ctx: Context, timeout: float) -> None:
         """
         click.echo(telegram_received)
 
-    service = ctx.obj.get("container").get_container().resolve(ConbusReceiveService)
+    service: ConbusReceiveService = (
+        ctx.obj.get("container").get_container().resolve(ConbusReceiveService)
+    )
     with service:
-        service.start(progress, finish, timeout)
+        service.start(progress, on_finish, timeout)

xp/cli/commands/file_commands.py

@@ -56,7 +56,9 @@ def decode_log_file(
     from xp.services.log_file_service import LogFileService
     from xp.utils.time_utils import TimeParsingError, parse_time_range
 
-    service = ctx.obj.get("container").get_container().resolve(LogFileService)
+    service: LogFileService = (
+        ctx.obj.get("container").get_container().resolve(LogFileService)
+    )
     StatisticsFormatter(True)
 
     try:
@@ -124,7 +126,9 @@ def analyze_log_file(ctx: Context, log_file_path: str) -> None:
     """
     from xp.services.log_file_service import LogFileService
 
-    service = ctx.obj.get("container").get_container().resolve(LogFileService)
+    service: LogFileService = (
+        ctx.obj.get("container").get_container().resolve(LogFileService)
+    )
     StatisticsFormatter(True)
 
     try:
@@ -156,7 +160,9 @@ def validate_log_file(ctx: Context, log_file_path: str) -> None:
     """
     from xp.services.log_file_service import LogFileService
 
-    service = ctx.obj.get("container").get_container().resolve(LogFileService)
+    service: LogFileService = (
+        ctx.obj.get("container").get_container().resolve(LogFileService)
+    )
     OutputFormatter(True)
 
     try:

xp/cli/commands/homekit/homekit_start_commands.py

@@ -28,7 +28,9 @@ def homekit_start(ctx: Context) -> None:
     click.echo("Starting XP Protocol HomeKit server...")
 
     try:
-        service = ctx.obj.get("container").get_container().resolve(HomeKitService)
+        service: HomeKitService = (
+            ctx.obj.get("container").get_container().resolve(HomeKitService)
+        )
         service.start()  # Blocking call - reactor.run() never returns
 
     except KeyboardInterrupt:

xp/cli/commands/module_commands.py

@@ -37,7 +37,9 @@ def module_info(ctx: Context, identifier: str) -> None:
         xp module info 14
         xp module info XP2606
     """
-    service = ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    service: ModuleTypeService = (
+        ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    )
     OutputFormatter(True)
 
     try:
@@ -76,7 +78,9 @@ def module_list(ctx: Context, category: str, group_by_category: bool) -> None:
         xp module list --category "Interface Panels"
         xp module list --group-by-category
     """
-    service = ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    service: ModuleTypeService = (
+        ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    )
     ListFormatter(True)
 
     try:
@@ -130,7 +134,9 @@ def module_search(ctx: Context, query: str, field: tuple) -> None:
         xp module search "push button"
         xp module search --field name "XP"
     """
-    service = ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    service: ModuleTypeService = (
+        ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    )
     ListFormatter(True)
 
     try:
@@ -162,7 +168,9 @@ def module_categories(ctx: Context) -> None:
         \b
         xp module categories
     """
-    service = ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    service: ModuleTypeService = (
+        ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    )
     OutputFormatter(True)
 
     try:

xp/cli/commands/reverse_proxy_commands.py

@@ -73,7 +73,9 @@ def start_proxy(ctx: Context, port: int, config: str) -> None:
             raise SystemExit(1)
 
         # Load configuration and create proxy instance
-        service = ctx.obj.get("container").get_container().resolve(ReverseProxyService)
+        service: ReverseProxyService = (
+            ctx.obj.get("container").get_container().resolve(ReverseProxyService)
+        )
         global_proxy_instance = service
 
         # Handle graceful shutdown on SIGINT

xp/cli/main.py

@@ -6,7 +6,6 @@ import click
 from click_help_colors import HelpColorsGroup
 
 from xp.cli.commands import homekit
-from xp.cli.commands.api import api
 from xp.cli.commands.conbus.conbus import conbus
 from xp.cli.commands.file_commands import file
 from xp.cli.commands.module_commands import module
@@ -79,7 +78,6 @@ cli.add_command(telegram)
 cli.add_command(module)
 cli.add_command(file)
 cli.add_command(server)
-cli.add_command(api)
 cli.add_command(reverse_proxy)
 
 # Add the tree command

xp/models/conbus/conbus_datapoint.py

@@ -21,6 +21,7 @@ class ConbusDatapointResponse:
         sent_telegram: Telegram sent to device.
         received_telegrams: List of telegrams received.
         datapoint_telegram: Parsed datapoint telegram.
+        data_value: Value of the datapoint telegram.
         datapoints: List of datapoint values.
         error: Error message if operation failed.
         timestamp: Timestamp of the response.
@@ -33,6 +34,7 @@ class ConbusDatapointResponse:
     sent_telegram: Optional[str] = None
     received_telegrams: Optional[list] = None
     datapoint_telegram: Optional[ReplyTelegram] = None
+    data_value: str = ""
     datapoints: Optional[List[Dict[str, str]]] = None
     error: Optional[str] = None
     timestamp: Optional[datetime] = None
@@ -55,6 +57,7 @@ class ConbusDatapointResponse:
         result: Dict[str, Any] = {
             "success": self.success,
             "serial_number": self.serial_number,
+            "data_value": self.data_value,
             "error": self.error,
             "timestamp": self.timestamp.isoformat() if self.timestamp else None,
         }

xp/models/conbus/conbus_writeconfig.py

@@ -0,0 +1,60 @@
+"""Conbus link number response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.system_function import SystemFunction
+
+
+@dataclass
+class ConbusWriteConfigResponse:
+    """Represents a response from Conbus write config operations (set/get).
+
+    Attributes:
+        success: Whether the operation was successful.
+        serial_number: Serial number of the device.
+        datapoint_type: the datapoint to write.
+        system_function: ACK or NAK received.
+        sent_telegram: Telegram sent to device.
+        received_telegrams: List of telegrams received.
+        data_value: written value.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    serial_number: str
+    datapoint_type: Optional[DataPointType] = None
+    system_function: Optional[SystemFunction] = None
+    sent_telegram: Optional[str] = None
+    received_telegrams: Optional[list] = None
+    data_value: Optional[str] = None
+    error: Optional[str] = None
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp and received_telegrams if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+        if self.received_telegrams is None:
+            self.received_telegrams = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        return {
+            "success": self.success,
+            "system_function": self.system_function,
+            "datapoint_type": self.datapoint_type,
+            "data_value": self.data_value,
+            "serial_number": self.serial_number,
+            "sent_telegram": self.sent_telegram,
+            "received_telegrams": self.received_telegrams,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

xp/services/conbus/conbus_datapoint_service.py

@@ -44,7 +44,9 @@ class ConbusDatapointService(ConbusProtocol):
         self.telegram_service = telegram_service
         self.serial_number: str = ""
         self.datapoint_type: Optional[DataPointType] = None
-        self.finish_callback: Optional[Callable[[ConbusDatapointResponse], None]] = None
+        self.datapoint_finished_callback: Optional[
+            Callable[[ConbusDatapointResponse], None]
+        ] = None
         self.service_response: ConbusDatapointResponse = ConbusDatapointResponse(
             success=False,
             serial_number=self.serial_number,
@@ -125,8 +127,9 @@ class ConbusDatapointService(ConbusProtocol):
         self.service_response.system_function = SystemFunction.READ_DATAPOINT
         self.service_response.datapoint_type = self.datapoint_type
         self.service_response.datapoint_telegram = datapoint_telegram
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        self.service_response.data_value = datapoint_telegram.data_value
+        if self.datapoint_finished_callback:
+            self.datapoint_finished_callback(self.service_response)
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -139,8 +142,8 @@ class ConbusDatapointService(ConbusProtocol):
         self.service_response.timestamp = datetime.now()
         self.service_response.serial_number = self.serial_number
         self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        if self.datapoint_finished_callback:
+            self.datapoint_finished_callback(self.service_response)
 
     def query_datapoint(
         self,
@@ -160,7 +163,7 @@ class ConbusDatapointService(ConbusProtocol):
         self.logger.info("Starting query_datapoint")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
+        self.datapoint_finished_callback = finish_callback
         self.serial_number = serial_number
         self.datapoint_type = datapoint_type
         self.start_reactor()

xp/services/conbus/{conbus_linknumber_set_service.py → write_config_service.py}

@@ -10,7 +10,7 @@ from typing import Callable, Optional
 from twisted.internet.posixbase import PosixReactorBase
 
 from xp.models import ConbusClientConfig
-from xp.models.conbus.conbus_linknumber import ConbusLinknumberResponse
+from xp.models.conbus.conbus_writeconfig import ConbusWriteConfigResponse
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.system_function import SystemFunction
@@ -19,11 +19,11 @@ from xp.services.protocol import ConbusProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ConbusLinknumberSetService(ConbusProtocol):
+class WriteConfigService(ConbusProtocol):
     """
-    Service for setting module link numbers via Conbus telegrams.
+    Service for writing module settings via Conbus telegrams.
 
-    Handles link number assignment by sending F04D04 telegrams and processing
+    Handles setting assignment by sending F04DXX telegrams and processing
     ACK/NAK responses from modules.
     """
 
@@ -42,13 +42,17 @@ class ConbusLinknumberSetService(ConbusProtocol):
         """
         super().__init__(cli_config, reactor)
         self.telegram_service = telegram_service
+        self.datapoint_type: Optional[DataPointType] = None
         self.serial_number: str = ""
-        self.link_number: int = 0
-        self.finish_callback: Optional[Callable[[ConbusLinknumberResponse], None]] = (
-            None
-        )
-        self.service_response: ConbusLinknumberResponse = ConbusLinknumberResponse(
-            success=False, serial_number=self.serial_number, result=""
+        self.data_value: str = ""
+        self.write_config_finished_callback: Optional[
+            Callable[[ConbusWriteConfigResponse], None]
+        ] = None
+        self.write_config_response: ConbusWriteConfigResponse = (
+            ConbusWriteConfigResponse(
+                success=False,
+                serial_number=self.serial_number,
+            )
         )
 
         # Set up logging
@@ -56,26 +60,30 @@ class ConbusLinknumberSetService(ConbusProtocol):
 
     def connection_established(self) -> None:
         """Handle connection established event."""
-        self.logger.debug(
-            f"Connection established, setting link number {self.link_number}."
-        )
+        self.logger.debug(f"Connection established, writing config {self.data_value}.")
 
         # Validate parameters before sending
         if not self.serial_number or len(self.serial_number) != 10:
             self.failed(f"Serial number must be 10 digits, got: {self.serial_number}")
             return
 
-        if not (0 <= self.link_number <= 99):
-            self.failed(f"Link number must be between 0-99, got: {self.link_number}")
+        if len(self.data_value) < 2:
+            self.failed(f"data_value must be at least 2 bytes, got: {self.data_value}")
+            return
+
+        if not self.datapoint_type:
+            self.failed(f"datapoint_type must be defined, got: {self.datapoint_type}")
             return
 
-        # Send F04D04{link_number} telegram
-        # F04 = WRITE_CONFIG, D04 = LINK_NUMBER datapoint type
+        # Send WRITE_CONFIG telegram
+        # Function F04 = WRITE_CONFIG,
+        # Datapoint = D datapoint_type
+        # Data = XX
         self.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
             system_function=SystemFunction.WRITE_CONFIG,
-            data_value=f"{DataPointType.LINK_NUMBER.value}{self.link_number:02d}",
+            data_value=f"{self.datapoint_type.value}{self.data_value}",
         )
 
     def telegram_sent(self, telegram_sent: str) -> None:
@@ -84,7 +92,7 @@ class ConbusLinknumberSetService(ConbusProtocol):
         Args:
             telegram_sent: The telegram that was sent.
         """
-        self.service_response.sent_telegram = telegram_sent
+        self.write_config_response.sent_telegram = telegram_sent
 
     def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
         """Handle telegram received event.
@@ -94,9 +102,9 @@ class ConbusLinknumberSetService(ConbusProtocol):
         """
         self.logger.debug(f"Telegram received: {telegram_received}")
 
-        if not self.service_response.received_telegrams:
-            self.service_response.received_telegrams = []
-        self.service_response.received_telegrams.append(telegram_received.frame)
+        if not self.write_config_response.received_telegrams:
+            self.write_config_response.received_telegrams = []
+        self.write_config_response.received_telegrams.append(telegram_received.frame)
 
         if (
             not telegram_received.checksum_valid
@@ -111,71 +119,75 @@ class ConbusLinknumberSetService(ConbusProtocol):
             telegram_received.frame
         )
 
-        if not reply_telegram:
-            self.logger.debug("Failed to parse reply telegram")
+        if not reply_telegram or reply_telegram.system_function not in (
+            SystemFunction.ACK,
+            SystemFunction.NAK,
+        ):
+            self.logger.debug("Not a write config reply")
             return
 
-        # Check for ACK or NAK response
-        if reply_telegram.system_function == SystemFunction.ACK:
-            self.logger.debug("Received ACK response")
-            self.succeed(SystemFunction.ACK)
-        elif reply_telegram.system_function == SystemFunction.NAK:
-            self.logger.debug("Received NAK response")
-            self.failed("Module responded with NAK")
-        else:
-            self.logger.debug(
-                f"Unexpected system function: {reply_telegram.system_function}"
-            )
+        succeed = (
+            True if reply_telegram.system_function == SystemFunction.ACK else False
+        )
+        self.finished(
+            succeed_or_failed=succeed, system_function=reply_telegram.system_function
+        )
 
-    def succeed(self, system_function: SystemFunction) -> None:
-        """Handle successful link number set operation.
+    def failed(self, message: str) -> None:
+        """Handle telegram failed event.
 
         Args:
-            system_function: The system function from the reply telegram.
+            message: The error message.
         """
-        self.logger.debug("Successfully set link number")
-        self.service_response.success = True
-        self.service_response.timestamp = datetime.now()
-        self.service_response.serial_number = self.serial_number
-        self.service_response.result = "ACK"
-        self.service_response.link_number = self.link_number
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        self.logger.debug("Failed to send telegram")
+        self.finished(succeed_or_failed=False, message=message)
 
-    def failed(self, message: str) -> None:
-        """Handle failed connection event.
+    def finished(
+        self,
+        succeed_or_failed: bool,
+        message: Optional[str] = None,
+        system_function: Optional[SystemFunction] = None,
+    ) -> None:
+        """Handle successful link number set operation.
 
         Args:
-            message: Failure message.
+            succeed_or_failed: succeed true, failed false.
+            message: error message if any.
+            system_function: The system function from the reply telegram.
         """
-        self.logger.debug(f"Failed with message: {message}")
-        self.service_response.success = False
-        self.service_response.timestamp = datetime.now()
-        self.service_response.serial_number = self.serial_number
-        self.service_response.result = "NAK"
-        self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
-
-    def set_linknumber(
+        self.logger.debug("finished writing config")
+        self.write_config_response.success = succeed_or_failed
+        self.write_config_response.error = message
+        self.write_config_response.timestamp = datetime.now()
+        self.write_config_response.serial_number = self.serial_number
+        self.write_config_response.system_function = system_function
+        self.write_config_response.datapoint_type = self.datapoint_type
+        self.write_config_response.data_value = self.data_value
+        if self.write_config_finished_callback:
+            self.write_config_finished_callback(self.write_config_response)
+
+    def write_config(
         self,
         serial_number: str,
-        link_number: int,
-        finish_callback: Callable[[ConbusLinknumberResponse], None],
+        datapoint_type: DataPointType,
+        data_value: str,
+        finish_callback: Callable[[ConbusWriteConfigResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
-        """Set the link number for a specific module.
+        """Write config to a specific module.
 
         Args:
             serial_number: 10-digit module serial number.
-            link_number: Link number to set (0-99).
+            datapoint_type: the datapoint type to write to.
+            data_value: the data to write.
             finish_callback: Callback function to call when operation completes.
             timeout_seconds: Optional timeout in seconds.
         """
-        self.logger.info("Starting set_linknumber")
+        self.logger.info("Starting write_config")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
         self.serial_number = serial_number
-        self.link_number = link_number
-        self.finish_callback = finish_callback
+        self.datapoint_type = datapoint_type
+        self.data_value = data_value
+        self.write_config_finished_callback = finish_callback
         self.start_reactor()