Hacs-和风天气

## 安装和风天气
进入HACS，官方没有，只能通过第三方式安装
![](/media/202212/image-b3dae24457984d4db327c9b943beb403.png)

点击右上三个点，选择Custom repositories(自定义)
![](/media/202212/image-1bc4b521c766436d9bb2adf97fbd26c3.png)
地址栏填入：`https://github.com/5high/HeWeather` 右侧选择Integration，ADD添加

如果添加后没有自动显示出来，那就重开这个页面进行搜索HeWeather，手动进行安装
![](/media/202212/image-4a40c48656844fe18ca678d00c260f50.png)

安装完成后是红色的，这时候我们重启下Home Assistant就行了(配置——服务控制——重启)

选择integration进行配置和风天气(也可点击名称HeWeather)
![](/media/202212/image-ef2dac0e1c044b5eb97f08e68eb0d0c2.png)

和风天气官网：`https://id.qweather.com/#/register`

登录和风天气官方创建帐号并在控制台中新建个应用，Web API，复制KEY
复制和风天气的实例
![](/media/202212/image-5330c2998a7a4640b31d4d8bad610d73.png)

修改/root/config/configuration.yaml      (方法很多，SHH，内部编辑器，Samba都可)
![](/media/202212/image-1bf5ec888d864691aa180af9c649950f.png)
配置添加在这最下方，city修改为auto_ip(根据IP获得位置)或是直接填写城市名称，appkey填写为你的和风天气KEY，保存
[](自用KEY:` bbc41a738b01480b9f2c6f3639f77fd0`)

```
sensor:
  - platform: HeWeather
    city: auto_ip
    appkey: 你的密钥
    options:
      - fl          #实时体感温度
      - tmp         #实时室外温度
      - cond_txt    #天气状态
      - wind_spd    #风速
      - hum         #实时室外湿度
      - pcpn        #降水量
      - pres        #大气压
      - vis         #能见度
      - wind_sc     #风力
      - aqi         #空气质量指数
      - main        #主要污染物
      - qlty        #空气质量
      - pm10        #PM10
      - pm25        #PM2.5
      - comf        #舒适度指数
      - cw          #洗车指数
      - drsg        #穿衣指数
      - flu         #感冒指数
      - sport       #运动指数
      - trav        #出行指数
      - uv          #紫外线指数
      - wind_dir    #风向
      - tmp_max     #今日最高温度
      - tmp_min     #今日最低温度
      - pop         #降水概率
```
对于不需要的参数可以禁用

重启HASS，配置——服务控制——重新启动

### 手动安装
如果出现 Hacs 无法下载的情况，我们可以手动进行安装
去 [Github](https://github.com/5high/HeWeather) 吧 和风天气 的这个文件夹下载下来
![](/media/202201/2022-01-13_223450_893527.png)
放入到 `Hass` 下的 `/config/custom_components` 下，和 `hacs` 文件夹同级
![](/media/202201/2022-01-13_223640_282825.png)
然后重启 HASS，配置——服务控制——重新启动
这时候才能去 `configuration.yaml` 写配置(之前放进去读取不到，会报错，重启会加载，就能识别到配置了)
然后再重启 HASS 即可

#### 手动添加
> 如果文件也下载不下来，可以按照这个路径进行手动添加
> 里面是这两个文件，`manifest.json` 和 `sensor.py`
> ![](/media/202201/2022-01-13_223549_096104.png)

记录时间 2022/1/13
`manifest.json`
```
{
  "domain": "HeWeather",
  "version": "1.0",
  "name": "HeWeather",
  "documentation": "https://www.hachina.io/3973.html#comments",
  "requirements": ["requests"],
  "codeowners": [],
  "dependencies": []
}
```
`sensor.py`
```
import logging
from datetime import timedelta
import voluptuous as vol
import requests
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.helpers.entity import Entity
import homeassistant.helpers.config_validation as cv
from homeassistant.util import Throttle
from requests.exceptions import (
    ConnectionError as ConnectError, HTTPError, Timeout)

_LOGGER = logging.getLogger(__name__)

TIME_BETWEEN_UPDATES = timedelta(minutes=30)

CONF_OPTIONS = "options"
CONF_CITY = "city"
# CONF_AQI_CITY = "aqi_city"
CONF_APPKEY = "appkey"

life_index_list = {"comf_txt": None, "drsg_txt": None, "flu_txt": None,
                   "sport_txt": None, "trav_txt": None, "uv_txt": None, "cw_txt": None}

OPTIONS = dict(fl=["HeWeather_fl", "实时体感温度", "mdi:temperature-celsius", "℃"],
               tmp=["HeWeather_tmp", "实时室外温度", "mdi:thermometer", "℃"],
               hum=["HeWeather_hum", "实时室外湿度", "mdi:water-percent", "%Rh"],
               pcpn=["HeWeather_pcpn", "降水量", "mdi:weather-rainy", "mm"],
               pres=["HeWeather_pres", "大气压", "mdi:debug-step-over", "hPa"],
               vis=["HeWeather_vis", "能见度", "mdi:eye", "km"],
               wind_spd=["HeWeather_wind_spd", "风速", "mdi:speedometer", "km/h"],
               wind_sc=["HeWeather_wind_sc", "风力", "mdi:flag-variant", None],
               wind_dir=["HeWeather_wind_dir", "风向", "mdi:apple-safari", None],
               cond_txt=["HeWeather_cond_txt", "天气状态", "mdi:counter", None],
               qlty=["HeWeather_qlty", "空气质量", "mdi:beach", None],
               main=["HeWeather_main", "主要污染物", "mdi:chart-bar-stacked", None],
               aqi=["HeWeather_aqi", "空气质量指数", "mdi:poll", "AQI"],
               pm10=["HeWeather_pm10", "PM10", "mdi:blur", "μg/m³"],
               pm25=["HeWeather_pm25", "PM2.5", "mdi:blur", "μg/m³"],
               comf=["HeWeather_comf", "舒适度指数", "mdi:chart-bubble", None],
               cw=["HeWeather_cw", "洗车指数", "mdi:car-wash", None],
               drsg=["HeWeather_drsg", "穿衣指数", "mdi:tie", None],
               flu=["HeWeather_flu", "感冒指数", "mdi:seat-individual-suite", None],
               sport=["HeWeather_sport", "运动指数", "mdi:bike", None],
               uv=["HeWeather_uv", "紫外线指数", "mdi:sunglasses", None],
               trav=["HeWeather_trav", "出行指数", "mdi:bus", None],
               tmp_max=["HeWeather_tmp_max", "今日最高温度", "mdi:mdi:thermometer", "℃"],
               tmp_min=["HeWeather_tmp_min", "今日最低温度", "mdi:mdi:thermometer", "℃"],
               pop=["HeWeather_pop", "降水概率", "mdi:weather-rainy", "%"],
               cond_code=[])

ATTR_UPDATE_TIME = "更新时间"
ATTRIBUTION = "Powered by He Weather"
ATTRIBUTION_SUGGESTION = "生活建议"

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
    {
        vol.Required(CONF_CITY): cv.string,
        vol.Required(CONF_APPKEY): cv.string,
        vol.Required(CONF_OPTIONS, default=[]): vol.All(cv.ensure_list, [vol.In(OPTIONS)]),
    }
)

def setup_platform(hass, config, add_entities, discovery_info=None):
    _LOGGER.info("Setup platform sensor.HeWeather")
    city = config.get(CONF_CITY)
    appkey = config.get(CONF_APPKEY)
    # aqi_city = config.get(CONF_AQI_CITY)
    data = WeatherData(city, appkey)

dev = []
    for option in config[CONF_OPTIONS]:
        dev.append(HeWeatherSensor(data, option))
    add_entities(dev, True)

class HeWeatherSensor(Entity):
    def __init__(self, data, option):
        self._data = data
        self._object_id = OPTIONS[option][0]
        self._friendly_name = OPTIONS[option][1]
        self._icon = OPTIONS[option][2]
        self._unit_of_measurement = OPTIONS[option][3]
        self._type = option
        self._state = None
        self._updatetime = None

@property
    def unique_id(self):
        return self._object_id

@property
    def name(self):
        return self._friendly_name

# @property
    # def registry_name(self):
    #     return self._friendly_name

@property
    def state(self):
        return self._state

@property
    def icon(self):
        return self._icon

@property
    def unit_of_measurement(self):
        return self._unit_of_measurement

@property
    def device_state_attributes(self):
        global ATTRIBUTION

if self._friendly_name == "舒适度指数":
            ATTRIBUTION = life_index_list['comf_txt']
        elif self._friendly_name == "穿衣指数":
            ATTRIBUTION = life_index_list["drsg_txt"]
        elif self._friendly_name == "感冒指数":
            ATTRIBUTION = life_index_list["flu_txt"]
        elif self._friendly_name == "运动指数":
            ATTRIBUTION = life_index_list["sport_txt"]
        elif self._friendly_name == "出行指数":
            ATTRIBUTION = life_index_list["trav_txt"]
        elif self._friendly_name == "紫外线指数":
            ATTRIBUTION = life_index_list["uv_txt"]
        elif self._friendly_name == "洗车指数":
            ATTRIBUTION = life_index_list["cw_txt"]
        else:
            ATTRIBUTION = "Powered by HeWeather"

return {
            ATTR_UPDATE_TIME: self._updatetime,
            ATTRIBUTION_SUGGESTION: ATTRIBUTION,
        }

def update(self):
        self._data.update()
        self._updatetime = self._data.updatetime

if self._type == "fl":
            self._state = self._data.fl
        elif self._type == "tmp":
            self._state = self._data.tmp
        elif self._type == "cond_txt":
            self._state = self._data.cond_txt
        elif self._type == "wind_spd":
            self._state = self._data.wind_spd
        elif self._type == "hum":
            self._state = self._data.hum
        elif self._type == "pcpn":
            self._state = self._data.pcpn
        elif self._type == "pres":
            self._state = self._data.pres
        elif self._type == "vis":
            self._state = self._data.vis
        elif self._type == "wind_sc":
            self._state = self._data.wind_sc
        elif self._type == "wind_dir":
            self._state = self._data.wind_dir
        elif self._type == "qlty":
            self._state = self._data.qlty
        elif self._type == "main":
            self._state = self._data.main
        elif self._type == "aqi":
            self._state = self._data.aqi
        elif self._type == "pm10":
            self._state = self._data.pm10
        elif self._type == "pm25":
            self._state = self._data.pm25
        elif self._type == "cw":
            self._state = self._data.cw
        elif self._type == "comf":
            self._state = self._data.comf
        elif self._type == "drsg":
            self._state = self._data.drsg
        elif self._type == "flu":
            self._state = self._data.flu
        elif self._type == "sport":
            self._state = self._data.sport
        elif self._type == "trav":
            self._state = self._data.trav
        elif self._type == "uv":
            self._state = self._data.uv
        elif self._type == "tmp_max":
            self._state = self._data.tmp_max
        elif self._type == "tmp_min":
            self._state = self._data.tmp_min
        elif self._type == "pop":
            self._state = self._data.pop

class WeatherData(object):
    def __init__(self, city, appkey):
        self._url = "https://free-api.heweather.net/s6/weather/now"
        self._air_url = "https://free-api.heweather.net/s6/air/now"
        self._life_index_url = "https://free-api.heweather.net/s6/weather/lifestyle"
        self._long_weather_forcasting_url = "https://free-api.heweather.net/s6/weather/forecast"
        self._params = {"location": city, "key": appkey}
        # self._aqi_params = {"location": aqi_city, "key": appkey}
        self._fl = None
        self._tmp = None
        self._cond_txt = None
        self._wind_spd = None
        self._hum = None
        self._pcpn = None
        self._pres = None
        self._vis = None
        self._wind_sc = None
        self._wind_dir = None
        self._qlty = None
        self._main = None
        self._aqi = None
        self._pm10 = None
        self._pm25 = None
        self._updatetime = None
        self._comf = None
        self._cw = None
        self._drsg = None
        self._flu = None
        self._sport = None
        self._uv = None
        self._trav = None
        self._tmp_max = None
        self._tmp_min = None
        self._pop = None

@property
    def fl(self):
        return self._fl

@property
    def tmp(self):
        return self._tmp

@property
    def cond_txt(self):
        return self._cond_txt

@property
    def wind_spd(self):
        return self._wind_spd

@property
    def wind_dir(self):
        return self._wind_dir

@property
    def hum(self):
        return self._hum

@property
    def pcpn(self):
        return self._pcpn

@property
    def pres(self):
        return self._pres

@property
    def vis(self):
        return self._vis

@property
    def wind_sc(self):
        return self._wind_sc

@property
    def qlty(self):
        return self._qlty

@property
    def main(self):
        return self._main

@property
    def aqi(self):
        return self._aqi

@property
    def pm10(self):
        return self._pm10

@property
    def pm25(self):
        return self._pm25

@property
    def comf(self):
        return self._comf

@property
    def cw(self):
        return self._cw

@property
    def drsg(self):
        return self._drsg

@property
    def flu(self):
        return self._flu

@property
    def sport(self):
        return self._sport

@property
    def uv(self):
        return self._uv

@property
    def trav(self):
        return self._trav

@property
    def tmp_max(self):
        return self._tmp_max

@property
    def tmp_min(self):
        return self._tmp_min

@property
    def pop(self):
        return self._pop

@property
    def updatetime(self):
        return self._updatetime
    
    def now(self):
        now_weather = requests.post(self._url, self._params)
        con = now_weather.json()
        return con

def air(self):
        r_air = requests.post(self._air_url, self._params)
        con_air = r_air.json()
        return con_air

def life(self):
        life_index = requests.post(self._life_index_url, self._params)
        con_life_index = life_index.json()
        return con_life_index

def today(self):
        today_weather = requests.post(self._long_weather_forcasting_url, self._params)
        con_today_weather = today_weather.json()
        return con_today_weather

@Throttle(TIME_BETWEEN_UPDATES)
    def update(self):
        import time
        try:
            con = self.now()
        except (ConnectError, HTTPError, Timeout, ValueError) as error:
            time.sleep(0.01)
            con = self.now()
            _LOGGER.error("Unable to connect to HeWeather. %s", error)
        try:
            con_air = self.air()
        except (ConnectError, HTTPError, Timeout, ValueError) as error:
            time.sleep(0.01)
            con_air = self.air()
            _LOGGER.error("Unable to connect to HeWeather. %s", error)
        try:
            con_life_index = self.life()
        except (ConnectError, HTTPError, Timeout, ValueError) as error:
            time.sleep(0.01)
            con_life_index = self.life()
            _LOGGER.error("Unable to connect to HeWeather. %s", error)
        try:
            today_weather = self.today()
        except (ConnectError, HTTPError, Timeout, ValueError) as error:
            time.sleep(0.01)
            today_weather = self.today()
            _LOGGER.error("Unable to connect to HeWeather. %s", error)

_LOGGER.info("Update from HeWeather...")
        try:
            self._fl = con.get("HeWeather6")[0].get("now").get("fl")
            self._cond_txt = con.get("HeWeather6")[0].get("now").get("cond_txt")
            self._hum = con.get("HeWeather6")[0].get("now").get("hum")
            self._pcpn = con.get("HeWeather6")[0].get("now").get("pcpn")
            self._pres = con.get("HeWeather6")[0].get("now").get("pres")
            self._tmp = con.get("HeWeather6")[0].get("now").get("tmp")
            self._vis = con.get("HeWeather6")[0].get("now").get("vis")
            self._wind_spd = con.get("HeWeather6")[0].get("now").get("wind_spd")
            self._wind_dir = con.get("HeWeather6")[0].get("now").get("wind_dir")

self._cond_code = con.get("HeWeather6")[0].get("now").get("cond_code")

self._qlty = con_air.get("HeWeather6")[0].get("air_now_city").get("qlty")
            self._aqi = con_air.get("HeWeather6")[0].get("air_now_city").get("aqi")
            self._pm10 = con_air.get("HeWeather6")[0].get("air_now_city").get("pm10")
            self._pm25 = con_air.get("HeWeather6")[0].get("air_now_city").get("pm25")
            if con_air.get("HeWeather6")[0].get("air_now_city").get("main") == "-":
                if int(self._pm10) > int(self._pm25):
                    self._main = "PM10"
                elif int(self._pm10) < int(self._pm25):
                    self._main = "PM25"
                else:
                    self._main = "-"
            else:
                self._main = con_air.get("HeWeather6")[0].get("air_now_city").get("main")

self._comf = con_life_index.get("HeWeather6")[0].get("lifestyle")[0].get("brf")
            self._drsg = con_life_index.get("HeWeather6")[0].get("lifestyle")[1].get("brf")
            self._flu = con_life_index.get("HeWeather6")[0].get("lifestyle")[2].get("brf")
            self._sport = con_life_index.get("HeWeather6")[0].get("lifestyle")[3].get("brf")
            self._trav = con_life_index.get("HeWeather6")[0].get("lifestyle")[4].get("brf")
            self._uv = con_life_index.get("HeWeather6")[0].get("lifestyle")[5].get("brf")
            self._cw = con_life_index.get("HeWeather6")[0].get("lifestyle")[6].get("brf")
            life = ["comf_txt", "drsg_txt", "flu_txt", "sport_txt", "trav_txt", "uv_txt", "cw_txt"]
            for i, index in enumerate(life):
                life_index_list[index] = con_life_index["HeWeather6"][0]["lifestyle"][i]["txt"]

self._tmp_max = today_weather.get("HeWeather6")[0].get("daily_forecast")[0].get("tmp_max")
            self._tmp_min = today_weather.get("HeWeather6")[0].get("daily_forecast")[0].get("tmp_min")
            self._pop = today_weather.get("HeWeather6")[0].get("daily_forecast")[0].get("pop")
            self._wind_sc = today_weather.get("HeWeather6")[0].get("daily_forecast")[0].get("wind_sc")
        except Exception as e:
            logging.info(e)

import time
        self._updatetime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
```