static void print_chip_energy(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
double val;
const sensors_subfeature *sf;
char *label;
const char *unit;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_ENERGY_INPUT);
if (sf && get_input_value(name, sf, &val) == 0) {
scale_value(&val, &unit);
printf("%6.2f %sJ", val, unit);
} else
printf(" N/A");
printf("\n");
}
static void print_chip_curr(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
const sensors_subfeature *sf;
double val;
char *label;
struct sensor_subfeature_data sensors[NUM_CURR_SENSORS];
struct sensor_subfeature_data alarms[NUM_CURR_ALARMS];
int sensor_count, alarm_count;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_CURR_INPUT);
if (sf && get_input_value(name, sf, &val) == 0)
printf("%+6.2f A ", val);
else
printf(" N/A ");
sensor_count = alarm_count = 0;
get_sensor_limit_data(name, feature, current_sensors,
sensors, &sensor_count, alarms, &alarm_count);
print_limits(sensors, sensor_count, alarms, alarm_count, label_size,
"%s = %+6.2f A");
printf("\n");
}
static void print_chip_power(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
double val;
const sensors_subfeature *sf;
struct sensor_subfeature_data sensors[6];
struct sensor_subfeature_data alarms[3];
int sensor_count, alarm_count;
char *label;
const char *unit;
int i;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sensor_count = alarm_count = 0;
/* Power sensors come in 2 flavors: instantaneous and averaged.
To keep things simple, we assume that each sensor only implements
one flavor. */
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_POWER_INPUT);
get_sensor_limit_data(name, feature,
sf ? power_inst_sensors : power_avg_sensors,
sensors, ARRAY_SIZE(sensors), &sensor_count,
alarms, ARRAY_SIZE(alarms), &alarm_count);
/* Add sensors common to both flavors. */
get_sensor_limit_data(name, feature,
power_common_sensors,
sensors, ARRAY_SIZE(sensors), &sensor_count,
alarms, ARRAY_SIZE(alarms), &alarm_count);
if (!sf)
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_POWER_AVERAGE);
if (sf && get_input_value(name, sf, &val) == 0) {
scale_value(&val, &unit);
printf("%6.2f %sW ", val, unit);
} else
printf(" N/A ");
for (i = 0; i < sensor_count; i++)
scale_value(&sensors[i].value, &sensors[i].unit);
print_limits(sensors, sensor_count, alarms, alarm_count,
label_size, "%s = %6.2f %sW");
printf("\n");
}
static void print_chip_fan(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
const sensors_subfeature *sf, *sfmin, *sfdiv;
double val;
char *label;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_FAULT);
if (sf && get_value(name, sf))
printf(" FAULT");
else {
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_INPUT);
if (sf && get_input_value(name, sf, &val) == 0)
printf("%4.0f RPM", val);
else
printf(" N/A");
}
sfmin = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_MIN);
sfdiv = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_DIV);
if (sfmin && sfdiv)
printf(" (min = %4.0f RPM, div = %1.0f)",
get_value(name, sfmin),
get_value(name, sfdiv));
else if (sfmin)
printf(" (min = %4.0f RPM)",
get_value(name, sfmin));
else if (sfdiv)
printf(" (div = %1.0f)",
get_value(name, sfdiv));
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_ALARM);
if (sf && get_value(name, sf)) {
printf(" ALARM");
}
printf("\n");
}
virtual double getValue() {
const sensors_subfeature * sf;
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_FAULT);
if( sf && get_value(name, sf) ) {
return INFINITY;
} else {
double val = 0.0;
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_INPUT);
if(sf && get_input_value(name, sf, &val) == 0 ) {
return val;
}
}
return INFINITY;
}
static void print_chip_power(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
double val;
const sensors_subfeature *sf;
struct sensor_subfeature_data sensors[NUM_POWER_SENSORS];
struct sensor_subfeature_data alarms[NUM_POWER_ALARMS];
int sensor_count, alarm_count;
char *label;
const char *unit;
int i;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sensor_count = alarm_count = 0;
/*
* Power sensors come in 2 flavors: instantaneous and averaged.
* Most devices only support one flavor, so we try to display the
* average power if the instantaneous power attribute does not exist.
* If both instantaneous power and average power are supported,
* average power is displayed as limit.
*/
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_POWER_INPUT);
get_sensor_limit_data(name, feature,
sf ? power_inst_sensors : power_avg_sensors,
sensors, &sensor_count, alarms, &alarm_count);
/* Add sensors common to both flavors. */
get_sensor_limit_data(name, feature, power_common_sensors,
sensors, &sensor_count, alarms, &alarm_count);
if (!sf)
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_POWER_AVERAGE);
if (sf && get_input_value(name, sf, &val) == 0) {
scale_value(&val, &unit);
printf("%6.2f %sW%*s", val, unit, 2 - (int)strlen(unit), "");
} else
printf(" N/A ");
for (i = 0; i < sensor_count; i++) {
/*
* Unit is W and needs to be scaled for all attributes except
* interval, which does not need to be scaled and is reported in
* seconds.
*/
if (strcmp(sensors[i].name, "interval")) {
char *tmpstr;
tmpstr = alloca(4);
scale_value(&sensors[i].value, &unit);
snprintf(tmpstr, 4, "%sW", unit);
sensors[i].unit = tmpstr;
} else {
sensors[i].unit = "s";
}
}
print_limits(sensors, sensor_count, alarms, alarm_count,
label_size, "%s = %6.2f %s");
printf("\n");
}
static void print_chip_temp(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
struct sensor_subfeature_data sensors[NUM_TEMP_SENSORS];
struct sensor_subfeature_data alarms[NUM_TEMP_ALARMS];
int sensor_count, alarm_count;
const sensors_subfeature *sf;
double val;
char *label;
int i;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_FAULT);
if (sf && get_value(name, sf)) {
printf(" FAULT ");
} else {
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_INPUT);
if (sf && get_input_value(name, sf, &val) == 0) {
get_input_value(name, sf, &val);
if (fahrenheit)
val = deg_ctof(val);
printf("%+6.1f%s ", val, degstr);
} else
printf(" N/A ");
}
sensor_count = alarm_count = 0;
get_sensor_limit_data(name, feature, temp_sensors,
sensors, &sensor_count, alarms, &alarm_count);
for (i = 0; i < sensor_count; i++) {
if (fahrenheit)
sensors[i].value = deg_ctof(sensors[i].value);
sensors[i].unit = degstr;
}
print_limits(sensors, sensor_count, alarms, alarm_count, label_size,
"%-4s = %+5.1f%s");
/* print out temperature sensor info */
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_TYPE);
if (sf) {
int sens = (int)get_value(name, sf);
/* older kernels / drivers sometimes report a beta value for
thermistors */
if (sens > 1000)
sens = 4;
printf(" sensor = %s", sens == 0 ? "disabled" :
sens == 1 ? "CPU diode" :
sens == 2 ? "transistor" :
sens == 3 ? "thermal diode" :
sens == 4 ? "thermistor" :
sens == 5 ? "AMD AMDSI" :
sens == 6 ? "Intel PECI" : "unknown");
}
printf("\n");
}
/***********************************************************************
* Read the input file.
***********************************************************************/
int read_input ( FILE *fp_in, FILE *fp_out, input_data *input_vars,
para_data *para_vars, time_data *time_vars )
{
/***********************************************************************
* Local variables.
***********************************************************************/
double t1, t2;
int ierr = 0;
char *error = NULL;
char *line = NULL;
size_t len = 0;
ssize_t read;
char *tmpData = NULL;
int tmpStrLen, i;
/***********************************************************************
* Read the input file. Echo to output file. Call for an input variable
* check. Only root reads, echoes, checks input.
***********************************************************************/
t1 = wtime ();
if ( IPROC == ROOT )
{
if ( !fp_in )
{
tmpStrLen = strlen (" ***ERROR: READ_INPUT:"
" Problem reading input file.\n");
ALLOC_STR ( error, tmpStrLen + 1, &ierr );
snprintf ( error, tmpStrLen + 1,
" ***ERROR: READ_INPUT:"
" Problem reading input file.\n" );
print_error ( fp_out, error, IPROC, ROOT );
FREE ( error );
ierr = 1;
}
else
{
while ( (read = getline(&line, &len, fp_in)) != -1 )
{
i = 0;
while ( isspace(line[i]) )
{
i++;
}
// Parallel processing inputs
// npey: number of process elements in y-dir
if ( strncmp(&line[i], "npey=", strlen("npey=")) == 0 )
{
get_input_value ( &line[i], "npey=", &tmpData );
NPEY = atoi ( tmpData );
}
// npez: input number of process elements in z-dir
else if ( strncmp(&line[i], "npez=", strlen("npez=")) == 0 )
{
get_input_value ( &line[i], "npez=", &tmpData );
NPEZ = atoi ( tmpData );
}
// ichunk:
else if ( strncmp(&line[i], "ichunk=", strlen("ichunk=")) == 0 )
{
get_input_value ( &line[i], "ichunk=", &tmpData );
ICHUNK = atoi ( tmpData );
}
// nthreads: input number of threads
else if ( strncmp(&line[i], "nthreads=", strlen("nthreads=")) == 0 )
{
get_input_value ( &line[i], "nthreads=", &tmpData );
NTHREADS = atoi ( tmpData );
}
// nnested:
else if ( strncmp(&line[i], "nnested=", strlen("nnested=")) == 0 )
{
get_input_value ( &line[i], "nnested=", &tmpData );
NNESTED = atoi ( tmpData );
}
// Geometry inputs
// ndimen:
else if ( strncmp(&line[i], "ndimen=", strlen("ndimen=")) == 0 )
{
get_input_value ( &line[i], "ndimen=", &tmpData );
NDIMEN = atoi ( tmpData );
}
// nx:
else if ( strncmp(&line[i], "nx=", strlen("nx=")) == 0 )
{
get_input_value ( &line[i], "nx=", &tmpData );
NX = atoi ( tmpData );
}
// ny:
else if ( strncmp(&line[i], "ny=", strlen("ny=")) == 0 )
{
get_input_value ( &line[i], "ny=", &tmpData );
NY = atoi ( tmpData );
}
// nz:
else if ( strncmp(&line[i], "nz=", strlen("nz=")) == 0 )
{
get_input_value ( &line[i], "nz=", &tmpData );
NZ = atoi ( tmpData );
}
// lx:
else if ( strncmp(&line[i], "lx=", strlen("lx=")) == 0 )
{
get_input_value ( &line[i], "lx=", &tmpData );
LX = atof ( tmpData );
}
// ly:
else if ( strncmp(&line[i], "ly=", strlen("ly=")) == 0 )
{
get_input_value ( &line[i], "ly=", &tmpData );
LY = atof ( tmpData );
}
// lz:
else if ( strncmp(&line[i], "lz=", strlen("lz=")) == 0 )
{
get_input_value ( &line[i], "lz=", &tmpData );
LZ = atof ( tmpData );
}
// Sn inputs
// nmom:
else if ( strncmp(&line[i], "nmom=", strlen("nmom=")) == 0 )
{
get_input_value ( &line[i], "nmom=", &tmpData );
NMOM = atoi ( tmpData );
}
// nang:
else if ( strncmp(&line[i], "nang=", strlen("nang=")) == 0 )
{
get_input_value ( &line[i], "nang=", &tmpData );
NANG = atoi ( tmpData );
}
// Data inputs
// ng:
else if ( strncmp(&line[i], "ng=", strlen("ng=")) == 0 )
{
get_input_value ( &line[i], "ng=", &tmpData );
NG = atoi ( tmpData );
}
// mat_opt:
else if ( strncmp(&line[i], "mat_opt=", strlen("mat_opt=")) == 0 )
{
get_input_value ( &line[i], "mat_opt=", &tmpData );
MAT_OPT = atoi ( tmpData );
}
// src_opt:
else if ( strncmp(&line[i], "src_opt=", strlen("src_opt=")) == 0 )
{
get_input_value ( &line[i], "src_opt=", &tmpData );
SRC_OPT = atoi ( tmpData );
}
// scatp:
else if ( strncmp(&line[i], "scatp=", strlen("scatp=")) == 0 )
{
get_input_value ( &line[i], "scatp=", &tmpData );
SCATP = atoi ( tmpData );
}
// Control inputs
// epsi:
else if ( strncmp(&line[i], "epsi=", strlen("epsi=")) == 0 )
{
get_input_value ( &line[i], "epsi=", &tmpData );
EPSI = atof ( tmpData );
}
// tf:
else if ( strncmp(&line[i], "tf=", strlen("tf=")) == 0 )
{
get_input_value ( &line[i], "tf=", &tmpData );
TF = atof ( tmpData );
}
// iitm:
else if ( strncmp(&line[i], "iitm=", strlen("iitm=")) == 0 )
{
get_input_value ( &line[i], "iitm=", &tmpData );
IITM = atoi ( tmpData );
}
// oitm:
else if ( strncmp(&line[i], "oitm=", strlen("oitm=")) == 0 )
{
get_input_value ( &line[i], "oitm=", &tmpData );
OITM = atoi ( tmpData );
}
// timedep:
else if ( strncmp(&line[i], "timedep=", strlen("timedep=")) == 0 )
{
get_input_value ( &line[i], "timedep=", &tmpData );
TIMEDEP = atoi ( tmpData );
}
// nsteps:
else if ( strncmp(&line[i], "nsteps=", strlen("nsteps=")) == 0 )
{
get_input_value ( &line[i], "nsteps=", &tmpData );
NSTEPS = atoi ( tmpData );
}
// it_det:
else if ( strncmp(&line[i], "it_det=", strlen("it_det=")) == 0 )
{
get_input_value ( &line[i], "it_det=", &tmpData );
IT_DET = atoi ( tmpData );
}
// fluxp:
else if ( strncmp(&line[i], "fluxp=", strlen("fluxp=")) == 0 )
{
get_input_value ( &line[i], "fluxp=", &tmpData );
FLUXP = atoi ( tmpData );
}
// fixup:
else if ( strncmp(&line[i], "fixup=", strlen("fixup=")) == 0 )
{
get_input_value ( &line[i], "fixup=", &tmpData );
FIXUP = atoi ( tmpData );
}
}
// Free temp data from memory
FREE ( tmpData );
}
}
bcast_i_scalar ( &ierr, COMM_SNAP, ROOT, NPROC );
if ( ierr != 0 )
{
return ierr;
}
if ( IPROC == ROOT )
{
input_echo ( input_vars, fp_out );
ierr = input_check ( fp_out, input_vars, para_vars );
}
/***********************************************************************
* Broadcast the data to all processes.
***********************************************************************/
ierr = var_bcast ( input_vars, para_vars );
t2 = wtime();
time_vars->tinp = t2 - t1;
return ierr;
}
/**
* \brief DAC Sinewave application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
uint8_t uc_key;
uint32_t ul_freq, ul_amp;
/* Initialize the system */
sysclk_init();
board_init();
/* Initialize debug console */
configure_console();
/* Output example information */
puts(STRING_HEADER);
/* Enable clock for DACC */
#if SAM4L
sysclk_enable_peripheral_clock(DACC_BASE);
#else
sysclk_enable_peripheral_clock(DACC_ID);
#endif
/* Reset DACC registers */
dacc_reset(DACC_BASE);
/* Half word transfer mode */
dacc_set_transfer_mode(DACC_BASE, 0);
/* Initialize timing, amplitude and frequency */
#if (SAM3N) || (SAM4L)
/* Timing:
* startup - 0x10 (17 clocks)
* internal trigger clock - 0x60 (96 clocks)
*/
dacc_set_timing(DACC_BASE, 0x10, 0x60);
/* Enable DAC */
dacc_enable(DACC_BASE);
#else
/* Power save:
* sleep mode - 0 (disabled)
* fast wakeup - 0 (disabled)
*/
dacc_set_power_save(DACC_BASE, 0, 0);
/* Timing:
* refresh - 0x08 (1024*8 dacc clocks)
* max speed mode - 0 (disabled)
* startup time - 0x10 (1024 dacc clocks)
*/
dacc_set_timing(DACC_BASE, 0x08, 0, 0x10);
/* Disable TAG and select output channel DACC_CHANNEL */
dacc_set_channel_selection(DACC_BASE, DACC_CHANNEL);
/* Enable output channel DACC_CHANNEL */
dacc_enable_channel(DACC_BASE, DACC_CHANNEL);
/* Set up analog current */
dacc_set_analog_control(DACC_BASE, DACC_ANALOG_CONTROL);
#endif /* (SAM3N) */
g_l_amplitude = MAX_AMPLITUDE / 2;
g_ul_frequency = DEFAULT_FREQUENCY;
SysTick_Config(sysclk_get_cpu_hz() / (g_ul_frequency * SAMPLES));
/* Main menu */
display_menu();
while (1) {
usart_serial_getchar((Usart *)CONSOLE_UART, &uc_key);
switch (uc_key) {
case '0':
puts("Frequency:");
ul_freq = get_input_value(MIN_FREQUENCY, MAX_FREQUENCY);
puts("\r");
if (ul_freq != VAL_INVALID) {
printf("Set frequency to : %luHz\n\r", (unsigned long)ul_freq);
SysTick_Config(sysclk_get_cpu_hz() / (ul_freq * SAMPLES));
g_ul_frequency = ul_freq;
}
break;
case '1':
puts("Amplitude:");
ul_amp = get_input_value(MIN_AMPLITUDE, MAX_AMPLITUDE);
puts("\r");
if (ul_amp != VAL_INVALID) {
printf("Set amplitude to : %lu\n\r", (unsigned long)ul_amp);
g_l_amplitude = ul_amp;
}
break;
case 'i':
case 'I':
printf("-I- Frequency : %lu Hz Amplitude : %ld\n\r",
(unsigned long)g_ul_frequency, (long)g_l_amplitude);
break;
case 'w':
case 'W':
printf("-I- Switch wave to : %s\n\r", g_uc_wave_sel ?
"SINE" : "Full Amplitude SQUARE");
g_uc_wave_sel = (g_uc_wave_sel + 1) & 1;
break;
case 'm':
case 'M':
display_menu();
break;
}
puts("Press \'m\' or \'M\' to display the main menu again!\r");
}
}
