bin/khatus_bar

   1 #! /usr/bin/awk -f
   2
   3 BEGIN {
   4      FS = msg_fs ? msg_fs : "|"
   5     OFS = msg_fs ? msg_fs : "|"
   6     Kfs = key_fs ? key_fs : ":"
   7
   8     _total_to_diff["khatus_sensor_net_addr_io", "bytes_read"     ] = 1
   9     _total_to_diff["khatus_sensor_net_addr_io", "bytes_written"  ] = 1
  10     _total_to_diff["khatus_sensor_disk_io"    , "sectors_read"   ] = 1
  11     _total_to_diff["khatus_sensor_disk_io"    , "sectors_written"] = 1
  12 }
  13
  14 # -----------------------------------------------------------------------------
  15 # Input
  16 # -----------------------------------------------------------------------------
  17 $1 == "OK" {
  18     Data_update()
  19 }
  20
  21 $1 == "OK" && \
  22 $2 == "khatus_sensor_datetime" {
  23     print_msg_ok("status_bar", make_status_bar())
  24 }
  25
  26 # Let everything else through
  27 //
  28
  29 # -----------------------------------------------------------------------------
  30 # Data
  31 # -----------------------------------------------------------------------------
  32
  33 function Data_update(    src, key, val, len_line, len_head, len_val, time) {
  34     src = $2
  35     key = $3
  36
  37     # Not just using $4 for val - because an unstructured value (like name of a
  38     # song) might contain a character identical to FS
  39     len_line = length($0)
  40     len_head = length($1 FS $2 FS $3 FS)
  41     len_val  = len_line - len_head
  42     val = substr($0, len_head + 1, len_val)
  43
  44     Data[src, key] = Data_maybe_total_to_diff(src, key, val)
  45     time = Data_get_time()
  46     M_time[src, key] = time
  47
  48     if (time % 3600 == 0) {
  49         Data_gc()
  50     }
  51 }
  52
  53 function Data_get(src, key, age_max,    time, age, is_expired) {
  54     time = Data_get_time()
  55     A_time[src, key] = time
  56     age = time - M_time[src, key]
  57     is_expired = age_max && age > age_max
  58     return is_expired ? "" : Data[src, key]
  59 }
  60
  61 function Data_get_time(    src, key, time) {
  62     src = "khatus_sensor_datetime"
  63     key = "epoch"
  64     time = Data[src, key]
  65     A_time[src, key] = time
  66     return time
  67 }
  68
  69 function Data_gc(    src_and_key, unused_for) {
  70     for (src_and_key in Data) {
  71         unused_for = Data_get_time() - A_time[src_and_key]
  72         if (unused_for > 3600) {
  73             print_msg_error(\
  74                 "Data_gc", "Deleting unused src_and_key: " src_and_key \
  75             )
  76             delete Data[src_and_key]
  77         }
  78     }
  79 }
  80
  81 function Data_maybe_total_to_diff(src, key, val,    key_parts) {
  82     split(key, key_parts, Kfs)
  83     if (_total_to_diff[src, key_parts[1]]) {
  84         _prev[src, key] = _curr[src, key]
  85         _curr[src, key] = val
  86         return (_curr[src, key] - _prev[src, key])
  87     } else {
  88         return val
  89     }
  90 }
  91
  92 # -----------------------------------------------------------------------------
  93 # Status bar
  94 # -----------------------------------------------------------------------------
  95
  96 function make_status_bar(    position, bar, sep, i, j) {
  97     position[++i] = ""
  98     position[++i] = make_status_energy()
  99     position[++i] = make_status_mem()
 100     position[++i] = make_status_cpu()
 101     position[++i] = make_status_disk()
 102     position[++i] = make_status_net()
 103     position[++i] = make_status_bluetooth()
 104     position[++i] = make_status_screen_brightness()
 105     position[++i] = make_status_volume()
 106     position[++i] = make_status_mpd()
 107     position[++i] = make_status_weather()
 108     position[++i] = make_status_datetime()
 109     position[++i] = ""
 110     bar = ""
 111     sep = ""
 112     for (j = 1; j <= i; j++) {
 113         bar = bar sep position[j]
 114         sep = " "
 115     }
 116     return bar
 117 }
 118
 119 function make_status_energy(    state, charge, direction_of_change) {
 120     state  = Data_get("khatus_sensor_energy", "battery_state")
 121     charge = Data_get("khatus_sensor_energy", "battery_percentage")
 122
 123     if (state == "discharging") {
 124         direction_of_change = "<"
 125     } else if (state == "charging") {
 126         direction_of_change = ">"
 127     } else {
 128         direction_of_change = "="
 129     }
 130
 131     return sprintf("E%s%d%%", direction_of_change, charge)
 132 }
 133
 134 function make_status_mem(    total, used, percent, status) {
 135     total = Data_get("khatus_sensor_memory", "total", 5)
 136     used  = Data_get("khatus_sensor_memory", "used" , 5)
 137     # To avoid division by zero when data is missing
 138     if (total && used) {
 139         percent = round((used / total) * 100)
 140         status = sprintf("%d%%", percent)
 141     } else {
 142         status = "__"
 143     }
 144     return sprintf("M=%s", status)
 145 }
 146
 147 function make_status_cpu(    load, temp, fan) {
 148     load = Data_get("khatus_sensor_loadavg"    , "load_avg_1min", 5)
 149     temp = Data_get("khatus_sensor_temperature", "temp_c"       , 5)
 150     fan  = Data_get("khatus_sensor_fan"        , "speed"        , 5)
 151
 152     load = load ? sprintf("%4.2f", load) : "--"
 153     temp = temp ? sprintf("%d"   , temp) : "--"
 154     fan  = fan  ? sprintf("%4d"  , fan)  : "--"
 155
 156     return sprintf("C=[%s %s°C %srpm]", load, temp, fan)
 157 }
 158
 159 function make_status_disk(    bytes_per_sector, bytes_per_mb, w, r, u) {
 160     bytes_per_sector = 512
 161     bytes_per_mb     = 1024 * 1024
 162
 163     w = Data_get("khatus_sensor_disk_io"   , "sectors_written"      , 5)
 164     r = Data_get("khatus_sensor_disk_io"   , "sectors_read"         , 5)
 165     u = Data_get("khatus_sensor_disk_space", "disk_usage_percentage", 10)
 166
 167     w = w ? sprintf("%0.3f", (w * bytes_per_sector) / bytes_per_mb) : "--"
 168     r = r ? sprintf("%0.3f", (r * bytes_per_sector) / bytes_per_mb) : "--"
 169     u = u ?                                                       u : "--"
 170
 171     return sprintf("D=[%s%% %s▲ %s▼]", u, w, r)
 172 }
 173
 174 function make_status_net(    \
 175     number_of_net_interfaces_to_show, \
 176     net_interfaces_to_show, \
 177     sensor_io, \
 178     sensor_wi, \
 179     out, \
 180     sep, \
 181     i, \
 182     interface, \
 183     label, \
 184     addr, \
 185     w, \
 186     r, \
 187     bytes_per_mb, \
 188     io_stat, \
 189     wifi \
 190 ) {
 191     number_of_net_interfaces_to_show = \
 192         split(opt_net_interfaces_to_show, net_interfaces_to_show, ",")
 193
 194     sensor_io = "khatus_sensor_net_addr_io"
 195     sensor_wi = "khatus_sensor_net_wifi_status"
 196
 197     out = ""
 198     sep = ""
 199     for (i = number_of_net_interfaces_to_show; i > 0; i--) {
 200         interface = net_interfaces_to_show[i]
 201         label = substr(interface, 1, 1)
 202
 203         addr = Data_get(sensor_io, "addr"          Kfs interface, 5)
 204         w    = Data_get(sensor_io, "bytes_written" Kfs interface, 5)
 205         r    = Data_get(sensor_io, "bytes_read"    Kfs interface, 5)
 206
 207         if (addr) {
 208             bytes_per_mb = 1024 * 1024
 209             w = w ? sprintf("%0.3f", w / bytes_per_mb) : "--"
 210             r = r ? sprintf("%0.3f", r / bytes_per_mb) : "--"
 211             io_stat = sprintf("%s▲ %s▼", w, r)
 212         } else {
 213             io_stat = "--"
 214         }
 215
 216         if (interface ~ "^w") {
 217             wifi = Data_get(sensor_wi, "status" Kfs interface, 10)
 218             label = label ":" (wifi ? wifi : "--")
 219         }
 220
 221         out = out sep label ":" io_stat
 222         sep = " "
 223     }
 224
 225     return sprintf("N[%s]", out)
 226 }
 227
 228 function make_status_bluetooth(    status) {
 229     status = Data_get("khatus_sensor_bluetooth_power", "power_status", 10)
 230     return sprintf("B=%s", status ? status : "--")
 231 }
 232
 233 function make_status_screen_brightness(    percentage) {
 234     percentage = Data_get("khatus_sensor_screen_brightness", "percentage", 5)
 235     percentage = percentage ? sprintf("%d", percentage) : "--"
 236     return sprintf("*%s%%", percentage)
 237 }
 238
 239 function make_status_volume(    sink, mute, vol_l, vol_r, status) {
 240     sink = opt_pulseaudio_sink
 241     mute  = Data_get("khatus_sensor_volume", "mute"      Kfs sink, 5)
 242     vol_l = Data_get("khatus_sensor_volume", "vol_left"  Kfs sink, 5)
 243     vol_r = Data_get("khatus_sensor_volume", "vol_right" Kfs sink, 5)
 244
 245     if (mute && vol_l && vol_r) {
 246              if (mute == "yes") {status = "X"}
 247         else if (mute == "no")  {status = sprintf("%s %s", vol_l, vol_r)}
 248         else {
 249             print_msg_error(\
 250                 "make_status_volume", \
 251                 "Unexpected value for 'mute' field: " mute \
 252             )
 253         }
 254     } else {
 255         status = "--"
 256     }
 257
 258     return sprintf("(%s)", status)
 259 }
 260
 261 function make_status_mpd(    state, status) {
 262     if (state = Data_get("khatus_sensor_mpd", "state", 5)) {
 263         if (state == "play") {
 264             status = make_status_mpd_state_known("▶")
 265         } else if (state == "pause") {
 266             status = make_status_mpd_state_known("❚❚")
 267         } else if (state == "stop") {
 268             status = make_status_mpd_state_known("⬛")
 269         } else {
 270             print_msg_error(\
 271                 "make_status_mpd", \
 272                 "Unexpected value for 'state' field: " state \
 273             )
 274             status = "--"
 275         }
 276     } else {
 277         status = "--"
 278     }
 279
 280     return sprintf("[%s]", status)
 281 }
 282
 283 function make_status_mpd_state_known(symbol,    s, song, time, percentage) {
 284     s = "khatus_sensor_mpd"
 285     song    = Data_get(s, "song"                   , 5)
 286     time    = Data_get(s, "play_time_minimal_units", 5)
 287     percent = Data_get(s, "play_time_percentage"   , 5)
 288     song    = substr(song, 1, opt_mpd_song_max_chars)
 289     return sprintf("%s %s %s %s", symbol, time, percent, song)
 290 }
 291
 292 function make_status_weather(    hour, t_f) {
 293     hour = 60 * 60
 294     t_f = Data_get("khatus_sensor_weather", "temperature_f", 3 * hour)
 295     t_f = t_f ? sprintf("%d", t_f) : "--"
 296     return sprintf("%s°F", t_f)
 297 }
 298
 299 function make_status_datetime(    dt) {
 300     dt = Data_get("khatus_sensor_datetime", "datetime", 5)
 301     return dt ? dt : "--"
 302 }
 303
 304 # -----------------------------------------------------------------------------
 305 # Output
 306 # -----------------------------------------------------------------------------
 307
 308 function print_msg_ok(key, val) {
 309     print_msg("OK", key, val, "/dev/stdout")
 310 }
 311
 312 function print_msg_error(location, msg) {
 313     print_msg("ERROR", location, msg, "/dev/stderr")
 314 }
 315
 316 function print_msg(status, key, val, channel) {
 317     print(status, "khatus_bar", key, val) > channel
 318 }
 319
 320 # -----------------------------------------------------------------------------
 321 # Numbers
 322 # -----------------------------------------------------------------------------
 323
 324 function round(n) {
 325     return int(n + 0.5)
 326 }