async def init_state(info_do_carregador, protocol): # Init State print(now(), 'Starting InitState') # Gerenciamento de Transições print(now(), 'Boot Notification is', info_do_carregador.flag_boot_notification) if not info_do_carregador.flag_boot_notification: return fsm.init_state return fsm.authentication
def on_authorize(self, id_token): if id_token['id_token'] in valid_tokens: print(now(), 'Token Accepted') return call_result.AuthorizePayload( id_token_info={"status": AuthorizationStatus.accepted}) else: print(now(), 'Token Invalid') return call_result.AuthorizePayload( id_token_info={"status": AuthorizationStatus.invalid})
def on_request_start_transaction(self, remote_start_id, id_token): if id_token['id_token'] == '123': print(now(), 'Starting Transaction') return call_result.RequestStartTransactionPayload( status=AvailabilityStatus.accepted) else: print(now(), 'Wrong ID_Token. Transaction did not initiate') return call_result.RequestStartTransactionPayload( status=AvailabilityStatus.rejected)
async def measuring(info_do_carregador, protocol): global count print(now(), 'Measuring...', count) await protocol.send_meter_values(1, now(), 100) if count <= 0: return fsm.stop_transaction else: count -= 1 return fsm.measuring
async def authentication(info_do_carregador, protocol): print(now(), 'Starting Authentication') if await protocol.send_authorize(info_do_carregador.RFID_VALUE): print(now(), 'Authentication Approved') info_do_carregador.RFID_VALUE = '1212' return fsm.start_transaction else: print(now(), 'Authentication Denied') info_do_carregador.RFID_VALUE = '1234' return fsm.authentication
async def send_request_stop_transaction(self, id): request = call.RequestStopTransactionPayload(transaction_id=str(id)) self.iniciar_timer_log() response = await self.call(request) self.escrever_arquivo_log('send_request_stop_transaction') if response: print(now(), "Stop transaction") # return False to turn off transaction status return False else: print(now(), "Error Stopping transaction") return True
async def on_connect(websocket, path): """ Para cada novo ponto de carga que se conecta, cria-se uma nova instância EVSE e comeca a escutar as mensagens. """ charge_point_id = path.strip('/') cp_created = ChargePointOperator(charge_point_id, websocket) print(now(), 'Conectando com EVSE ', charge_point_id) try: await cp_created.start() except: print(now(), 'Fim da conexão com ' + charge_point_id + '....')
async def send_meter_values(self, evse_id, timestamp, met_value): meter_array = [] meter_array.append({ "timestamp": timestamp, "sampledValue": [{ "value": 100 }] }) request = call.MeterValuesPayload(evse_id=123, meter_value=meter_array) self.iniciar_timer_log() response = await self.call(request) self.escrever_arquivo_log('send_meter_values') if response: print(now(), "Meter values sent") else: print(now(), "Error in central system with meter values")
async def start_transaction(info_do_carregador, protocol): print(now(), 'Iniciando o start_transaction') # Gerenciamento de Transições global count count = info_do_carregador.QNT_METER - 1 await protocol.send_request_start_transaction('123') return fsm.measuring
async def send_heartbeat(self, info_do_carregador): request = call.HeartbeatPayload() while not info_do_carregador.parar_heartbeat: print(now(), 'HeartBeat sent to CPO') self.iniciar_timer_log() response = await self.call(request) self.escrever_arquivo_log('send_heartbeat') if response.current_time: print(response.current_time, "Heartbeat delivered in CPO") else: print(now(), "Heartbeat not delivered") print(now(), "Heartbeat feedback in EVSE") await asyncio.sleep(info_do_carregador.HEARTBEAT_INTERVAL) info_do_carregador.heartbeat_parado = True return True
async def send_request_start_transaction(self, id): request = call.RequestStartTransactionPayload(id_token={ "id_token": str(id), "type": IdTokenEnumType.ISO14443 }, remote_start_id=1) self.iniciar_timer_log() response = await self.call(request) self.escrever_arquivo_log('send_request_start_transaction') if response.status == AvailabilityStatus.accepted: print(now(), 'Start Transaction Accepted') return True else: print(now(), 'Start Transaction rejected') return False
async def send_boot_notification(self, info_do_carregador): request = call.BootNotificationPayload(charging_station={ 'model': info_do_carregador.CP_MODEL, 'vendor_name': info_do_carregador.CP_VENDOR }, reason=BootReason.PowerUp) print(now(), 'BootNotification sent to CPO') self.iniciar_timer_log() response = await self.call(request) self.escrever_arquivo_log('send_boot_notification') if response.status == RegistrationStatus.accepted: print(now(), 'BootNotification OK, connected with CPO.') info_do_carregador.HEARTBEAT_INTERVAL = response.interval info_do_carregador.flag_boot_notification = True return await self.send_heartbeat(info_do_carregador) else: print(now(), 'BootNotification OK, did not connect with CPO.') import sys try: sys.exit(1) except: print("Closing EVSE... Bye")
def on_request_stop_transaction(self, transaction_id): print(now(), 'Finished Transaction', transaction_id) return call_result.RequestStopTransactionPayload( status=AvailabilityStatus.accepted)
def on_meter_values(self, evse_id, meter_value): print(now(), evse_id, meter_value) return call_result.MeterValuesPayload()
async def stop_transaction(info_do_carregador, protocol): print(now(), 'Iniciando o StopTransaction') await protocol.send_request_stop_transaction('123') if info_do_carregador.ciclo_unico_da_maquina_de_estado: return fsm.end_state return fsm.authentication
async def end_state(info_do_carregador, protocol): # end State print(now(), 'Iniciando o end_state') info_do_carregador.parar_heartbeat = True await asyncio.sleep(0.1) protocol.fechar_arquivo_log() return fsm.fim
def on_heartbeat(self): print(now(), ' On a Heartbeat!') return call_result.HeartbeatPayload(current_time=now())
def after_boot_notification(self, charging_station, reason, **kwargs): print(now(), " Boot Notification from: ", charging_station, ", cause ", reason)
def on_boot_notification(self, charging_station, reason, **kwargs): print(now(), ' Got a BootNotification!') return call_result.BootNotificationPayload( current_time=now(), interval=HEARTBEAT_INTERVAL, status=RegistrationStatus.accepted)
async def fim(info_do_carregador, protocol): # end State print(now(), 'Iniciando o fim') return True
from src.tools import now, CPO_IP, CPO_PORT, SUBPROTOCOL async def on_connect(websocket, path): """ Para cada novo ponto de carga que se conecta, cria-se uma nova instância EVSE e comeca a escutar as mensagens. """ charge_point_id = path.strip('/') cp_created = ChargePointOperator(charge_point_id, websocket) print(now(), 'Conectando com EVSE ', charge_point_id) try: await cp_created.start() except: print(now(), 'Fim da conexão com ' + charge_point_id + '....') async def main(): server = await websockets.serve(on_connect, CPO_IP, CPO_PORT, subprotocols=SUBPROTOCOL) await server.wait_closed() if __name__ == '__main__': print(now(), "Iniciando Servidor...") asyncio.run(main())