web-dev-qa-db-fra.com

Ajuste automatiquement la luminosité de l'écran en fonction du lever et du coucher du soleil

Des questions et réponses similaires dans Demandez à Ubuntu indiquent les solutions suivantes:

mais ils nécessitent soit la saisie manuelle des heures de lever et de coucher du soleil, soit simplement la balance des couleurs et ajoutent plus de rouge la nuit.

Je recherche une solution qui obtient automatiquement les heures de lever et de coucher du soleil chaque jour et règle physiquement la luminosité de l'écran. De plus, je souhaite un effet de transition sur une période de 60 à 120 minutes afin que je ne remarque pas le changement d'affichage.

La reconfiguration par temps nuageux (gradateur à l'extérieur) ou lorsque le soleil se couche entre deux bâtiments de trois étages au lieu de leurs toits (plus lumineux avant le coucher du soleil) devrait être un processus simple et rapide.

displaylaptopbrightnessbacklight
10
WinEunuuchs2Unix

Mise à jour du message à partir de 2019 - Eyesome

Eyesome est un script bash fonctionnant en tant que démon et dormant la plupart du temps, 24 heures sur 24, 7 jours sur 7. Il ajuste automatiquement la luminosité de l'écran (et éventuellement le gamma également) pour l'affichage de votre ordinateur portable via une interface matérielle et jusqu'à deux autres moniteurs à l'aide du contrôle logiciel de xrandr.

Au lever du soleil (l'heure est automatiquement obtenue chaque jour sur Internet), la luminosité de votre écran (et éventuellement du gamma également) est ajustée progressivement. Le réglage progressif est défini par vous mais 120 minutes me conviennent. Pour que les ajustements restent imperceptibles, définissez un intervalle de sommeil entre les ajustements. Le meilleur choix est probablement entre 15 et 60 secondes et la valeur par défaut est 60.

Le démon Eyesome dort plusieurs heures avant le début de la transition au coucher du soleil. À l'inverse de la transition au lever du soleil, la transition au coucher du soleil diminue progressivement la luminosité de l'écran (et éventuellement le gamma aussi), de sorte qu'elle ne soit pas visible. 90 minutes avant le coucher du soleil est recommandé, mais vous pouvez définir la période de votre choix.

Au coucher du soleil, le gamma peut être défini pour augmenter. Par exemple, le gamma rouge peut être défini à 1,0 le jour et à 1,2 la nuit pour réduire la fatigue oculaire. Le gamma bleu à son tour peut être défini à 1,0 pendant le jour et à 0,8 pendant la nuit, il diminuera donc à la place.

Pour réduire les ressources, eyeome dort toute la période entre les transitions du coucher et du lever du soleil. Il existe des exceptions ponctuelles lors de la reprise de la suspension ou du branchement à chaud de moniteurs externes. Cela dépend de l'endroit où vous vivez et de la saison de l'année, mais le sommeil moyen sera de 12 heures.

Vous pouvez télécharger Eyesome de Github

Post originale de 2017

Introduction

Ceci est une solution bash sans qu'il soit nécessaire d'installer des programmes supplémentaires. Il nécessite une connexion Internet (si vous lisez ceci, vous en avez une) pour obtenir automatiquement les heures de lever et de coucher du soleil chaque jour. Il fournit un écran de configuration convivial. Il démarre automatiquement avec cronet ne nécessite aucune interaction de l'utilisateur.

Cette réponse est divisée en plusieurs parties

  • Obtenez automatiquement les heures de lever et de coucher du soleil chaque jour avec cronname__
  • Configurer les paramètres de luminosité et le temps de transition
  • Script principal pour ajuster la luminosité en fonction de l'heure
  • Démarrer l'affichage-auto-luminosité automatiquement chaque démarrage avec cronname__
  • Réglage de la luminosité instantané/transparent à partir de la suspension
  • Résumé

Obtenez automatiquement les heures de lever et de coucher du soleil chaque jour avec cron

Il existe plusieurs sites Internet pour signaler les horaires de lever et coucher du soleil pour votre localité. Ce script utilise ( https://www.timeanddate.com/ ), un site connu depuis longtemps.

Avec les pouvoirs Sudo, éditez le fichier /usr/local/bin/Sun-hours et collez-le:

#!/bin/bash

# Called daily from /etc/cron.daily/Sun-hours
while true; do

### "-q"= quiet, "-O-" pipe output
echo $(wget -q -O- https://www.timeanddate.com/Sun/canada/edmonton | grep -oE 'Sunrise Today.{35}' | awk -F\> '{print $3}' | tr --delete "<") > /tmp/sunrise
echo $(wget -q -O- https://www.timeanddate.com/Sun/canada/edmonton | grep -oE 'Sunset Today.{35}' | awk -F\> '{print $3}' | tr --delete "<") > /tmp/sunset

## If network is down files will have one byte size
size1=$(wc -c < /tmp/sunrise)
size2=$(wc -c < /tmp/sunset)

if [ $size1 -gt 1 ] && [ $size2 -gt 1 ] ; then
    cp /tmp/sunrise /usr/local/bin/sunrise
    cp /tmp/sunset  /usr/local/bin/sunset
    chmod 666 /usr/local/bin/sunrise
    chmod 666 /usr/local/bin/sunset
    rm /tmp/sunrise
    rm /tmp/sunset
    exit 0
else
    logger "/etc/cron.daily/Sun-hours: Network is down. Waiting 5 minutes to try again."
    sleep 300
fi

done

Avant de sauvegarder le script, remplacez les deux occurrences de /canada/edmonton par votre propre pays et votre ville. Visitez le site www.timeanddate.com pour obtenir le nom ou le numéro exact. Par exemple, "Paris, États-Unis" a des dizaines de noms, ainsi ils contiendront un numéro tel que /worldclock/@5205082 pour "Paris, PA États-Unis".

Utilisez cron pour exécuter le script Sun-hours chaque jour

Avec les pouvoirs Sudo, éditez le fichier /etc/cron.daily/Sun-hours et collez-le:

#!/bin/sh
#
# Each day /etc/cron.daily/Sun-hours will get sunrise and sunset times.

sleep 60 # give time for network to come up.
/usr/local/bin/Sun-hours

Marquez les deux fichiers comme exécutables avec Sudo chmod a+x ___/Sun-hours où "___" est le répertoire pour chaque fichier.

Utilisez Conky pour surveiller les changements d'heure de lever/coucher du soleil chaque jour

Conky est un outil populaire pour surveiller votre système. Voici les commandes permettant d'afficher les paramètres lever, coucher et luminosité:

${color orange}${voffset 2}${hr 1}
${color}${goto 5}Day: ${color green}${execpi 300 cat /usr/local/bin/sunrise}  ${color}Night: ${color green}${execpi 300 cat /usr/local/bin/sunset}  ${color}Level: ${color green}${execpi 10 cat cat /sys/class/backlight/intel_backlight/brightness}
${color orange}${voffset 2}${hr 1}

Voici à quoi ça ressemble:

display-auto-brightness conky

Remarque: ce code Conky utilise intel_backlight que vous devez modifier en fonction de votre carte graphique, comme décrit dans les sections ci-dessous.

Configurer les paramètres de luminosité et le temps de transition

Vous ne voulez pas que votre affichage passe en pleine luminosité au lever du soleil et en obscurité totale au coucher du soleil. Une période de transition est nécessaire. De plus, un fichier de configuration est requis pour enregistrer les variables pour une luminosité et une atténuation maximales. Voici l'écran de configuration:

display-auto-brightness-config

L'écran est construit à l'aide de la commande standard zenity . Les valeurs existantes sont donc affichées dans les étiquettes avec la balise "(valeur)" et vous pouvez saisir de nouvelles valeurs si nécessaire. . Sinon, les fichiers existants sont conservés lorsque les nouvelles valeurs sont vides.

Remplacez intel_backlight par votre pilote d'affichage si différent. Pour trouver votre nom, utilisez: ls /sys/class/backlight/*/brightness.

En utilisant Sudo, créez le fichier /usr/local/bin/auto-brightness-config et collez-le dans le code suivant:

#!/bin/bash

# Read hidden configuration file with entries separated by " " into array
IFS=' ' read -ra CfgArr < /usr/local/bin/.auto-brightness-config

# Zenity form with current values in entry label
# because initializing multiple entry data fields not supported
output=$(zenity --forms --title="Display Auto Brightness Configuration" \
        --text="Enter new settings or leave entries blank to keep (existing) settings" \
   --add-entry="/sys/class/backlight/??????/brightness driver : (${CfgArr[0]})" \
   --add-entry="Day time maximum display brightness : (${CfgArr[1]})" \
   --add-entry="Transition minutes after sunrise to maximum : (${CfgArr[2]})" \
   --add-entry="Night time minimum display brightness : (${CfgArr[3]})" \
   --add-entry="Transition minutes before sunset to minimum : (${CfgArr[4]})")

IFS='|' read -a ZenArr <<<$output # Split zenity entries separated by "|" into array elements

# Update non-blank zenity array entries into configuration array
for i in ${!ZenArr[@]}; do
    if [[ ${ZenArr[i]} != "" ]]; then CfgArr[i]=${ZenArr[i]} ; fi
done

# write hidden configuration file using array (fields automatically separated by " ")
echo "${CfgArr[@]}" > /usr/local/bin/.auto-brightness-config

Marquez le fichier comme exécutable en utilisant:

chmod a+x /usr/local/bin/auto-brightness-config

Programme principal display-auto-brightness

En utilisant Sudo, créez le fichier /usr/local/bin/display-auto-brightness et collez-le dans le code suivant:

#!/bin/bash

# NAME: display-auto-brightness
# PATH: /usr/local/bin
# DESC: Set display brightness based on min/max values, Sun rise/set time
#       and transition minutes.
# CALL: Called from cron on system startup with @reboot option.
# DATE: Feb 17, 2017. Modified: Dec 2, 2017.

# NOTE: Only sleep for 1 minute to make display brightness changes gradual.
#       Configuration file can change any time so variables reread when waking.
#       The file is maintained by /usr/local/bin/auto-brightness-config script.

#       Sunrise and sunset time obtained from www.dateandtime.com using
#       /usr/local/bin/Sun-hours script. The script is called from cron using
#       /etc/cron.daily/cron-daily-Sun-hours. Variables stored in am/pm format
#       in /usr/local/bin/sunrise and /usr/local/bin/sunset.

#       When suspending at 6 am it might be dark with setting at 300. When 
#       resuming at 4:30pm it might be full Sun and setting needs to be 2000.
#       It will take between 1 and 59 seconds to adjust screen brightness with
#       sudden jump in brightness. To correct this create kill sleep command
#       during suspend with /lib/systemd/system-sleep/display-auto-brightness
#       script.

# TODO: Add support for external monitors connected via HDMI / DisplayPort.
#       xrandr --output HDMI-0  --brightness .799
#       xrandr --output DP-1-1  --brightness 1.15

if [[ $(id -u) != 0 ]]; then # root powers needed to call this script
    echo display-auto-brightness must be called with Sudo powers
    exit 1
fi

# global variable
LastSetting=""

function set-and-sleep {
    if [[ "$1" != "$LastSetting" ]]; then
        Sudo sh -c "echo $1 | Sudo tee $backlight"
        echo "$1" > "/tmp/display-current-brightness"
        LastSetting="$1"
    fi
    sleep 60
}  

re='^[0-9]+$'   # regex for valid numbers

function calc-level-and-sleep {
    # Parms $1 = number of minutes for total transition
    #       $2 = number of seconds into transition

    secTotal=$(( $1 * 60 )) # Convert total transition minutes to seconds
    Adjust=$( bc <<< "scale=6; $transition_spread * ( $2 / $secTotal )" )
    Adjust=$( echo $Adjust | cut -f1 -d"." ) # Truncate number to integer

    if ! [[ $Adjust =~ $re ]] ; then
        Adjust=0   # When we get to last minute $Adjust can be non-numeric
    fi

    calc_bright=$(( $min_bright + $Adjust ))
    set-and-sleep "$calc_bright"
}


while true ; do

    # Although variables change once a day it could be weeks between reboots.
    sunrise=$(cat /usr/local/bin/sunrise)
    sunset=$(cat /usr/local/bin/sunset)

    # Read hidden configuration file with entries separated by " " into array
    IFS=' ' read -ra CfgArr < /usr/local/bin/.auto-brightness-config
    backlight="/sys/class/backlight/${CfgArr[0]}/brightness"
    max_bright="${CfgArr[1]}"
    after_sunrise="${CfgArr[2]}"
    min_bright="${CfgArr[3]}"
    before_sunset="${CfgArr[4]}"

    # Current seconds
    secNow=$(date +"%s")
    secSunrise=$(date --date="$sunrise today" +%s)
    secSunset=$(date --date="$sunset today" +%s)

    # Is it night time?
    if [ "$secNow" -gt "$secSunset" ] || [ "$secNow" -lt "$secSunrise" ]; then
        # MINIMUN: after sunset or before sunrise nightime setting
        set-and-sleep "$min_bright"
        continue
    fi

    # We're somewhere between sunrise and sunset
    secMaxCutoff=$(( $secSunrise + ( $after_sunrise * 60 ) ))
    secMinStart=$((  $secSunset  - ( $before_sunset * 60 ) ))

    # Is it full bright day time?
    if [ "$secNow" -gt "$secMaxCutoff" ] && [ "$secNow" -lt "$secMinStart" ]; then
        # MAXIMUN: after sunrise transition AND before nightime transition
        set-and-sleep "$max_bright"
        continue
    fi

    # Daytime - nightime = transition brightness levels
    transition_spread=$(( $max_bright - $min_bright ))

    # Are we between sunrise and full brightness?
    if [ "$secNow" -gt "$secSunrise" ] && [ "$secNow" -lt "$secMaxCutoff" ]; then
        # Current time - Sunrise = progress through transition
        secPast=$(( $secNow - $secSunrise ))
        calc-level-and-sleep $after_sunrise $secPast
        continue
    fi

    # Are we between beginning to dim and sunset (full dim)?
    if [ "$secNow" -gt "$secMinStart" ] && [ "$secNow" -lt "$secSunset" ]; then
        # Sunset - Current time = progress through transition
        secBefore=$(( $secSunset - $secNow ))
        calc-level-and-sleep $before_sunset $secBefore
        continue
    fi

    # At this stage brightness was set with manual override outside this program
    # or exactly at a testpoint, then it will change next minute so no big deal.
    sleep 60 # reset brightness once / minute.

done # End of forever loop

Marquez le fichier comme exécutable en utilisant:

chmod a+x /usr/local/bin/display-auto-brightness

REMARQUE: Le 26 août 2017, le message a été revu sans suite pour corriger un bogue qui bloquait le programme lorsque le dernier niveau de luminosité était égal à la luminosité minimale ou maximale et que la valeur de réglage de la minute en cours est blanc (zéro). Fixé avec succès le 2 décembre 2017 mais pas publié avant le 17 février 2018. Ooops!

Démarrer l'affichage-auto-luminosité automatiquement chaque démarrage avec cronname__

Cron est utilisé pour démarrer l'application principale à chaque démarrage. Créez le fichier /etc/cron.d/display-auto-brightness avec les pouvoirs Sudo et copiez-le dans ceci:

Shell=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
@reboot   root    /usr/local/bin/display-auto-brightness

Réglage instantané de la luminosité après la suspension

Vous pouvez suspendre votre ordinateur à 6 heures du matin quand il se lève avant que le soleil ne se lève et que votre réglage soit à 300. Vous pouvez le reprendre à 16 heures lorsque le soleil est brillant et le réglage devrait être 2000, mais vous devez attendre 1 à 59 secondes pour display-auto-brightness. pour réinitialiser l'affichage. Lorsque l'affichage est réinitialisé, le changement est spectaculaire. Pour résoudre ce problème, un script systemdest nécessaire. Créez le fichier /lib/systemd/system-sleep/display-auto-brightness contenant:

#!/bin/sh

# NAME: display-auto-brightness
# PATH: /lib/systemd/system-sleep/
# DESC: Restart display brightness when resuming from suspend
# CALL: Automatically called when system goes to sleep and wakes up
# DATE: August 2017. Modified: June 10, 2018.

# NOTE: Gives instant display brightness adjustment instead of waiting 1 to 59 seconds.

logger -t "logger -t "test" "\$0=$0, \$1=$1, \$2=$2" test" "\$0=$0, \$1=$1, \$2=$2"

case $1/$2 in
  pre/*)
    echo "/lib/systemd/system-sleep/display-auto-brightness: Going to $2..."
    ;;
  post/*)
    # March 28, 2018 On AW17R3 this script runs too fast
    sleep 2

    echo "/lib/systemd/system-sleep/display-auto-brightness: Resuming from $2..."

    # Find running tree processes containing "display-auto" AND "sleep"
    ProgramTree=$(pstree -g -p | grep display-auto | grep sleep)
    # echo's below will print in /var/log/syslog. Comment out with # to suppress
    echo "pstree -g -p | grep display-auto | grep sleep"
    echo "============================================="
    echo "$ProgramTree"

    # extract sleep program ID within `pstree`. eg we would want "16621" below:
    # |-cron(1198,1198)---cron(1257,1198)---sh(1308,1308)---display-auto-br(1321,1308)---sleep(16621,1308)
    pID=$(echo "$ProgramTree" | cut -f 6 -d '(' )
    pID=$(echo "$pID" | cut -f1 -d",")

    kill $pID  # kill sleep command forcing screen brightness to adjust immediately
    rm /tmp/display-current-brightness
    echo "display-auto-brightness: sleep pID: '$pID' has been killed."
    ;;
esac

Marquez le fichier comme exécutable en utilisant:

chmod a+x /lib/systemd/system-sleep/display-auto-brightness

Résumé

Afficher le niveau de luminosité actuel est systray

En plus de l'exemple de Conky présenté précédemment, indicateur-sysmoniteur , vous pouvez afficher la luminosité actuelle dans la barre d'état système via bash:

display-auto-brightness systray

Dans cet exemple, la luminosité est réglée sur 418 et environ 20 minutes avant le coucher du soleil. Au coucher du soleil, la valeur sera de 250 et la luminosité maximale de jour sera de 1200. Sur cette machine, intel_backlight = 4882 est possible, mais si vous êtes à l'intérieur avec des rideaux ouverts, l'écran est comme si vous regardiez le soleil.

L’indicateur systray est configuré à l’aide de ce code:

#!/bin/bash

if [ -f ~/.lock-screen-timer-remaining ]; then
    text-spinner
    Spinner=$(cat ~/.last-text-spinner) # read last text spinner used
    Minutes=$(cat ~/.lock-screen-timer-remaining)
    systray=" $Spinner Lock screen in: $Minutes"
else
    systray=" Lock screen: OFF"
fi

if [ -f /tmp/display-current-brightness ]; then
    Brightness=$(cat /tmp/display-current-brightness)
    systray="$systray Brightness: $Brightness"
else
    systray="$systray Brightness: OFF"
fi

echo "$systray" # sysmon-indidicator will put echo string into systray for us.

exit 0

Ce Q & A ( BASH peut-il afficher dans systray en tant qu’indicateur d’application? ) décrit comment configurer indicateur-sysmonitor.

Améliorations futures

  • Migration des scripts bash pour cette réponse vers github
  • Ajout de la prise en charge des moniteurs externes à l'aide de xrandrname__
  • Ajout du support pour plus de rouge/moins de bleu en utilisant xrandrname__
7
WinEunuuchs2Unix

Je viens d'écrire un programme qui fait presque ce que vous recherchez. Il change la luminosité de l'écran en fonction des images prises par votre webcam pour obtenir la luminosité ambiante. Vous pouvez choisir l'intervalle pour détecter vous-même la luminosité et la vitesse de variation.

https://github.com/Wandersalamander/Dimmer

3
wandersalamander

Ce script ajuste la luminosité du rétroéclairage en fonction des données d'image de la webcam. Cela vous aidera peut-être à résoudre votre problème.

https://github.com/unxed/brightness.sh/blob/master/backlight.sh

0
unxed