Integração de recarga e sistema solar

[ivanfm]

• Depois que coloquei um carregador fixo e conectado em casa fiz a integração com o sistema solar para recarga
• A forma de fazer essa integração vai depender do carregador que você possui e seu sistema de controle
• Utilizei inicialmente a integração do Home Assistant com a API JuiceBox
• Aprendi que alguns veículos tratam melhor o ajuste de limite de corrente do que outros
  • o Bolt quando conectado em um carregador que indica correntes de até 10A assume que esse carregador é um carregador de baixa potencia e não aceita quando o carregador indica que pode fornecer corrente maior
  • Por isso sempre deixo a corrente minima para inicio de carga como 12A

• Configuração do Home Assistant para receber novos limites e passar para API Juicenet

  Código: Selecionar todos

  # Recebe comando via mqtt e atualiza definicao do juicebox
  - id: ajuste_limite_juicebox
    alias: "Ajuste limite JuiceBox"
    trigger: 
      platform: mqtt
      topic: /juicenet_q12l12/setLimit
    action:
      service: python_script.juicenet_limit
      data: 
        entity_id: 'number.juicenet_q12l12_amperage_limit'
        trigger: '{{ trigger }}'
        payload: '{{ trigger.payload }}'

• Script que faz a chamada no formato correto e dentro dos limites, se fizer a chamada com valores fora do limite a integração para de funcionar corretamente

  Código: Selecionar todos

  payload = data.get('payload')
  entity = data.get('entity_id')
  oldStateObj = hass.states.get(entity)
  newValue = int(payload)
  if 'min' in oldStateObj.attributes:
     newValue = max(oldStateObj.attributes['min'], newValue)
  if 'max' in oldStateObj.attributes:
     newValue = min(oldStateObj.attributes['max'], newValue)
  data = { "entity_id" : entity, "value" : int(newValue) }
  hass.services.call("number","set_value", data , False)

• A parte que define o tratamento ficou simples, mas depende de cada ambiente portanto não vou colocar o código aqui, mas explicar o que é feito

  • A cada 3 minutos (isso dá tempo para estabilizar o sistema)
    • Se não está carregando coloco limite de carga para 12A
    • Se esta carregando
      • se está injetando energia na rede mando aumentar a corrente limite de carga pelo numero que esta injetando (se passar do permitido o script do Home Assistant controla)
      • se está consumindo da rede, mando reduzir a corrente limite de carga do numero que está recebendo
    • Dessa forma o processo de carga tenta utilizar o máximo possível de energia solar durante a carga, tenho uma configuração de valor minimo, dessa forma posso garantir a recarga sempre, normalmente deixo em 6A mas quando preciso de uma carga mais rápida só preciso ajustar esse limite inferior

[ivanfm]

Estou migrando totalmente o sistema de controle do carregador para o Home Assistant então aqui vou colocar como está ficando (atualmente já estou utilizando isso por pelo menos 1 mês) :

• Quando funcionava utilizei a API da ENEL X e depois migrei para o juicepassproxy
• Corrente de standby
  • o Juicebox tem um parâmetro para corrente de carga quando conectado e outro para quando não está conectado, se ele perde a conectividade com servidor ele altera a corrente limite utilizada, então já tem um sistema de contingencia
  • se utilizar um carregador sem esse tipo de recurso e perder a conectividade ele vai ficar com a corrente de standby, nesse caso pode ser mais seguro utilizar valores maiores se a sua instalação comportar
• Controle de carga por horario
  • Inicialmente eu fazia o controle pelo carro, agora isso já faz parte do script pois posso pausar
  • Para carregadores como Juicebox que suportam pausa, basta criar um schedule no homeassistant definindo o horário que deseja carregar e passar no parametro chargingPermitted
  • Caso o carregador não suporte pausa é possível gerenciar na maioria dos carros pelo horário de carga no painel
  • Para não ficar carregando a noite quando não preciso da carga rapidamente ajusto para carregar somente durante o dia
    • assim posso utilizar mais do período de geração solar
  • Além disso preparando a casa para funcionamento em momentos sem energia também considero um sensor que indica se existe energia elétrica chegando na casa e a carga fica permitida somente nesse caso

• Um sensor template que calcula a corrente que pode ser disponibilizada ou reduzida do carregador

  Código: Selecionar todos

  - sensor:
    - name: "Corrente Disponível EVSE"
      unique_id: evse_available_amps
  # O meu medidor somente mostra sinal na potencia em watts
  # o carregador esta ligado entre as fases 1 e 2
  # Então determina quando pode ajustar pela fase que tem menor "folga" a que vai ter potencia maior
  # A tensão pode variar mas utiliza aqui um valor fixo como referencia para facilitar
  # Se a potencia for positiva significa que não tem folga então a corrente disponível fica negativa
  # Se a potencia for negativa significa que tem folga e a corrente disponível fica positiva
      state: >-
        {%- set watts = max(states.sensor.fase_1_quadro_entrada.state | int,states.sensor.fase_2_quadro_entrada.state | int) -%}
        {%- set amps = (watts / -127) -%}
        {{- amps -}}

• Automação

  Código: Selecionar todos

  alias: EVSE - Controle de Corrente
  description: >-
    A cada 3 minutos para não ficar alterando muito e dar tempo para estabilizar
    as mudanças maiores
  
  
    Alem do delay entre os dados medidos (medidor de energia, carregador) existem
    variações constantes no consumo da casa (maquina de lavar, secar, forno entre
    outros equipamentos)
  
  
    45 segundos para dar tempo de receber as atualizações dos medidores de energia
    que atualiza até uns 20 segundos
  
  
    Se o carro ficar muito tempo com plugged significa que provavelmente terminou
    a carga entao considera como standby para retornar a corrente padrao
  
  
    Isso é útil no caso do juicebox que frequentemente tem perdido a conexao com
    os servidores, dessa forma vai tentar deixar com corrente de standby para o
    próximo  uso com corrente maxima mesmo que não retorne a conexão. Mas o script
    só retorna para corrente padrão se for horario de carregamento, se não for
    deixa  em 0 de forma a manter a recarga pausada. Se houve problema de perda da
    conexão  utilizando max_charging_current do juicepassproxy basta desligar e
    ligar alimentação do carregador
  trigger:
    - platform: time_pattern
      seconds: "45"
      minutes: /3
    - platform: state
      entity_id:
        - input_number.cfg_evse_maximo
        - input_number.cfg_evse_standby
        - input_number.cfg_evse_minimo
      for:
        hours: 0
        minutes: 0
        seconds: 30
    - platform: state
      entity_id:
        - sensor.juicebox_status
        - schedule.horario_carregamento_evse
      for:
        hours: 0
        minutes: 0
        seconds: 10
      to: null
  condition:
    - condition: state
      entity_id: binary_sensor.tem_energia
      state: "on"
  action:
    - service: python_script.reload
      metadata: {}
      data: {}
      enabled: false
    - service: python_script.evse_control_limits
      metadata: {}
      data:
        minCurrent: "{{ states('input_number.cfg_evse_minimo') }}"
        maxCurrent: "{{ states('input_number.cfg_evse_maximo') }}"
        standbyCurrent: "{{ states('input_number.cfg_evse_standby') }}"
        availableCurrent: "{{ states('sensor.corrente_disponivel_evse') }}"
        chargingState: "{{ states('sensor.juicebox_status').lower() }}"
        chargingCurrent: "{{ states('sensor.juicebox_current') }}"
        chargingTime: "{{ states('sensor.juicebox_tempo_em_carga') }}"
        limitEntity: number.juicebox_max_charging_current
        debug: 1
        chargingPermitted: >-
          {{ ( is_state('schedule.horario_carregamento_evse','on') or
          (states('sensor.corrente_disponivel_evse') | int >
          (states('input_number.cfg_evse_minimo') | int* 2)) ) and
          is_state('binary_sensor.tem_energia','on') }}
  trace:
    stored_traces: 120
  mode: single

• Script que segue a lógica já indicada anteriormente

  Código: Selecionar todos

  #
  # Configuration Parameters
  #  minCurrent		- minimum Current (default 6)
  #  maxCurrent		- maximum Current (default 32)
  #  standbyCurrent	- standby Current (default 12) 
  #                         Bolt with not allow to go over 10A if started with less than 11A
  #                         it consider that is connected to a portable charger
  #  minChargingTime      - minimum ChargingTime (seconds) to make adjusts (default 90)
  #  chargingPermitted    - True/False (default True)
  #                         Will pause charging when not permitted AFTER the start of charging
  #                         This is to solve a problem with Bolt that will consider the charger as
  #                          portable when connected to EVSE with Current lower than 10A
  #
  #
  # Control Parameters
  #  availableCurrent	- available Current (positive can use more, negative reduce from charging)
  #
  #
  # EVSE - Parameters
  #  chargingState	- current EVSE state ('charging' and ['standby','available','unplugged','plugged in'] considered)
  #  chargingTime         - charging time in seconds
  #  chargingCurrent      - current being used
  #  limitEntity          - entity that controls de current limit
  #                         use max_charging_current entity for juicepassproxy
  #
  
  def get_or_default(name, defaultValue):
      value = data.get(name)
      if (value is None) or (value == 'unavailable') or (value == 'unknown'):
          return defaultValue
      return value
      
  def get_float_or_default(name, defaultValue):
      return float(get_or_default(name, defaultValue))
      
  def get_int_or_default(name, defaultValue):
      # Sometimes values came as "xx.0" using float first will make conversion work fine
      return int(get_float_or_default(name, defaultValue))
  
  def evse_debug(message):
      if int(get_or_default('debug', 0)) > 0:
          logger.error(message)
  
  
  def vehicle_not_connected():
      global chargingState
      return chargingState in ['available','unplugged','standby']
      
  def vehicle_not_charging():
      global chargingState
      return chargingState in ['plugged in'] or vehicle_not_connected()
      
  def vehicle_connected():
      return not vehicle_not_connected()
      
  minCurrent = get_int_or_default('minCurrent', 6)
  maxCurrent = get_int_or_default('maxCurrent', 32)
  standbyCurrent = get_int_or_default('standbyCurrent', 12)
  availableCurrent = get_float_or_default('availableCurrent', 0)
  minChargingTime = get_int_or_default('minChargingTime', 90)
  
  # some integrations have different case, use lower to make is more standard
  chargingState = get_or_default('chargingState', 'standby').lower()
  chargingPermitted = get_or_default('chargingPermitted',True)
  
  chargingTime = get_int_or_default('chargingTime', 0)
  chargingCurrent = get_float_or_default('chargingCurrent', 0)
  limitEntity = get_or_default('limitEntity', '')
  
  
  stateObject = hass.states.get(limitEntity)
  currentLimit = int(float(stateObject.state))
  
  
  if (currentLimit == 0) and (not chargingPermitted) and vehicle_connected():
     # Charging pause requested and already defined
     logger.debug("EVSE Charging paused")
  
     # No changes should be made
     newLimit = currentLimit
  
  else:   
      newLimit = currentLimit
      
      if vehicle_not_charging():
          if chargingPermitted:
              newLimit = standbyCurrent
      elif ((chargingState == 'charging') and (chargingTime > minChargingTime)) or (chargingPermitted and (currentLimit == 0)):
          # To overcome a problem on Bolt when corrected during pause it will consider as charging on portable charger
          # we must let it start and then pause
          if chargingPermitted:
              newLimit = int(chargingCurrent + availableCurrent)
  
              if (newLimit != currentLimit):
                  evse_debug("state = " + chargingState + " current=" + str(chargingCurrent) + " currentLimit = " + str(currentLimit) + " newLimit = " + str(newLimit) + " permitted=" + str(chargingPermitted))    
  
              # Apply configured limits
              tmp = min( max(minCurrent, newLimit), maxCurrent)
  
              if tmp != newLimit:
  #                evse_debug("adjusting newLimit to range " + str(newLimit) + " -> " + str(tmp))
                  newLimit = tmp
  
          else:
              # Pause Charging
              newLimit = 0
  
  if (newLimit != currentLimit):
      # if entity has limits apply this limits also
      tmpLimit = newLimit
          
      if 'min' in stateObject.attributes:
          tmpLimit = max(stateObject.attributes['min'], tmpLimit)
              
      if 'max' in stateObject.attributes:
          tmpLimit = min(stateObject.attributes['max'], tmpLimit)
  
      if (tmpLimit != newLimit):
          evse_debug("Adjusted by entity limits tmpLimit=" + str(tmpLimit) + " newLimit=" + str(newLimit) + " entity=" + str(stateObject))
          
      if (tmpLimit != currentLimit):
          evse_debug("Changing EVSE Charging Current " + limitEntity + " from=" + str(currentLimit) + " to=" + str(tmpLimit) + " " + str(newLimit) )
          serviceData = { "entity_id" : limitEntity, "value" : int(tmpLimit) }
          hass.services.call("number","set_value", serviceData , False)
      else:
          evse_debug("EVSE Charging Current " + limitEntity + " not changed because of entity limits : newLimit=" + str(newLimit) + " " + str(stateObject))

• exemplo de corrente em comparação com a potência gerada pelo sistema solar em um dia nublado com várias nuvens
  • é importante lembrar também que existem outros equipamentos no imóvel sendo utilizados e com isso a variação da corrente não acompanha totalmente a geração solar

Screenshot_2024-01-29_16-39-20.jpg (23.44 KiB) Exibido 714 vezes

2c10c585-f565-460a-b414-7d41dc8377c3.jpeg (15.01 KiB) Exibido 227 vezes

[ivanfm]

• Pelo que pude perceber esse processo que utilizei no juicebox deve funcionar também para carregadores conectados via OCPP utilizando o Home Assistant
  • https://home-assistant-ocpp.readthedocs ... index.html
  • https://github.com/lbbrhzn/ocpp
• Tem que testar para determinar qual o mapeamento de estados que deve ser feito
• A API Juicenet ficou instavel e consegui migrar para a utilização do juicepassproxy - https://github.com/snicker/juicepassproxy/pull/69