Send a proper CALL

[gconceicao]

I am trying to sending a CALL function to charge point but I'm facing some issues to receive the answers of the CP.

Follow the code to suport the solution.

class CentralSystem:
def init(self):
self.connections = {} # Dicionário de conexões ativas
self.connection_events = {}
self.last_activity = {}
self.logger = Logger.Logger()
self.server = None # Adiciona referência ao servidor

async def on_connect(self, websocket):  # Remove path parameter
    """Handler para novas conexões de estações"""
    try:

        if websocket.subprotocol:
            logger.info("Protocols Matched: %s", websocket.subprotocol)
        else:
            logger.warning(
                "Protocols Mismatched | Expected Subprotocols: %s, "
                "but client did not negotiate subprotocol. Closing connection.",
                websocket.available_subprotocols,
            )
            return await websocket.close()
        
        base_path = "/ocpp"
        path = websocket.request.path
        
        if not path.startswith(base_path):
            logger.info(f"Invalid path: {path}")
            return await websocket.close(code=4000, reason="Invalid path")

        charge_point_id = path[len(base_path):].strip("/")

        # Verifica se já está conectado
        if charge_point_id in self.connections:
            self.logger.warning(f"Charge Point {charge_point_id} já conectado")
            await websocket.close(code=4002, reason="Charge Point already connected")
            return
        
        # Cria e registra a nova conexão
        cp = ChargePoint(charge_point_id, websocket, self)
        self.connections[charge_point_id] = cp
        self.connection_events[charge_point_id] = asyncio.Event()
        self.last_activity[charge_point_id] = time.time()

        self.logger.info(f"Estação {charge_point_id} conectada")
        await cp.start()

    except Exception as e:
        self.logger.error(f"Erro na conexão: {str(e)}")
        if charge_point_id in self.connections:
            await self.remove_connection(charge_point_id)
        await websocket.close(code=1011, reason=str(e))

async def start_ocpp_server(self, host: str, port: int):
    """Inicia o servidor OCPP"""
    self.server = await websockets.serve(
        self.on_connect,  # Just pass the method directly
        host,
        port,
        subprotocols=['ocpp1.6']
    )
    self.logger.info(f"Servidor OCPP iniciado em ws://{host}:{port}")
    return self.server
    
async def add_connection(self, charge_point_id, websocket):
    """Registra uma nova conexão"""
    cp = ChargePoint(charge_point_id, websocket, self)  # Add self as central_system
    self.connections[charge_point_id] = cp
    self.connection_events[charge_point_id] = asyncio.Event()
    self.last_activity[charge_point_id] = time.time()
    self.logger.info(f"Adicionando conexão: {charge_point_id}")
    return cp
    
async def remove_connection(self, charge_point_id):
    """Remove uma conexão"""
    if charge_point_id in self.connections:
        del self.connections[charge_point_id]
    if charge_point_id in self.connection_events:
        self.connection_events[charge_point_id].set()
        del self.connection_events[charge_point_id]
    if charge_point_id in self.last_activity:
        del self.last_activity[charge_point_id]

async def get_connection(self, charge_point_id):
    """Retorna uma conexão específica"""
    self.logger.info(f"Buscando conexão: {charge_point_id}")
    self.logger.info(f"Conexões ativas: {list(self.connections.keys())}")
    return self.connections.get(charge_point_id)

async def main(self, host: str, port: int):
    """Inicia o servidor OCPP e mantém a CentralSystem ativa"""
    await self.start_ocpp_server(host, port)
    await asyncio.Event().wait()  # Mantém o servidor rodando indefinidamente

With this code, I then call the send_command_to_chargepoint function that checks which command I should send to the CP (Charge Point).

async def send_command_to_chargepoint(self, charge_point_id, command, params):

    cp = self.connections.get(charge_point_id)
    if not cp:
        return None
    
    # Exemplo: suporte para UnlockConnector
    if command == "UNLOCK_CONNECTOR":
        connector_id = params.get("connector_id")
        if connector_id is None:
            return {"error": "Missing connector_id"}

        # Aqui chama o método do ChargePoint para enviar comando
        result = await cp.send_unlock_connector(connector_id=connector_id)
        if result:
            return {"status": "success", "response": str(result)}
        else:
            return {"status": "failed"}

    # Outros comandos podem ser implementados aqui
    return {"error": "Unsupported command"}
    
   After the verification, it send the code as requested.
    
async def send_unlock_connector(self, connector_id):
    try:
        self.logger.info(f"{self.id}: Enviando UnlockConnector connector_id={connector_id}")
        request = call.UnlockConnector(connector_id=connector_id)

        response = await asyncio.wait_for(self.call(request), timeout=10)

        self.logger.info(f"{self.id}: Resposta UnlockConnector: {response.status}")
        return response
    except asyncio.TimeoutError:
        self.logger.error(f"{self.id}: Timeout esperando resposta UnlockConnector")
    except Exception as e:
        self.logger.error(f"{self.id}: Erro ao enviar UnlockConnector: {e}")

    return None

The problem is that this response from self.call never arrives, it always hits the timeout. I'm using a charging station simulator software that's already certified and 100% functional. In this software, I receive the information from the CS (Central System), and it also shows the response being sent almost instantly.

    18/06/25 13:35:02:939 :  001 : 

Request recieved : [2,"7a0f84f9-fdc9-4c7c-b0bb-6da4602a8483","UnlockConnector",{"connectorId":1}]
18/06/25 13:35:02:945 : 001 :
Sending response : [3,"7a0f84f9-fdc9-4c7c-b0bb-6da4602a8483",{"status":"UnlockFailed"}]

Somone could help me with some implementation examples of this functions (Requisition of the central system to charge point, and answers of the charge point to central system))

[gconceicao]

Problem Solved,

It just change the Super() on Start task to wait the answer fisrt.

        await super().start()
        await self.central_system.add_connection(self.id, self.websocket)