Archivo

Entradas Etiquetadas ‘ahorro’

Creando un menú selector de frecuencia de nuestra CPU

Lunes, 9 de Enero de 2012 Gaspar Fernández 2 comentarios

screenshot-05-01-2012-220103

A mí me gusta tener el control sobre la frecuencia de la CPU, ya sea porque muchas veces no estoy haciendo nada y lo quiero dejar al mínimo de velocidad para que se caliente menos, o porque algunas veces necesito un poco más de potencia, y otras veces lo dejo a su aire para que cambie de frecuencia solo.

El script se basa en llamadas a cpufreq-set de cpufrequtils, aunque la llamada tiene que ser con permisos de root, por lo que conviene ver antes este artículo, de todas formas, todo esto se hará paso a paso.

Requisitos

  • CPU soportada por cpufreq
  • Sudo / Gksudo
  • Cpufrequtils
  • Zenity
  • Xosd

Editando sudoers

Este script lo ejecutaremos desde nuestro usuario, pero la llamada a cpufreq-set necesita permisos especiales, por lo tanto, lo haremos con sudo. Si saltamos este paso, nos preguntará la contraseña para ejecutar los comandos, pero si no queremos que nos pregunte, debemos hacer esto.

Lo primero es ejecutar:

$ sudo visudo

Y en el archivo, debajo de la última línea sin comentario, escribimos:

mi_usuario   ALL= NOPASSWD : /usr/bin/cpufreq-set

Sustituyendo mi_usuario por el usuario que va a ejecutar el script. Si tenéis varios usuarios podéis añadirlos uno por línea, o ver el artículo mencionado antes para más opciones.

El script

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#!/bin/bash

DIALOG=zenity
CPUFREQSET=`which cpufreq-set`
OSDCAT=`which osd_cat`

XOSD_FONT="-*-luxisans-bold-*-*-*-47-*-*-*-*-*-*-*"
XOSD_OPTIONS="--pos=bottom -o -210 -A center -c green -s 2 -d 2 -f "$XOSD_FONT;
tempfile=`tempfile 2>/dev/null` || tempfile=/tmp/test$$
trap "rm -f $tempfile" 0 1 2 5 15

if [ -z $CPUFREQSET ]
then
    echo "cpufrequtils no está instalado"
    exit
fi

if [ -z $OSDCAT ]
then
    echo "xosd no está instalado"
    exit
fi

if [ -e "/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies" ]
then
    actual=`cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq`
    cnt=0
    for i in `cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies`
    do
    if [[ $i != $actual ]]; then
        cnt=`expr $cnt + 1`
    fi
    done
else
    echo "CPUfreq no está disponible"
    exit    
fi

simple_math()
{
    echo "scale=2; $1" | bc;
}

saca_freq()
{
    cnt=0
    for i in `cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies`
      do
      if [[ $cnt == $1 ]]; then
      frq=$i
      break
      fi
      cnt=`expr $cnt + 1`
    done
    echo $frq
}

pone_freqs()
{
    cnt=0
    for j in `cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies`
      do
      if [[ $j != $actual ]]; then
      frq=$frq":Cpufreq "$cnt":"`simple_math $j/1000000`" Ghz"
      fi
      cnt=`expr $cnt + 1`
    done
    echo $frq
}

pone_governors()
{
    possible_governors=([0]=powersave [1]=conservative [2]=ondemand [3]=performance)
    governor_command=([0]=Powersave [1]=Conservative [2]=Ondemand [3]=Performance)
    governor_text=([0]="Ahorro de energía" [1]="Modo conservador" [2]="Modo Bajo demanda" [3]="Modo rendimiento")
    available_governors=`cpufreq-info -g`

    for (( g=0; g<${#possible_governors[*]}; g++ ))
    do
    # echo $g
    # echo ${possible_governors[$g]}
    gov=${possible_governors[$g]}
    if [ -n "`echo $available_governors | grep $gov`" ]
    then
        frq=$frq":"${governor_command[$g]}":"${governor_text[$g]}
    fi
    done
   
    echo $frq
}

freqs="Exit:No hacer nada"
freqs=$freqs`pone_freqs`
freqs=$freqs`pone_governors`

OLD_IFS=$IFS
IFS=":"


$DIALOG --width=240 --height=250 --title="Selector de frecuencia" --list --column "ID" --column "Frecuencia" --hide-column 1 --text "Elige una opcion" $freqs > $tempfile

retval=$?
IFS="${OLD_IFS}"

choice=`cat $tempfile`

comando=`echo $choice | cut --delimiter " " --fields 1`
modif=`echo $choice | cut --delimiter " " --fields 2`

case $retval in
  0)
    case $comando in
        "Exit")
        echo "Salir" | osd_cat $XOSD_OPTIONS
        ;;
        "Cpufreq")
        freqdef=`saca_freq $modif`
        gksudo "$CPUFREQSET -g userspace"
        gksudo "$CPUFREQSET -f $freqdef"
        echo "Velocidad actual "`simple_math $freqdef/1000000`"Ghz" | $OSDCAT $XOSD_OPTIONS
        ;;
        "Powersave")
        gksudo "/usr/bin/cpufreq-set -g powersave"
        echo "Modo ahorro de energía" | $OSDCAT $XOSD_OPTIONS
        ;;
        "Conservative")
        gksudo "/usr/bin/cpufreq-set -g conservative"
        echo "Modo conservador" | $OSDCAT $XOSD_OPTIONS
        ;;
        "Ondemand")
        gksudo "/usr/bin/cpufreq-set -g ondemand"
        echo "Modo bajo demanda" | $OSDCAT $XOSD_OPTIONS
        ;;
        "Performance")
        gksudo "/usr/bin/cpufreq-set -g performance"
        echo "Modo rendimiento" | $OSDCAT $XOSD_OPTIONS
        ;;     
    esac;;
  1)
    echo "Cancelado";;
  255)
    echo "Escape";;
esac

Notas del script

  • He optado por filtrar el resultado de cpufreq-info -g y cambiar las palabras, me gusta filtrar todos los datos que me llegan.
  • Añadí la primera opción para no hacer nada, porque me resultó más cómoda cuando quiero cancelar el menú
  • zenity nos devuelve dos cosas: El resultado de la ejecución y el valor elegido, por tanto el primer valor lo podemos averiguar del script, el segundo lo devuelve como texto, por eso lo almacenamos en un archivo temporal
  • Para cambiar el tipo de letra, tenemos que ejecutar xfontsel, desde ese programa, elegir el tipo de letra y copiar el texto que nos devuelve a la variable XOSD_FONT
    • Por último…

      Para disfrutar de este script, lo bueno es asociarlo a una tecla, por ejemplo yo lo tengo en Meta+F3 y con ello se puede cambiar la frecuencia rápidamente.

Suspensión e hibernación con uswsusp

Lunes, 4 de Julio de 2011 Gaspar Fernández Sin comentarios

Desde hace años, he tenido mala suerte con los sistemas de suspensión de sistema e hibernación. En mi época Windows (que casi todos hemos tenido), casi nunca suspendía el sistema, sobre todo porque, luego no espabilaba, vamos que, unas veces se quedaba el sistema dormido y no respondía, y otras veces parecía que volvía a responder pero no terminaba de encender. El gran problema era que pasara lo que pasara no podía monitorizar el problema, ni arreglarlo, por mucho que investigué. Aunque parece que a día de hoy ya no existe tanto problema con este sistema operativo.

Cuando entré en el mundo Linux, al principio tuve problemas similares, o que directamente no podía hibernar ni suspender porque el sistema no quería sencillamente, la verdad es que investigar un poco en el tema tampoco sirvió de mucho porque parecía que a todo el mundo le funcionaba directamente, menos a mí. Mi cruzada en este ámbito empezó con Gentoo, y por aquel entonces me paré a mirar todos los kernels que tenía disponibles y descubrí el kernel tuxonince, que era especial para hibernar y suspender. En Gentoo no tuve más problemas.

Aunque poco a poco toca renovarse, y en un netbook que utilizo para los viajes instalé Linux Mint Debian Edition, el netbook no es gran cosa, pero me hace el apaño y un tema que me preocupa, ahora sí, es la energía, ya que si estoy con batería (que dura unas escasas 2h:30) y por un momento dejo de utilizarlo, es tiempo que pierdo, por lo que vendría bien suspenderlo, que consuma poca energía y espabilarlo cuando vuelva a utilizarlo (apagarlo y encenderlo, puede ser muy pesado y en ocasiones gastar más energía aún, además de perder tiempo).
Como es normal, de serie no funciona ni la hibernación ni la suspensión, por lo que tuve que buscar alternativas, tal vez más adelante instale los parches de tuxonice, pero por el momento tengo prisa y no quiero compilar el kernel (que puede tirarse unas 3h).

Lo primero fue instalar uswsusp, y dado que no está marcado como estable en Debian, LMDE tampoco lo trae, por lo que las opciones son añadir sid a los repositorios, o bajarlo de aquí.

$ dpkg -i uswsusp_1.0-1_[plataforma].deb

Seguidamente, aunque hice pruebas con pm-utils (instalado por defecto), no logré que nada funcionara, incluso cambiando todas las configuraciones disponibles, por lo que instalé el hibernate script, que utilizaba yo con tuxonice, este sí que viene en el repositorio oficial:

$ apt-get install hibernate

De serie, no funcionó, aunque cambiando algo de configuración sí:

$ sudo nano /etc/hibernate/ususpend-ram.conf

Y cambiar las siguientes líneas:

1
2
USuspendRamForce yes  # Quitamos el comentario, porque mi sistema no lo reconoce automáticamente.
USuspendRamVbeSave yes   # Salvamos el estado del hardware, y luego lo restauramos.

Ahora, para hibernar ejecutamos el hibernate script, tanto hibernate como hibernate-ram para que todo funcione.
Más adelante probaré con tuxonice+LMDE, y publicaré mis resultados.

Nos ponemos serios con PHP: Empezamos con un CRUD (la esencia no es exclusiva de PHP)

Viernes, 16 de Julio de 2010 Gaspar Fernández Sin comentarios

crudHace años tuve entre manos un gran proyecto web, en el que invertí 8 meses de mi vida y funcionó bastante bien durante un tiempo. En su desarrollo recuerdo que tuve que desarrollar cerca 50 formularios diferentes, comprobar los valores de cada uno de los campos, hacer lecturas y escrituras en base de datos con los datos obtenidos, y opcionalmente realizar alguna tarea extra una vez enviado y validado el formulario. Además, tenía que ser capaz de listar la información, modificarla y eliminarla. Por aquel entonces, aunque había partes en común y aproveché para realizar código, no lo hice de la forma más efectiva; podría haber ahorrado muchísimo trabajo.
En los últimos años, para mis proyectos web decidí fabricarme una biblioteca para hacer este tipo de tareas de forma más rápida (con menos esfuerzo, y al fin y al cabo de forma más depurada y segura). Para eso me fabriqué una biblioteca CRUD.

Es cierto que perdemos eficiencia, es más rápida por lo general una herramienta específica, que haga justo lo que se le pide en un momento dado, que una herramienta configurable y flexible (tendremos muchas más sentencias de control y a veces se ejecutarán procesos innecesarios), pero por otro lado hay que tener en cuenta que no podemos echar un mes en un proyecto que generalmente requiere unos días, y por otra parte, seguro seguro que tenemos que hacer modificaciones antes de entregarlo, y éstas no deben llevarnos otro mes más. En definitiva, nos compensa perder algo de eficiencia en favor de un tiempo de desarrollo más corto y generar un código más fácilmente mantenible.

Lo importante de un CRUD, es la posibilidad de Crear, Ver, Actualizar, Borrar (y listar información), si lo pensamos es simple, lo ideal sería tener una clase (o una función) que simplemente llamándola nos hiciera esta complicada tarea; aunque también es verdad, si lo pensamos un poco más, que podemos complicar todo esto de mil formas, y todo lo que queramos. Además, tenemos que crear una herramienta que sea lo más flexible posible para todo tipo de bases de datos y tablas, y además, sería interesante manejar los errores que puedan surgir en el proceso, para poder generar una salida acorde.

Aunque podemos encontrar bibliotecas por Internet que hacen esta tarea, yo siempre prefiero una solución DIY (Do it yourself) (Hazlo tú mismo), de esta forma, el código será 100% mío y yo controlaré el proceso por completo, además de que como materia de aprendizaje es bastante efectivo. Dejo por aquí algunas instrucciones para empezar a fabricarnos un CRUD un tanto sencillo (y que a medida que vayamos haciendo proyectos podemos ir completándolo con las necesidades que nos vayan surgiendo):

  • Listar información de base de datos: Debemos tener la posibilidad de elegir los campos a listar
  • Crear entrada: Debemos tener la posibilidad de introducir campos que concuerden con entradas en una base de datos, y también la posibilidad de generar datos automáticamente (fecha de introducción, identificadores únicos, etc):
    • Necesitaremos un generador de formularios y la posibilidad de elegir el mejor tipo de campo para cada campo de la tabla que vamos a modificar
    • Debemos tener la posibilidad de verificar, vía servidor (PHP) o cliente (Javascript), mejor hacerlo de las dos formas, que los datos estén bien formados (números máximos de caracteres, formato de introducción (por ejemplo, de una fecha, un teléfono, una dirección e-mail…)
    • Inserción en tabla, y muestra de la salida, para que el usuario vea si todo ha ido bien o mal. Sería conveniente también, que esto fuera una redirección, para que, si se refresca la página, no se reenvíen los formularios.
  • Modificar entrada:
    • Podemos aprovechar mucho código de la creación de entrada (muestra de formulario, verificación…)
    • Debemos modificar la tabla de datos, a lo mejor actualizar fechas de modificación, logs, etc
  • Eliminar entrada:
    • Idealmente, debemos presentar un diálogo tipo: “¿Está seguro?” para confirmar que no se hace por accidente, tal vez los datos no siempre interese eliminarlos, sólo hacer una marca de que no se visualicen.
  • Ver información:
    • Necesitamos hacer un sistema de visualización flexible, automático y tener la posibilidad de seleccionar los campos a mostrar (los identificadores únicos, fechas internas, IDs, no le suelen interesar al usuario), por otra parte, a veces para visualizar un dato es necesario hacer varias consultas a base de datos y tenemos que estar preparados.

Pero como dije antes, esto lo podemos complicar hasta la saciedad, aumentando el número de campos que podemos introducir (por ejemplo inserción de ficheros, Javascripts para introducir la fecha de forma fácil, o inclusión de áreas de texto HTML (como TinyMCE).

En cuanto al listado podemos implementar paginación automática (para el caso de que haya muchos elementos a listar) y ordenación de los elementos por columna (tal vez por nombre, por fecha, etc)

Por otra parte, tenemos que tener muy en cuenta el diseño, éste suele ser diferente para cada página (quitando esas páginas que parece que están hechas todas con el mismo molde), así que tenemos que hacer que nuestra salida en (x)HTML sea lo más flexible posible, que nos deje introducir código adicional, cambiar las imágenes utilizadas (iconos de insertar, eliminar…)

Y como colofón, podemos implementar soporte para relaciones, puede que echemos unos días desarrollando nuestro CRUD, pero  nos va a ahorrar mucho tiempo de desarrollo si lo utilizamos en nuestros proyectos.

Visita otras webs de la red