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())