sensors.c

来自「系统任务管理器」· C语言 代码 · 共 2,517 行 · 第 1/5 页

					sensor->iodev, sensor->inter, &sensor->raw_value);
		sensor->value = sensor->raw_value * sensor->factor + sensor->offset;
		if (units_fahrenheit)
			sensor->value = 1.8 * sensor->value + 32.0;
		t = sensor->value;
		}
	if (! found_temp && _GK.demo)
		{
		t = 90.0 + (gfloat)(random() & 0xf);
		found_temp = TRUE;
		}
	if (temp)
		*temp = t;
	if (units)
		*units = units_fahrenheit ? 'F':'C';
	if ((_GK.debug_level & DEBUG_SENSORS) && sensor)
		printf("sensor_temp: %s %s t=%.2f\n",
					sensor->name_locale, sensor->path, sensor->value);
	if (found_temp && sensor)
		gkrellm_check_alert(sensor->alert, sensor->value);
	return found_temp;
	}

gboolean
gkrellm_sensor_read_temperature(gpointer sr, gfloat *temp, gchar *units)
	{
	return sensor_read_temperature((Sensor *) sr, temp, units);
	}


static gboolean
sensor_read_fan(Sensor *sensor, gfloat *fan)
	{
	gfloat	f = 0;
	gint	found_fan = FALSE;

	if (sensor && get_fan)
		{
		found_fan = thread_data_valid ? TRUE
				: (*get_fan)(sensor->path, sensor->id,
						sensor->iodev, sensor->inter, &sensor->raw_value);
		sensor->value = sensor->raw_value * sensor->factor;
		f = sensor->value;
		}
	if (! found_fan && _GK.demo)
		{
		f = 4980 + (gfloat)(random() & 0x3f);
		found_fan = TRUE;
		}
	if (fan)
		*fan = f;
	if ((_GK.debug_level & DEBUG_SENSORS) && sensor)
		printf("sensor_fan: %s %s rpm=%.0f\n",
					sensor->name_locale, sensor->path, sensor->value);
	if (found_fan && sensor)
		gkrellm_check_alert(sensor->alert, sensor->value);
	return found_fan;
	}

gboolean
gkrellm_sensor_read_fan(gpointer sr, gfloat *fan)
	{
	return sensor_read_fan((Sensor *) sr, fan);
	}


static gboolean
sensor_read_voltage(Sensor *sensor, gfloat *voltage)
	{
	gfloat		v = 0;
	gfloat		offset;
	gboolean	found_voltage = FALSE;

	if (sensor && get_voltage)
		{
		found_voltage = thread_data_valid ? TRUE
			: (*get_voltage)(sensor->path, sensor->id,
					sensor->iodev, sensor->inter, &sensor->raw_value);
		offset = sensor->offset;
		if (sensor->vref)	/* A negative voltage is level shifted by vref */
			offset *= sensor->vref->value;
		sensor->value = sensor->raw_value * sensor->factor + offset;
		v = sensor->value;
		}
	if (! found_voltage && _GK.demo)
		{
		v = 2.9 + (gfloat)(random() & 0x7) * 0.1;
		found_voltage = TRUE;
		}
	if (voltage)
		*voltage = v;
	if ((_GK.debug_level & DEBUG_SENSORS) && sensor)
		printf("sensor_voltage: %s %s v=%.2f\n",
				sensor->name_locale, sensor->path, sensor->value);
	if (found_voltage && sensor)
		gkrellm_check_alert(sensor->alert, sensor->value);
	return found_voltage;
	}

gboolean
gkrellm_sensor_read_voltage(gpointer sr, gfloat *voltage)
	{
	return sensor_read_voltage((Sensor *) sr, voltage);
	}

/* =================================================================== */
/* The sensors monitor */

static void		sensor_reset_optionmenu(Sensor *sensor);

#define	SENSOR_STYLE_NAME	"sensors"

/* Temperature and fan sensors can be located on different panels depending
|  on the sensor group.
*/
#define	SENSOR_PANEL_LOCATION	0

#define	PROC_PANEL_LOCATION		1	/* SENSOR_GROUP_MAINBOARD */
#define	CPU_PANEL_LOCATION		2	/* cpu0 if smp */

#define	DISK_PANEL_LOCATION		1	/* SENSOR_GROUP_DISK	*/


#define DO_TEMP	1
#define	DO_FAN	1
#define	DO_VOLT	1

typedef struct
	{
	GkrellmPanel	**panel;
	GkrellmDecal	*name_decal,
					*sensor_decal;
	Sensor			*sensor;
	}
	SensorMon;

static GtkWidget
				*temp_vbox,
				*fan_vbox,
				*volt_vbox;

static GList	*volt_list,
				*temperature_list,
				*fan_list,
				*disk_temperature_list;

static GkrellmPanel
				*pVolt,
				*pTemp,
				*pFan;

static gint		style_id;
static gint		volt_mon_width,
				volt_mon_height,
				volt_name_width,
				volt_bezel_width;


  /* Display modes */
#define	DIGITAL_WITH_LABELS	0
#define	DIGITAL_NO_LABELS	1
#define	N_DISPLAY_MODES		2

#define	MONITOR_PAD		6
#define	NAME_PAD		4

GkrellmMonitor	*mon_sensors;
GkrellmMonitor	*mon_config_sensors;

static GkrellmPiximage
				*bezel_piximage;

static GkrellmStyle
				*bezel_style;		/* Just for the bezel image border */

static gint		display_mode,
				have_negative_volts;

static gint		minus_width;		/* If will be drawing neg voltages */

  /* If drawing '-' sign, grub a pixel or two to tighten the layout */
static gint		pixel_grub;


static gint		sensor_config_version;

  /* Avoid writing decimal values into the config to avoid possible
  |  locale changing decimal point breakage (decimal point can be '.' or ',')
  */
#define	SENSOR_FLOAT_FACTOR		10000.0
static gfloat		sensor_float_factor = 1.0,
					gkrellm_float_factor = 1.0;

void
gkrellm_sensor_reset_location(gpointer sr)
	{
	GList	*list;
	Sensor	*sensor;

	for (list = sensor_list; list; list = list->next)
		{
		sensor = (Sensor *) list->data;
		if (sr == sensor)
			{
			sensor->location = SENSOR_PANEL_LOCATION;
			sensor_reset_optionmenu(sensor);
			break;
			}
		}
	}


static void
sensor_relocation_error(gchar *pname)
	{
	gchar	*msg;

	msg = g_strdup_printf(
				_("Can't find a %s panel to relocate sensor to."),
				pname ? pname : "?");
	gkrellm_config_message_dialog(NULL, msg);
	g_free(msg);
	}

  /* When moving off some other panel, reset that panel.
  */
static void
sensor_reset_location(Sensor *sr)
	{
	if (sr->group == SENSOR_GROUP_MAINBOARD)
		{
		if (sr->location == PROC_PANEL_LOCATION)
			gkrellm_proc_set_sensor(NULL, sr->type);
		else if (sr->location >= CPU_PANEL_LOCATION)
			gkrellm_cpu_set_sensor(NULL, sr->type,
						sr->location - CPU_PANEL_LOCATION);
		}
	else if (sr->group == SENSOR_GROUP_DISK)
		{
		if (sr->location == DISK_PANEL_LOCATION)
			gkrellm_disk_temperature_remove(sr->id_name);
		}
	}

void
gkrellm_sensors_interface_remove(gint interface)
	{
	GList		*list;
	Sensor		*sensor;
	gboolean	removed_one;

	do
		{
		removed_one = FALSE;
		for (list = sensor_list; list; list = list->next)
			{
			sensor = (Sensor *) list->data;
			if (sensor->inter == interface)
				{
				sensor_reset_location(sensor);
				g_free(sensor->id_name);
				g_free(sensor->path);
				g_free(sensor->name);
				g_free(sensor->default_label);
				g_free(sensor->vref_name);
				sensor_list = g_list_remove(sensor_list, sensor);
				g_free(sensor);
				removed_one = TRUE;
				break;
				}
			}
		}
	while (removed_one);		
	}

static void
add_sensor_monitor(Sensor *sr, GkrellmPanel **p, GList **smon_list)
	{
	SensorMon		*smon;
	gfloat			t;
	gchar			units;
	gboolean		set_loc = FALSE;

	sr->smon = NULL;
	if (!sr->enabled)
		return;

	if (sr->location != SENSOR_PANEL_LOCATION)
		{
		if (sr->group == SENSOR_GROUP_MAINBOARD)
			{
			if (sr->location == PROC_PANEL_LOCATION)
				set_loc = gkrellm_proc_set_sensor(sr, sr->type);
			else
				set_loc = gkrellm_cpu_set_sensor(sr, sr->type,
							sr->location - CPU_PANEL_LOCATION);
			}
		else if (sr->group == SENSOR_GROUP_DISK)
			{
			if (sr->location == DISK_PANEL_LOCATION)
				{
				gkrellm_freeze_alert(sr->alert);
				sensor_read_temperature(sr, &t, &units);
				gkrellm_thaw_alert(sr->alert);
				set_loc = gkrellm_disk_temperature_display((gpointer) sr,
							sr->id_name, t, units);
				if (set_loc)
					disk_temperature_list =
							g_list_append(disk_temperature_list, sr);
				}
			}
		if (set_loc)
			return;
		sr->location = SENSOR_PANEL_LOCATION;
		}
	smon = g_new0(SensorMon, 1);
	smon->sensor = sr;
	smon->panel = p;		/* Alerts need a GkrellmPanel ** */
	*smon_list = g_list_append(*smon_list, smon);
	sr->smon = (gpointer) smon;
	}

static void
make_sensor_monitor_lists(gboolean do_temp, gboolean do_fan, gboolean do_volt)
	{
	GList	*list;
	Sensor	*sr;

	if (do_temp)
		{
		gkrellm_free_glist_and_data(&temperature_list);
		g_list_free(disk_temperature_list);
		disk_temperature_list = NULL;
		}
	if (do_fan)
		gkrellm_free_glist_and_data(&fan_list);
	if (do_volt)
		gkrellm_free_glist_and_data(&volt_list);

	for (list = sensor_list; list; list = list->next)
		{
		sr = (Sensor *) list->data;
		if (do_temp && sr->type == SENSOR_TEMPERATURE)
			add_sensor_monitor(sr, &pTemp, &temperature_list);
		if (do_fan && sr->type == SENSOR_FAN)
			add_sensor_monitor(sr, &pFan, &fan_list);
		if (do_volt && sr->type == SENSOR_VOLTAGE)
			{
			if (!sr->has_config && sr->vref_name)
				sr->vref = lookup_vref(sr, sr->vref_name);
			add_sensor_monitor(sr, &pVolt, &volt_list);
			}
		}
	}

#include "pixmaps/sensors/bg_volt.xpm"

static void
cb_alert_trigger(GkrellmAlert *alert, SensorMon *smon)
	{
	GkrellmAlertdecal	*ad;
	GkrellmDecal		*d;

	ad = &alert->ad;
	alert->panel = *smon->panel;

	/* Make the GkrellmAlertdecal show up under the sensor decal
	*/
	d = smon->sensor_decal;
	if (d)
		{
		ad->x = d->x - 2;
		ad->y = d->y - 2;
		ad->w = d->w + 3;
		ad->h = d->h + 4;
		gkrellm_render_default_alert_decal(alert);
		}
	}


static void
draw_bezels(GkrellmPanel *p, GList *smon_list, gint w, gint h, gint x_adjust)
	{
	GList			*list;
	GkrellmBorder	*b		= &bezel_style->border;
	SensorMon		*smon;
	GkrellmDecal	*dv;
	gint			x;

	if (!bezel_piximage)
		return;
	for (list = smon_list; list; list = list->next)
		{
		smon = (SensorMon *) list->data;
		dv = smon->sensor_decal;
		x = dv->x + x_adjust;
		if (w == 0)
			w = b->left + dv->w + b->right - x_adjust;
		if (h == 0)
			h = b->top + b->bottom + dv->h;
		gkrellm_paste_piximage(bezel_piximage, p->bg_pixmap,
				x - b->left, dv->y - b->top, w, h);
		gkrellm_paste_piximage(bezel_piximage, p->pixmap,
				x - b->left, dv->y - b->top, w, h);
		}
	gdk_draw_drawable(p->bg_text_layer_pixmap, _GK.draw1_GC, p->bg_pixmap,
				0, 0,  0, 0,  p->w, p->h);
	}


static gboolean
any_negative_volts(void)
	{
	GList		*list;
	Sensor		*s;
	SensorMon	*volt;
	gfloat		v;
	gboolean	tmp, result = FALSE;

	/* This routine can be called before any volt decals exist, but reading
	|  voltages can trigger alerts which expect to find decals.  Hence freeze.
	*/
	tmp = thread_data_valid;
	thread_data_valid = FALSE;	/* Need results immediately */
	for (list = volt_list; list; list = list->next)
		{
		volt = (SensorMon *) list->data;
		gkrellm_freeze_alert(volt->sensor->alert);
		s = volt->sensor->vref;
		if (s && s->value == 0)
			sensor_read_voltage(s, &v);
		sensor_read_voltage(volt->sensor, &v);
		gkrellm_thaw_alert(volt->sensor->alert);
		if (v < 0.0)
			{
			result = TRUE;
			break;
			}
		}
	thread_data_valid = tmp;
	return result;
	}

static void
make_volt_decals(GkrellmPanel *p, GkrellmStyle *style)
	{
	GList				*list;
	GkrellmBorder		*b	= &bezel_style->border;
	Sensor				*sensor;
	SensorMon			*volt;
	GkrellmDecal		*dv, *dn;
	GkrellmTextstyle	*ts_volt, *ts_name;
	gchar				*fmt;
	gint				w_volt;

	ts_name = gkrellm_meter_alt_textstyle(style_id);
	ts_volt = gkrellm_meter_textstyle(style_id);

	volt_mon_width = 0;
	volt_mon_height = 0;
	volt_name_width = 0;
	w_volt = 0;

	minus_width = 0;
	have_negative_volts = FALSE;
	fmt = "8.88";
	if (any_negative_volts())
		{
		have_negative_volts = TRUE;
		minus_width = 1;
		fmt = "-8.88";
		}

	for (list = volt_list; list; list = list->next)
		{
		volt = (SensorMon *) list->data;
		sensor = volt->sensor;
		if (display_mode == DIGITAL_WITH_LABELS)
			{
			volt->name_decal = dn = gkrellm_create_decal_text(p,
						volt->sensor->name_locale, ts_name, style, 0, 0, 0);
			if (dn->w > volt_name_width)
				volt_name_width = dn->w;
			}
		dv = gkrellm_create_decal_text(p, fmt, ts_volt, style, 0, 0, 0);
		volt->sensor_decal = dv;
		if (minus_width == 1)
			minus_width = gkrellm_gdk_string_width(dv->text_style.font, "-");
		w_volt = dv->w;			/* Same for all volt decals */
		if (dv->h > volt_mon_height)
			volt_mon_height = dv->h;

		sensor->cb_alert = cb_alert_trigger;
		sensor->cb_alert_data = volt;
		gkrellm_alert_trigger_connect(sensor->alert, cb_alert_trigger, volt);
		gkrellm_alert_command_process_connect(sensor->alert,
					cb_command_process, sensor);
		gkrellm_reset_alert_soft(sensor->alert);
		}
	pixel_grub = minus_width ? 1 : 0;
	volt_bezel_width = b->left + w_volt + b->right - pixel_grub;
	volt_mon_height += b->top + b->bottom;

	/* If name decal I let bezel left border encroach into NAME_PAD space