void mppt_scan()
 {
  //  find the pwm duty cycle width that gives the highest input power measurement
  // search up to near full pwm duty % or max output current,
  // which ever occurs first.
 
 int i;
 float fa1,fa0,fa2;
 float  power_sum = 0.0,siin,svin,vbat,pwr,prev_pwr;
 float start_pwm;
 
 // maybe buck converter is stopped, PWM output would be disabled
 // so enable it if needed. DO not enable it when running,
 // PWM will be immediately taken to 1
 // and likely ruin the tracking
 if (is_running == 0)
   buck_start();
 
 // get battery voltage
 fa0 = (float)analogRead(0);
 vbat = fa0 * nvd.vout_cal;

 // get start point for search, set max found to zero
 max_pwr = 0.0;
 start_pwm = pwm;        // save the pre-existing pwm value before it gets mangled

 // smoothly ramp down to small pwm from start pwm.
 // 5 cycle pwm width of the 800 cycle wide full power
 // is not a lot. I call it very low power.
 for(i=pwm; i >35; i-=20)
   {
   pwm = i;
   delay(20);
   }

 // search for max power, and record pwm for that power,
 // from something low to nearly full power
 // or until output current limit is exceeded
 // get power available when fed into the battery.
 
 for(i=20; i < 775; i+=20)
   {
   pwm = i;      // very shortly after this,
                 // the pwm width will be set with this new value
   delay(20);    // milliseconds. Let things stabilise a bit.
             //There are large capacitors on the input and output of the converter
                 // so there will be a time delay
                 // and it will be different with all the different builds.
   //
   // get input voltage
   fa1 = (float)analogRead(VIN);
   svin = fa1 * nvd.vin_cal;
   // get input current
   fa1 = (float)(analogRead(IIN) - nvd.z_iin);
   siin = fa1 * nvd.iin_cal;
   // get output current
   fa2 = (float)(analogRead(IOUT) - nvd.z_iout) * nvd.iout_cal;  
   // do not exceed max current setting, if so break out of this loop
   if (fa2 > nvd.imax)
     break;
   // get power
   pwr = svin * siin;
   // do search
   if (pwr > max_pwr)
     {
       max_pwr = pwr;
       max_pwr_pwm = i;
     }
   }
   
 // smoothly ramp back down to start position,
 // down from the search end point down to start_pwm
 for(; i > (start_pwm + 20); i -= 20)
   {
   pwm = i;  
   delay(20);
   }
 }