Ejemplo n.º 1
0
static void flip_layer( float *data, int rows, int cols, float missing_value )
{
   int i, j;
   float temp[MAXROWS*MAXCOLUMNS];

#define DATA(R,C)  data[R*cols+C]
#define TEMP(R,C)  temp[C*rows+rows-R-1]

   for (i=0;i<rows;i++) {
      for (j=0;j<cols;j++) {

         /* NOTE: floating-point errors on next line probably indicate
            improperly byteswapped data file! How to catch in program??? */
         if (DATA(i,j)==missing_value) {
            TEMP(i,j) = MISSING;
         }
         else {
            TEMP(i,j) = DATA(i,j);
         }
      }
   }

   memcpy( data, temp, rows*cols*sizeof(float) );

#undef DATA
#undef TEMP
}
Ejemplo n.º 2
0
void radiator_loop_new()
{
  temp_t tab [] = {
    DS18B20_RADIATOR_U,
    DS18B20_RADIATOR_D,
    DS18B20_HOUSE_S_T,
  };
  
  ds18b20_temp_tab_fill(RESOLUTION_11, 7, tab);
  
  CONFIG static temp_t  ambient_temp = TEMP(23);
  CONFIG static uint8_t heating_f    = 4.0 * 0x10;
  CONFIG static temp_t  storage_off  = TEMP(10);

  temp_t goal = CONFIG_GET(ambient_temp);
  goal += (uint32_t)(tab[0] - tab[1]) * CONFIG_GET(heating_f) / 0x10;
  goal = MIN(goal, tab[2] - storage_off);

  valve_state_t amount = VALVE_STATE_MAX * 5 / 100;
  if (goal > tab[1]) valve_open_for (VALVE_RADIATOR, amount);
  else               valve_close_for(VALVE_RADIATOR, amount);
  
  if (valve_closed(VALVE_RADIATOR))
    relay_off(RELAY_PUMP_RADIATOR);
  else
    relay_on (RELAY_PUMP_RADIATOR);
}
Ejemplo n.º 3
0
   cg_buffer2D<float> DiffGausY(cg_buffer2D<float> &X) {
      cg_buffer2D<float> TEMP(X.get_width(), X.get_height(), X.get_stride());

      float *fp1 = X.get_data();
      float *fp2 = X.get_data()+X.get_stride();
      float *fp3 = X.get_data()+(X.get_stride()*2);
      float *fp4 = X.get_data()+(X.get_stride()*3);
      float *fp5 = X.get_data()+(X.get_stride()*4);

      float *fp = TEMP.get_data()+(X.get_stride()*2);

      for(unsigned int i=0;i<X.get_stride();i++) {
         for (unsigned int j=0;j<X.get_height()-4;j++) {
            *fp = DG3[0]*(float)*fp1 + DG3[1]*(float)*fp2 + DG3[2]*(float)*fp3 +
                  DG3[3]*(float)*fp4 + DG3[4]*(float)*fp5;
            fp += X.get_stride();
            fp1 += X.get_stride();
            fp2 += X.get_stride();
            fp3 += X.get_stride();
            fp4 += X.get_stride();
            fp5 += X.get_stride();
         }
         fp1 = X.get_data()+i;
         fp2 = X.get_data()+X.get_stride()+i;
         fp3 = X.get_data()+(X.get_stride()*2)+i;
         fp4 = X.get_data()+(X.get_stride()*3)+i;
         fp5 = X.get_data()+(X.get_stride()*4)+i;
         fp = TEMP.get_data()+(X.get_stride()*2)+i;
      }
      return TEMP;
   }
int main() {
    env::variable<int> TEMP( "abc", env::default_value = 5 );

    std::cout << TEMP << std::endl;

    return 0;
}
Ejemplo n.º 5
0
   cg_buffer2D<float> GaussianY(cg_buffer2D<float> &X) {
      cg_buffer2D<float> TEMP(X.get_width(), X.get_height(), X.get_stride());

      float *fp1 = X.get_data();
      float *fp2 = X.get_data()+X.get_stride();
      float *fp3 = X.get_data()+(X.get_stride()*2);

      float *fp = TEMP.get_data()+(X.get_stride());

      for(unsigned int i=0;i<X.get_stride();i++) {
         for (unsigned int j=0;j<X.get_height()-2;j++) {
            *fp = G3[0]*(float)*fp1 + G3[1]*(float)*fp2 + G3[2]*(float)*fp3;
            fp += X.get_stride();
            fp1 += X.get_stride();
            fp2 += X.get_stride();
            fp3 += X.get_stride();
         }
         fp1 = X.get_data()+i;
         fp2 = X.get_data()+X.get_stride()+i;
         fp3 = X.get_data()+(X.get_stride()*2)+i;
         fp = TEMP.get_data()+(X.get_stride())+i;
      }

      return TEMP;
   }
Ejemplo n.º 6
0
   cg_buffer2D<float> DiffGausX(cg_buffer2D<float> &X) {

      cg_buffer2D<float> TEMP(X.get_width(), X.get_height(), X.get_stride());

      float *Tp1 = X.get_data();
      float *Tp2 = X.get_data()+1;
      float *Tp3 = X.get_data()+2;
      float *Tp4 = X.get_data()+3;
      float *Tp5 = X.get_data()+4;

      float *fp = TEMP.get_data()+2;

      for(int i=0;i<X.get_height();i++) {
         for (int j=0;j<X.get_stride()-4;j++) {
            *fp = (DG3[0]*(float)*Tp1++) + (DG3[1]*(float)*Tp2++) +
                  (DG3[2]*(float)*Tp3++) + (DG3[3]*(float)*Tp4++) +
                  (DG3[4]*(float)*Tp5++);
            fp++;
         }
         fp += 4;
         Tp1 += 4;
         Tp2 += 4;
         Tp3 += 4;
         Tp4 += 4;
         Tp5 += 4;
      }

      return TEMP;
   }
Ejemplo n.º 7
0
int main() {
    env::variable<int> TEMP( "abc", (env::global_id = "temp_dir_location", env::default_value = 5) );

    std::cout << TEMP << std::endl;

    return 0;
}
Ejemplo n.º 8
0
void radiator_loop()
{ 
  temp_t tab [] = {
    DS18B20_COLLECTOR,
    DS18B20_OUTSIDE,
  };

  ds18b20_get_temp_tab(sizeof(tab)/sizeof(temp_t), RESOLUTION_9, 7, tab);
  temp_t outside = MIN(tab[0], tab[1]);

  temp_t read_0 = ds18b20_get_temp(DS18B20_RADIATOR_U, RESOLUTION_11, 7);
  _delay_ms(1000);
  temp_t read_1 = ds18b20_get_temp(DS18B20_RADIATOR_U, RESOLUTION_11, 7);

  temp_t curr = read_1 + (read_1 - read_0) * 16;

  temp_t goal = CONFIG_GET(radiator_goal);
  CONFIG static uint8_t radiator_factor = 24;
  if (outside < goal) goal += (CONFIG_GET(radiator_factor) * ((uint32_t)goal - outside)) >> 4;

  bool dir = curr > goal;
  temp_t diff = dir ? curr - goal : goal - curr;

  valve_state_t amount = (VALVE_STATE_MAX * (uint32_t)diff) >> (8 + 6);
  
  if (dir) valve_close_for(VALVE_RADIATOR, amount);
  else     valve_open_for (VALVE_RADIATOR, amount);
 
  if (valve_closed(VALVE_RADIATOR) || outside > TEMP(15)) // quick dirty hack - father wants radiator in bathroom warm, maybe we can achieve that by heating without pump
    relay_off(RELAY_PUMP_RADIATOR);
  else
    relay_on (RELAY_PUMP_RADIATOR);
}
Ejemplo n.º 9
0
void T7(void)
{
    assert(TEMP(3) == 123);
    assert(TEMP2(1) == 123);
    assert(xcat(xcat(1,2),3) == 123);
    assert(strcmp("abc123abc123abc123abc",
		  S1(M1(123))) == 0);
}
Ejemplo n.º 10
0
   cg_buffer2D<float> Amplitude(cg_buffer2D<float> &X, cg_buffer2D<float> &Y) {
      cg_buffer2D<float> TEMP(X.get_width(), X.get_height(), X.get_stride());

      float *dp = TEMP.get_data();
      float *sp1 = X.get_data();
      float *sp2 = Y.get_data();

      for (unsigned int i=0;i<(X.get_stride()*X.get_height());i++) {
         *dp = sqrt((*sp1**sp1)+(*sp2**sp2));
         dp++;
         sp1++;
         sp2++;
      }

      return TEMP;
   }
Ejemplo n.º 11
0
   cg_buffer2D<float> Angle(cg_buffer2D<float> &X, cg_buffer2D<float> &Y) {
      cg_buffer2D<float> TEMP(X.get_width(), X.get_height(), X.get_stride());

      float *dp = TEMP.get_data();
      float *sp1 = X.get_data();
      float *sp2 = Y.get_data();

      for (unsigned int i=0;i<(X.get_stride()*X.get_height());i++) {
         *dp = atan(*sp2 / *sp1);
         dp++;
         sp1++;
         sp2++;
      }

      return TEMP;
   }
Ejemplo n.º 12
0
int main(void)
{
   RCC_Configuration();
   GPIO_Configuration();

   RCC_ClocksTypeDef RCC_Clocks;
   RCC_GetClocksFreq(&RCC_Clocks);
   SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000 - 1);

   setup_adc();
   tim1_init();
   usart_init();

   PWM_U = 0;
   PWM_V = 0;
   PWM_W = 0;

   while(1){
      if(uartsend == 1){
         amp = AMP(amp_raw);
         volt = VOLT(volt_raw);
         if(temp_raw < ARES && temp_raw > 0){
            temp = TEMP(temp_raw);
         }
         from_hv.dc_volt = TOFIXED(volt);
         from_hv.dc_cur =  TOFIXED(amp);
         from_hv.hv_temp = TOFIXED(temp);
#ifdef TROLLER
         from_hv.dc_cur =  TOFIXED(0);
         from_hv.hv_temp = TOFIXED(0);
         from_hv.a = TOFIXED(AMP(ADCConvertedValue[1]));
         from_hv.b = TOFIXED(AMP(ADCConvertedValue[2]));
         from_hv.c = TOFIXED(AMP(ADCConvertedValue[3]));
#endif
         uartsend = 0;
         while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
         USART_SendData(USART2, 0x154);
         for(int j = 0;j<sizeof(from_hv_t);j++){
            while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
            USART_SendData(USART2, ((uint8_t*)&from_hv)[j]);
         }
      }
      //GPIOA->BSRR = (GPIOA->ODR ^ GPIO_Pin_2) | (GPIO_Pin_2 << 16);//toggle red led
   }
}
Ejemplo n.º 13
0
   cg_buffer2D<float> GaussianX(cg_buffer2D<T> &X) {
      cg_buffer2D<float> TEMP(X.get_width(), X.get_height(), X.get_stride());

      T *Tp1 = X.get_data();
      T *Tp2 = X.get_data()+1;
      T *Tp3 = X.get_data()+2;
      float *fp = TEMP.get_data()+1;

      for(unsigned int i=0;i<X.get_height();i++) {
         for (unsigned int j=0;j<X.get_stride()-2;j++) {
            *fp = (G3[0]*(float)*Tp1++) + (G3[1]*(float)*Tp2++) +
                  (G3[2]*(float)*Tp3++);

            fp++;
         }
         fp += 2;
         Tp1 += 2;
         Tp2 += 2;
         Tp3 += 2;

      }

      return TEMP;
   }
Ejemplo n.º 14
0
int main() {
    env::variable<> TEMP( "TEMP", env::global_id = "temp_dir_location" );

    return 0;
}
Ejemplo n.º 15
0
/* Generate code for a section of the mask. first is the index we start
 * at, we set last to the index of the last one we use before we run 
 * out of intermediates / constants / parameters / sources or mask
 * coefficients.
 *
 * 0 for success, -1 on error.
 */
static int
vips_reducev_compile_section( VipsReducev *reducev, Pass *pass, gboolean first )
{
	VipsVector *v;
	int i;

#ifdef DEBUG_COMPILE
	printf( "starting pass %d\n", pass->first ); 
#endif /*DEBUG_COMPILE*/

	pass->vector = v = vips_vector_new( "reducev", 1 );

	/* We have two destinations: the final output image (8-bit) and the
	 * intermediate buffer if this is not the final pass (16-bit).
	 */
	pass->d2 = vips_vector_destination( v, "d2", 2 );

	/* "r" is the array of sums from the previous pass (if any).
	 */
	pass->r = vips_vector_source_name( v, "r", 2 );

	/* The value we fetch from the image, the accumulated sum.
	 */
	TEMP( "value", 2 );
	TEMP( "sum", 2 );

	/* Init the sum. If this is the first pass, it's a constant. If this
	 * is a later pass, we have to init the sum from the result 
	 * of the previous pass. 
	 */
	if( first ) {
		char c0[256];

		CONST( c0, 0, 2 );
		ASM2( "loadpw", "sum", c0 );
	}
	else 
		ASM2( "loadw", "sum", "r" );

	for( i = pass->first; i < reducev->n_point; i++ ) {
		char source[256];
		char coeff[256];

		SCANLINE( source, i, 1 );

		/* This mask coefficient.
		 */
		vips_snprintf( coeff, 256, "p%d", i );
		pass->p[pass->n_param] = PARAM( coeff, 2 );
		pass->n_param += 1;
		if( pass->n_param >= MAX_PARAM )
			return( -1 );

		/* Mask coefficients are 2.6 bits fixed point. We need to hold
		 * about -0.5 to 1.0, so -2 to +1.999 is as close as we can
		 * get. 
		 *
		 * We need a signed multiply, so the image pixel needs to
		 * become a signed 16-bit value. We know only the bottom 8 bits
		 * of the image and coefficient are interesting, so we can take
		 * the bottom bits of a 16x16->32 multiply. 
		 *
		 * We accumulate the signed 16-bit result in sum.
		 */
		ASM2( "convubw", "value", source );
		ASM3( "mullw", "value", "value", coeff );
		ASM3( "addssw", "sum", "sum", "value" );

		/* We've used this coeff.
		 */
		pass->last = i;

		if( vips_vector_full( v ) )
			break;

		/* orc 0.4.24 and earlier hate more than about five lines at
		 * once :( 
		 */
		if( i - pass->first > 3 )
			break;
	}

	/* If this is the end of the mask, we write the 8-bit result to the
	 * image, otherwise write the 16-bit intermediate to our temp buffer. 
	 */
	if( pass->last >= reducev->n_point - 1 ) {
		char c32[256];
		char c6[256];
		char c0[256];
		char c255[256];

		CONST( c32, 32, 2 );
		ASM3( "addw", "sum", "sum", c32 );
		CONST( c6, 6, 2 );
		ASM3( "shrsw", "sum", "sum", c6 );

		/* You'd think "convsuswb", convert signed 16-bit to unsigned
		 * 8-bit with saturation, would be quicker, but it's a lot
		 * slower.
		 */
		CONST( c0, 0, 2 );
		ASM3( "maxsw", "sum", c0, "sum" ); 
		CONST( c255, 255, 2 );
		ASM3( "minsw", "sum", c255, "sum" ); 

		ASM2( "convwb", "d1", "sum" );
	}
	else 
		ASM2( "copyw", "d2", "sum" );

	if( !vips_vector_compile( v ) ) 
		return( -1 );

#ifdef DEBUG_COMPILE
	printf( "done coeffs %d to %d\n", pass->first, pass->last );
	vips_vector_print( v );
#endif /*DEBUG_COMPILE*/

	return( 0 );
}
Ejemplo n.º 16
0
void handle_timechanges(struct tm *tick_time, TimeUnits units_changed) {
	static char time_buffer[256];
	static char clock_buffer[64];
//	static char day_buffer[10];
//	static char date_buffer[10];
	static char ampm[3];
	static char buf[64];
	char *p = 0;
	strftime(ampm, sizeof(ampm), "%p", tick_time);
	time_t current_time = time(0);
	time_t since = current_time + timezone_offset - last_update;

	if(tick_time->tm_sec == 0 && tick_time->tm_min % 15 == 0)
		send_int(KEY_TEMPERATURE, CMD_UPDATE);
	else if(bluetooth && last_update == -1)
		send_int(KEY_TEMPERATURE, CMD_UPDATE);

	static char time_format[16];
	snprintf(time_format, sizeof(time_format), "%%l:%%M");
	if(clock_is_24h_style()) snprintf(time_format, sizeof(time_format), "%%H:%%M");
	if(show_seconds) strncat(time_format, ":%S", sizeof(time_format));
	
	if(clock_is_24h_style())
		strftime(clock_buffer, sizeof(clock_buffer), time_format, tick_time);
	else {
		strftime(clock_buffer, sizeof(clock_buffer), time_format, tick_time);
		snprintf(buf, sizeof(buf), "%c", ampm[0] == 'A' ? 'a' : 'p');
		strncat(clock_buffer, buf, sizeof(time_buffer));
	}
	
	p = clock_buffer;
	if(p[0] == ' ') p++;
	text_layer_set_text(time_layer, p);

	//strncat(time_buffer, "\n", sizeof(time_buffer));	
	strftime(time_buffer, sizeof(time_buffer), "%A\n%B ", tick_time);
	//strncat(time_buffer, buf, sizeof(time_buffer));	
	
	strftime(buf, sizeof(buf), "%e, %Y", tick_time);
	p = buf;
	if(p[0] == ' ') p++;
	strncat(time_buffer, p, sizeof(time_buffer));	
	
	snprintf(buf, sizeof(buf), "\nepoch: %ld", current_time + timezone_offset);
	strncat(time_buffer, buf, sizeof(time_buffer));

	snprintf(buf, sizeof(buf), "\nbattery: %s", battery);
	strncat(time_buffer, buf, sizeof(time_buffer));

	snprintf(buf, sizeof(buf), "\nconnected: %s", bluetooth ? "yes" : "no");
	strncat(time_buffer, buf, sizeof(time_buffer));

	// only show weather and location if we're connected and it has been updated
	if(bluetooth && last_update != -1) {
		if(latitude[0] != 0) {
			snprintf(buf, sizeof(buf), "\nlatitude: %s", latitude);
			strncat(time_buffer, buf, sizeof(time_buffer));
		}
		if(longitude[0] != 0) {
			snprintf(buf, sizeof(buf), "\nlongitude: %s", longitude);
			strncat(time_buffer, buf, sizeof(time_buffer));
		}
		if(location[0] != 0) {
			snprintf(buf, sizeof(buf), "\nlocation: %s", location);
			strncat(time_buffer, buf, sizeof(time_buffer));
		}
		if(weather[0] != 0) {
			snprintf(buf, sizeof(buf), "\nweather: %s", weather);
			strncat(time_buffer, buf, sizeof(time_buffer));
		}
	
		if(temperature != -999999) {
			snprintf(buf, sizeof(buf), "\ntemp: %d\u00B0%c (%d/%d)", TEMP(temperature), metric_units ? 'C' : 'F', TEMP(temperature_min), TEMP(temperature_max));
			strncat(time_buffer, buf, sizeof(time_buffer));
		}
		
		char unit = 's';
		if(since > 3600) {
			since /= 3600;
			unit = 'h';
		} else if(since > 60) {
			since /= 60;
			unit = 'm';
		}
		snprintf(buf, sizeof(buf), "\nupdated: %ld%c ago", since, unit);
		if(unit == 's') snprintf(buf, sizeof(buf), "\nupdated: <1m ago");
		strncat(time_buffer, buf, sizeof(time_buffer));
	}
	
	p = time_buffer;
	if(p[0] == ' ') p++;
	text_layer_set_text(text_layer, p);

	//strftime(date_buffer, sizeof(date_buffer), "%b %e", tick_time);
	//text_layer_set_text(date_layer, date_buffer);
}
Ejemplo n.º 17
0
/* Generate code for a section of the mask. first is the index we start
 * at, we set last to the index of the last one we use before we run 
 * out of intermediates / constants / parameters / sources or mask
 * coefficients.
 *
 * 0 for success, -1 on error.
 */
static int
pass_compile_section( Pass *pass, Morph *morph, gboolean first_pass )
{
	INTMASK *mask = morph->mask;
	const int n_mask = mask->xsize * mask->ysize; 

	VipsVector *v;
	char offset[256];
	char source[256];
	char zero[256];
	char one[256];
	int i;

	pass->vector = v = vips_vector_new( "morph", 1 );

	/* The value we fetch from the image, the accumulated sum.
	 */
	TEMP( "value", 1 );
	TEMP( "sum", 1 );

	CONST( zero, 0, 1 );
	CONST( one, 255, 1 );

	/* Init the sum. If this is the first pass, it's a constant. If this
	 * is a later pass, we have to init the sum from the result 
	 * of the previous pass. 
	 */
	if( first_pass ) {
		if( morph->op == DILATE )
			ASM2( "copyb", "sum", zero );
		else
			ASM2( "copyb", "sum", one );
	}
	else {
		/* "r" is the result of the previous pass. 
		 */
		pass->r = vips_vector_source_name( v, "r", 1 );
		ASM2( "loadb", "sum", "r" );
	}

	for( i = pass->first; i < n_mask; i++ ) {
		int x = i % mask->xsize;
		int y = i / mask->xsize;

		/* Exclude don't-care elements.
		 */
		if( mask->coeff[i] == 128 )
			continue;

		/* The source. sl0 is the first scanline in the mask.
		 */
		SCANLINE( source, y, 1 );

		/* The offset, only for non-first-columns though.
		 */
		if( x > 0 ) {
			CONST( offset, morph->in->Bands * x, 1 );
			ASM3( "loadoffb", "value", source, offset );
		}
		else
			ASM2( "loadb", "value", source );

		/* Join to our sum. If the mask element is zero, we have to
		 * add an extra negate.
		 */
		if( morph->op == DILATE ) {
			if( !mask->coeff[i] ) 
				ASM3( "xorb", "value", "value", one );
			ASM3( "orb", "sum", "sum", "value" );
		}
		else {
			if( !mask->coeff[i] ) 
				ASM3( "andnb", "sum", "sum", "value" );
			else
				ASM3( "andb", "sum", "sum", "value" );
		}

		if( vips_vector_full( v ) )
			break;
	}

	pass->last = i;

	ASM2( "copyb", "d1", "sum" );

	if( !vips_vector_compile( v ) ) 
		return( -1 );

#ifdef DEBUG
	printf( "done matrix coeffs %d to %d\n", pass->first, pass->last );
	vips_vector_print( v );
#endif /*DEBUG*/

	return( 0 );
}