int main()
{
unsigned short old_temp, new_temp, fan_speed, steps;
short temp_change;
float step_up, step_down;
/* prepare_fan(); */
/* assume running on boot so set fan speed to minimum */
new_temp = get_temp();
fan_speed = 2000;
set_fan_speed(fan_speed);
sleep(polling_interval);
step_up = (float)(max_fan_speed - min_fan_speed) /
(float)((max_temp - high_temp) * (max_temp - high_temp + 1) / 2);
step_down = (float)(max_fan_speed - min_fan_speed) /
(float)((max_temp - low_temp) * (max_temp - low_temp + 1) / 2);
while(1)
{
old_temp = new_temp;
new_temp = get_temp();
if(new_temp >= max_temp && fan_speed != max_fan_speed) {
fan_speed = max_fan_speed;
}
if(new_temp <= low_temp && fan_speed != min_fan_speed) {
fan_speed = min_fan_speed;
}
temp_change = new_temp - old_temp;
if(temp_change > 0 && new_temp > high_temp && new_temp < max_temp) {
steps = (new_temp - high_temp) * (new_temp - high_temp + 1) / 2;
fan_speed = max(fan_speed, ceil(min_fan_speed + steps * step_up));
}
if(temp_change < 0 && new_temp > low_temp && new_temp < max_temp) {
steps = (max_temp - new_temp) * (max_temp - new_temp + 1) / 2;
fan_speed = min(fan_speed, floor(max_fan_speed - steps * step_down));
}
set_fan_speed(fan_speed);
sleep(polling_interval);
}
return 0;
}
void main(void)
{
init_pins();
init_oscillator();
SPI1_Initialize();
float temp = 0;
// Set all pins RD1-7 to inputs, RD0 (MSB is set to output)
//TRISD = 0b11111110;
// RC2 is PWM pin
TRISCbits.RC2 = 0;
configure_adc();
configure_pwm();
int ticks = 0;
while (1)
{
MAX_7221_INIT();
temp = get_temperature(0);
set_fan_speed(temp);
if(ticks % 125 == 0) {
MAX_7221_WRITE_FLOAT(temp, 3);
ticks = 0;
}
ticks++;
}
}
int main(void)
{
int result, done, op;
result = SusiDllInit();
if (result == FALSE) {
printf("SusiDllInit() failed\n");
return 1;
}
result = SusiHWMAvailable();
if (result == FALSE) {
printf("SusiHWMAvailable() failed\n");
SusiDllUnInit();
return 1;
}
result = show_platform_info();
done = 0;
while (! done) {
show_menu();
if (scanf("%i", &op) <= 0)
op = -1;
switch (op) {
case 0:
done = 1;
continue;
case 1:
result = get_voltage();
break;
case 2:
result = get_temperature();
break;
case 3:
result = get_fan_speed();
break;
case 4:
result = set_fan_speed();
break;
default:
printf("\nUnknown choice!\n\n");
continue;
}
if (result != 0) {
printf("Library returns with error.\n");
SusiDllUnInit();
return 1;
}
}
result = SusiDllUnInit();
if (result == FALSE) {
printf("SusiDllUnInit() failed\n");
return 1;
}
return 0;
}
/* Main function */
int main()
{
Machine mach;
double A, k;
init(&mach);
k = (log(mach.fan.max_speed) - log(mach.fan.min_speed)) / (mach.high_temp - mach.low_temp);
A = mach.fan.max_speed * exp(-(mach.high_temp * k));
while(1)
{
mach.temp = get_temp(mach.cores);
mach.fan.speed = calc_fan_speed(mach, A, k);
if(mach.fan.old_speed != mach.fan.speed)
{
set_fan_speed(mach.fan.speed);
log_fan_speed(mach.fan.speed, mach.temp);
mach.fan.old_speed = mach.fan.speed;
mach.old_temp = mach.temp;
}
sleep(mach.polling_interval);
}
return SUCCESS;
}
static int
do_fan( SaHpiSessionIdT session_id, SaHpiResourceIdT resource_id,
SaHpiRdrT *rdr )
{
SaErrorT rv;
SaHpiCtrlRecT *ctrl_rec = &rdr->RdrTypeUnion.CtrlRec;
printf( "\tfan: num %d, id ", ctrl_rec->Num );
display_textbuffer( rdr->IdString );
printf( "\n" );
if ( ctrl_rec->Type != SAHPI_CTRL_TYPE_ANALOG ) {
fprintf( stderr, "cannot handle non analog fan controls !\n" );
return 0;
}
printf( "\t\tmin %d\n", ctrl_rec->TypeUnion.Analog.Min );
printf( "\t\tmax %d\n", ctrl_rec->TypeUnion.Analog.Max );
printf( "\t\tdefault %d\n", ctrl_rec->TypeUnion.Analog.Default );
SaHpiCtrlStateAnalogT speed;
rv = get_fan_speed( session_id, resource_id, ctrl_rec->Num, &speed );
if ( rv != SA_OK )
return 0;
printf( "\t\tcurrent %d\n", speed );
if ( fan_speed == -1 )
return 0;
if ( fan_speed < ctrl_rec->TypeUnion.Analog.Min
|| fan_speed > ctrl_rec->TypeUnion.Analog.Max ) {
fprintf( stderr, "fan speed %d out of range [%d,%d] !\n",
fan_speed, ctrl_rec->TypeUnion.Analog.Min,
ctrl_rec->TypeUnion.Analog.Max );
return 0;
}
speed = fan_speed;
rv = set_fan_speed( session_id, resource_id, ctrl_rec->Num, speed );
if ( rv != SA_OK )
return 0;
rv = get_fan_speed( session_id, resource_id, ctrl_rec->Num, &speed );
if ( rv != SA_OK )
return 0;
printf( "\t\tnew speed %d\n", speed );
return 0;
}
static int on_fan_speed_change(CanopyContext ctx, const char *varName, void *userData)
{
int8_t fanSpeed;
CanopyResultEnum result;
result = canopy_var_get_int8(ctx, "fan_speed", &fanSpeed);
if (!ctx) {
fprintf(stderr, "Error reading fan_speed\n");
return -1;
}
set_fan_speed(fanSpeed);
return 0;
}
/*
* Open fan devices and initialize per fan data structure.
* Returns #fans found.
*/
static int
envd_setup_fans(void)
{
int i, fd;
fanspeed_t speed;
env_fan_t *fanp;
char path[FILENAME_MAX];
int fancnt = 0;
for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
fanp->fd = -1;
fanp->cur_speed = 0;
fanp->prev_speed = 0;
(void) strcpy(path, "/devices");
(void) strlcat(path, fanp->devfs_path, sizeof (path));
fd = open(path, O_RDWR);
if (fd == -1) {
envd_log(LOG_WARNING, ENV_FAN_OPEN_FAIL, fanp->name,
fanp->devfs_path, errno, strerror(errno));
fanp->present = B_FALSE;
continue;
}
fanp->fd = fd;
fanp->present = B_TRUE;
fancnt++;
/*
* Set cur_speed/prev_speed to current fan speed
*/
if (get_fan_speed(fanp, &speed) == -1) {
/*
* The Fan driver does not know the current fan speed.
* Initialize it to 50% of the max speed and reread
* to get the current speed.
*/
speed = fanp->speed_max/2;
(void) set_fan_speed(fanp, speed);
if (get_fan_speed(fanp, &speed) == -1)
continue;
}
fanp->cur_speed = speed;
fanp->prev_speed = speed;
}
return (fancnt);
}
int main(void)
{
CanopyContext ctx;
CanopyResultEnum result;
uint64_t reportTimer = 0;
result = canopy_set_global_opt(
CANOPY_LOG_LEVEL, 0,
CANOPY_LOG_PAYLOADS, true);
ctx = canopy_init_context();
if (!ctx) {
fprintf(stderr, "Error initializing context\n");
return -1;
}
result = canopy_set_opt(ctx,
CANOPY_DEVICE_UUID, "e6968460-f010-48ef-8e69-835543843b32",
CANOPY_DEVICE_SECRET_KEY, "/pMdwTzEA3+d66qo3MZQ2bWjsYGXAHAb",
CANOPY_CLOUD_SERVER, "sandbox.canopy.link"
);
if (result != CANOPY_SUCCESS){
fprintf(stderr, "Failed to configure context\n");
return -1;
}
result = canopy_var_init(ctx, "out float32 temperature");
if (result != CANOPY_SUCCESS){
fprintf(stderr, "Failed to init cloudvar 'temperature'\n");
return -1;
}
result = canopy_var_init(ctx, "out float32 humidity");
if (result != CANOPY_SUCCESS){
fprintf(stderr, "Failed to init cloudvar 'humidity'\n");
return -1;
}
result = canopy_var_init(ctx, "inout int8 fan_speed");
if (result != CANOPY_SUCCESS){
fprintf(stderr, "Failed to init cloudvar 'fan_speed'\n");
return -1;
}
/*result = canopy_var_on_change(ctx, "fan_speed", on_fan_speed_change, NULL);
if (result != CANOPY_SUCCESS) {
fprintf(stderr, "Error setting up fan_speed callback\n");
return -1;
}*/
// turn fan off
init_fan_pins();
result = canopy_var_set_int8(ctx, "fan_speed", 0);
if (!ctx) {
fprintf(stderr, "Error setting fan_speed\n");
return -1;
}
while (1) {
int8_t speed;
canopy_sync_blocking(ctx, 10*CANOPY_SECONDS);
result = canopy_var_get_int8(ctx, "fan_speed", &speed);
if (result != CANOPY_SUCCESS) {
fprintf(stderr, "Error reading fan_speed\n");
return -1;
}
set_fan_speed(speed);
if (canopy_once_every(&reportTimer, 60*CANOPY_SECONDS)) {
printf("reading sensors...\n");
float temperature, humidity;
bool sensorOk;
sensorOk = read_sensors(&temperature, &humidity);
if (sensorOk) {
printf("Temperature: %f Humidity: %f\n", temperature, humidity);
result = canopy_var_set_float32(ctx, "temperature", temperature);
if (result != CANOPY_SUCCESS) {
fprintf(stderr, "Failed to set cloudvar 'temperature'\n");
return -1;
}
result = canopy_var_set_float32(ctx, "humidity", humidity);
if (result != CANOPY_SUCCESS) {
fprintf(stderr, "Failed to set cloudvar 'humidity'\n");
return -1;
}
}
}
}
}
/**
* Main TWI handler
*/
void twi_handler(void) {
struct ucinfo_t *info = &ucinfo;
if (ts_rx_valid == true) {
/* I must be a slave, I've received something */
switch (slave_rx_addr) {
case TWICMD_POWERUP:
/*
* Turn on a the power supply. If I'm getting this command, I'm a
* slave and I must have standby power on, so there must be a power
* supply on me. Separating this and TWICMD_STARTUP gets power to
* ALL slaves, even those without power supplies, for when the
* TWICMD_STARTUP happens.
*/
info->addressing_complete = false;
gpio_set_pin_high(SPARE_DOWN);
gpio_set_pin_high(HAVE_USB);
power_supply_on();
break;
case TWICMD_STARTUP:
/* restart addressing cycle */
info->addressing_complete = false;
gpio_set_pin_high(SPARE_DOWN);
gpio_set_pin_high(HAVE_USB);
usb_powerup_request();
break;
case TWICMD_POWERDOWN:
usb_powerdown_request();
break;
case TWICMD_ADDRESS:
if (tmp1 < sizeof(addresses) / sizeof(addresses[0])) {
addresses[tmp1] = slave_rx_data.b[0];
su_pin[tmp1] = gpio_pin_is_high(SPARE_UP);
sd_pin[tmp1] = gpio_pin_is_high(SPARE_DOWN);
tmp1++;
}
if (gpio_pin_is_low(SPARE_UP) && gpio_pin_is_high(SPARE_DOWN)) {
/* This is MY address! Grab it. */
my_twi_address = slave_rx_data.b[0];
my_twi_address_set = true;
delay_msec(1);
twi_slave_setup(my_twi_address);
delay_msec(1);
if (info->chain_configuration == CC_OPEN_UP) {
/*
* Send notification back up chain to master.
* Last address done
*/
gpio_set_pin_low(HAVE_USB);
} else {
/* Propagate down so next module gets next address. */
gpio_set_pin_low(SPARE_DOWN);
}
}
break;
case TWICMD_ADDRESSING_COMPLETE:
info->addressing_complete = true;
gpio_set_pin_high(SPARE_DOWN);
gpio_set_pin_high(HAVE_USB);
break;
case TWICMD_FPGA_ASIC_CTL:
fpga_reg_write(FA_ASIC_CONTROL,
(slave_rx_data.b[0] & F_FORCE_BAUD) ? (slave_rx_data.b[0] & ~F_FORCE_BAUD) : ((slave_rx_data.b[0] & ~F_ASIC_BAUD_MASK) | ucinfo.asic_baud_rate_code));
break;
case TWICMD_REBOOT:
if (slave_rx_nb && slave_rx_data.b[0]) {
/*
* Tell Atmel DFU loader not to start app ever again (harmless
* with custom loader).
*/
flashc_erase_gp_fuse_bit(31, true);
flashc_write_gp_fuse_bit(31, true);
/*
* Tell custom bootloader not to start app on this boot
* (harmless with Atmel DFU loader).
*/
AVR32_PM.gplp[1] = 0x73746179;
}
/* never returns */
self_reset();
break;
case TWICMD_FAN_SET:
set_fan_speed(slave_rx_data.b[0], slave_rx_data.b[1]);
break;
case TWICMD_DIE_SETTINGS:
if (slave_rx_nb) {
hf_nvram_write_die_settings(0, &slave_rx_data.opSettings);
}
break;
case TWICMD_BAD_CORE_BITMAP:
if (slave_rx_nb) {
hf_nvram_write_bad_core_bitmap(0, (((uint16_t) slave_rx_data.b[0]) << 8) | slave_rx_data.b[1]);
}
break;
case TWICMD_MIXED_BAUD:
set_mixed_slave_baudrate();
break;
case TWICMD_VOLTAGE_SET:
if (slave_rx_nb >= 3) {
module_voltage_set(0, slave_rx_data.b[0], ((uint16_t) slave_rx_data.b[1] << 8) | slave_rx_data.b[2]);
}
break;
default:
break;
}
ts_rx_valid = false;
}
if (info->master == false) {
if (info->addressing_complete == false) {
/* propagate HAVE_USB back up chain to master during address cycle */
if (info->chain_configuration == CC_MIDDLE) {
if (gpio_pin_is_high(USB_DOWN)) {
gpio_set_pin_high(HAVE_USB);
} else {
gpio_set_pin_low(HAVE_USB);
}
}
}
}
masterHandler();
}
/*
* This is the environment thread, which monitors the current temperature
* and power managed state and controls system fan speed. Temperature is
* polled every sensor-poll_interval seconds duration.
*/
static void *
envthr(void *args)
{
int err;
fanspeed_t fan_speed;
struct timeval ct;
struct timespec to;
env_fan_t *pmfanp = &envd_system_fan;
tempr_t cpu_amb_temp, cpu_die_temp;
tempr_t cpu_amb_warning, cpu_die_warning;
(void) pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
(void) pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
cpu_amb_warning = cpu_amb_sensor.temp_thresh->high_warning;
cpu_die_warning = cpu_die_sensor.temp_thresh->high_warning;
for (;;) {
(void) gettimeofday(&ct, NULL);
/*
* Monitor current temperature for all sensors
* (current temperature is recorded in the "cur_temp"
* field within each sensor data structure)
*/
monitor_sensors();
cpu_amb_temp = cpu_amb_sensor.cur_temp;
cpu_die_temp = cpu_die_sensor.cur_temp;
/*
* Process any PM state change events while waiting until
* time to poll sensors again (i.e. sensor_poll_interval
* seconds from the last time).
*/
to.tv_sec = ct.tv_sec + sensor_poll_interval;
to.tv_nsec = 0;
for (;;) {
/*
* Turn off system fan if in lowest power state
* and both CPU die and ambient temperatures are
* below corresponding high warning temperatures.
*/
fan_speed = pmfanp->speed_max;
if (cur_lpstate && cpu_amb_temp < cpu_amb_warning &&
cpu_die_temp < cpu_die_warning)
fan_speed = pmfanp->speed_min;
if (env_debug)
envd_log(LOG_INFO,
"fan: %-16s speed cur:%3d new:%3d "
"low-power:%d\n", pmfanp->name,
(uint_t)pmfanp->cur_speed,
(uint_t)fan_speed, cur_lpstate);
if (fan_speed != pmfanp->cur_speed &&
set_fan_speed(pmfanp, fan_speed) == 0)
pmfanp->cur_speed = fan_speed;
/* wait for power state change or time to poll */
pthread_mutex_lock(&lpstate_lock);
err = pthread_cond_timedwait(&lpstate_cond,
&lpstate_lock, &to);
pthread_mutex_unlock(&lpstate_lock);
if (err == ETIMEDOUT)
break;
}
}
/*NOTREACHED*/
return (NULL);
}
