BOOST RENEWABLES - give us feed-in tariffs

There are a lot of interesting laws being considered to boost investment and viability of renewable energy sources. Net metering is just one, then there are feed-in tariffs and virtual net metering also called remote net metering or aggregate net metering.

In situations where multiple investors ( a group of neighbors ?) want to share the output of a renewable energy source, and perhaps these investors are remotely located from the source, virtual net metering will allow the renewable energy produced and metered at the source to be credited to any other investor meters out there on the grid.

Feed-in tariffs insure that renewable energy sources receive the same or higher price for their energy as fossil fueled (and subsidized) sources. Seems only fair, but currently in NY, the utilities are allowed to pay less for clean renewable energy, or only what is called the 'avoided cost', somewhere around 4 cents / KWhr  while charging a retail of 10 to 16 cents / KWhr.  A feed-in tariff would set ( and stabilize) the price somewhere in between so that investors can be certain of their return on investment and not have to gamble that the price of renewable energy is set by those that have a vested interest in burning fossil fuels.

These laws are slowly being passed piecemeal state by state. Eventually I look forward to progressive national legislation on this front. There is still lots of resistance from vested interests, but they are slowly figuring out that this kind of legislation does not hurt too many and helps boost renewable energy generation and national energy independence.

Survived Irene - barely

This video was taken after the water crested and pretty much covered the flume, causing it to rise up and down on the flood waters. Managed to save it by clearing debris from the inlet to flood it and weigh it down. It would have been destroyed if I had not been here. The upside to all this wet ... been running all year and they just passed net metering for under 25KW hydro in NY!

Three Phase to Single using a 3Ø induction motor as generator

Common Micro Hydro Misconceptions

Hydro power - common misconceptions.

1. If there is a waterfall just let the falling water hit some paddles to which the generator is coupled and you are in business.

2. Rainwater running from the roof could be used to make electricity.

3. Hookup a turbine or Pelton wheel to your faucet, incoming waterline, or garden hose and you can keep the lights on for free. 

4. How about if I have a 2400 gallon tank 100 feet higher on a hill that fills up in 24 hours. How much electricity can I get? Answer: it will light up a night light continuously or brew coffee once in 24 hrs. (1800Watts for 10 min) 

Or 300Watt hrs  = .3Kwhrs about 2 cents worth.

Connecting to the Utility Grid

Net Meter Micro Hydro – The Road to Energy Independence

By Robert Honders, Honderosa Valley Consulting

Net metering is the single most effective policy government can implement to promote renewable energy derived from all sources. Why exclude waterpower? If net metering were extended to all small scale (under 25KW) hydro sites, we would see renewed interest in the restoration of thousands of micro hydro sites that have been abandoned during the times of cheap oil. Many of these sites could be made productive again with lower investments because the infrastructure (dam, penstock, water supply) may still be intact. There is no valid reason to treat one renewable energy source any differently than another. We need them all to pave the road to energy independence.

The advantages of a grid connection include energy storage and vastly simplified control of frequency & voltage. Essentially the site runs wide open and just pushes energy into the grid at the grid voltage and frequency. It is analogous to you helping a freight train by pushing on the back of it. You won't be able to change its speed at all, even if your efforts are doubled, or stopped altogether. In other words, your energy input can fluctuate, but the train stabilizes everything just as the grid stabilizes relatively small energy inputs.

The simplest way to get grid-connected and reap these stabilizing benefits is through net metering. Net metering is accomplished using a single-bidirectional meter, which is already in place on all grid-connected homes. But beware! The newer electronic meters are programmed by the utility company to ignore the direction of the energy flow. Thus you can end up paying for the energy that you send to the grid! The power company prevents small energy producers from sharing the energy they generate with their neighbors and turning their own meter backward without permission.         (Older spinning disk meters were not programmable in this way. The worst they could do to you is stand still while you were supplying power, and spin forward as you used power.)

To get grid connected with your hydro powered induction generator (cheapest, robust and most common) you’ll need to use an ‘inter-tie protection relay’ like the Beckwith M-3410. The relay monitors the grid / utility (not your generator) for any type of anomaly, like ‘grid down’, voltage or frequency too low / high etc. If any grid anomaly occurs the relay disconnects your micro hydro output from the grid for their protection. After grid power is restored the relay monitors the grid and if the grid has been normal for 5 minutes it will re-connect your micro hydro. You will need to wire an auxiliary contactor to hang a dump load (space heater will do) on your induction generator while it is disconnected from the grid to prevent your output voltage from rising too high.  Below you’ll find the diagram for a system like this. Double click to enlarge.

Once your utility has inspected and tested your grid inter-tie for proper operation, AND if your state law has hydro power included in the net metering law, then you can ask your utility company to re-program your meter so you can share your excess power with your neighbors and run your meter backwards. Net metering makes it possible to ‘store’ your excess energy in the grid instead of in batteries, and returns energy to you when you need it, perhaps during a dry August, and at the same price.                          

So let’s have NET METERING FOR ALL RENEWABLE ENERGY be the law of the land!

Pumps as Turbines have many advantages.

If you are good with welding you may want to consider making your own 'turbine' case to replace the pump case and use only the impeller, shaft, seals and bearings from a split case pump. This will allow you to design the turbine case with a much larger inlet to eliminate the restrictive pump outlet.  Note that pump outlet = turbine inlet. This will get you a little more efficiency in converting the energy in the water ( head X flow ) to mechanical shaft energy.

You could even buy just the parts you need. Example shown here. This is a project I'm considering, at least on paper. Another approach might be to modify a split case pump housing with a second outlet. (inlet with respect to turbine operation) Since these housings are mostly made of cast steel it would involve welding of cast steel or cast iron. I'm not sure it would be worth it for maybe a 5% boost in efficiency. But if you like to tweak and optimize ...

Alternative Power Lecture series at SUNY Orange

Alternative PwrFlyer

The Engineering Mind ...

Arduino and bidirectional AC valve motor controller for Micro Hydro

The diagram, Arduino on left Rotork valve operator right, blue outline of turbo-gen extreme right.

       /*
      Generator RPM control Robert J Honders Sr 7/9/2013
      Changed: 8/30/13 to control the 120VAC motor on ROTORK valve actuator.
      Tuned: 2/7/2014, onsite w Gen1 on grid 
      and simulated unloading by switching off C1 then Gen1. 
      Loads continuously powered by grid. Still problem osc when no load.
      2/12/2014 tweaked program, added Inverse of Deviation element to help stay put within range.
      3/23/2014 Added intermediate Proportional error bands. 
      Rev6 3/24/2014 Reversed valve adjustment order to close first.
      Rev 6.5 added DeltaRPM to correct rapid changes. Abandoned that idea.
      Rev 6.6 Added more speed error bands, now 7.
      WAY OVER,  OVER,  NEAR+,  WITHIN SPAN,  NEAR-,  UNDER,  WAY UNDER.
      
      NOTE: A lot of testing stuff is commented out of the program. By removing
      the '//' you can get stuff to print out on screen. Input to pin 2
      can be simulated with 'hall effect' type pickup (TLE4906) and a tiny magnet
      on the VARIAC controlled test motor shaft. Here is a simple Arduino pulse generator 
      routine to give a 1ms negative pulse every 32ms (variable with a pot) for off site testing.
      
      
  
  I needed to have a variable source of negative going pulses, potentiometer adjustable, around 33 ms apart, 
  to simulate what comes from my Micro Hydro generator hall pickup. Just so I would not have to be in the
  noisy powerhouse to develop the PID valve controller to operate the motorized valves.(Another project.)  
  
  Control the frequency of pulse at pin 13 with 10K potentiometer, center to pin A0, one end to +5, other to GND.
  Not possble to use - delayMicroseconds() - if the pulses need to be shorter and faster because DelayMicroseconds
  is only good up to 16383. I got around that by dividing the time in four. Lots of details to help you
  and me understand it.   Robert Honders Sr 3/28/2014

//START OF TEST PULSE GENERATOR.

            // constants won't change. Used here to set pin numbers. 
            const int pulsePin = 13; // sets which output pin to pulse.  
            //Declare some variables.
            int OldPotValue;//declared here it is good throughout and only zeroed here.
            int PotValue;    //declared here it is good throughout and only zeroed here.
            int error;  //Really the change in PotValue as we turn the shaft.
            int minPotDelta=100;// This is the minimum change sensed in 100000, turning the pot.
                                  // this is to eliminate jitter in sucessive A/D conversion readings
            
  void setup()   // the setup routine runs once when reset is pressed.
          
          {
             Serial.begin(9600);       
             Serial.println(" pot variable generator RPM pulse simulator");
             pinMode (pulsePin, OUTPUT);// set digital pin to OUTPUT, they default to inputs.
          }
  
  void loop()  // the loop routine runs over and over again forever 
  
    {
             
      
            //Serial.println (OldPotValue); //milliseconds between pulses NOT?
           // delay (1000);
            
            PotValue = analogRead(A0);// read the pot input on analog pin A0:
            PotValue = map(PotValue,0,1000, 0,100000);//the second 2 can be swapped to get the pot to give higher RPM on clockwise.
            PotValue = PotValue/4;// divided in four to get around delayMicroseconds limitation, the latest pot value.
             
            error = OldPotValue - PotValue; // is it different than the last pot value by an amount called error
              
              
              if  (abs(error) <= minPotDelta) //error is change in pot setting if small change use OldPotValue, eliminates small A/D conv errors.
              {
                 
                PotValue = OldPotValue;// if the pot value changed by less than the minPotDelta than we will use the OldPotValue.
                   // if the pot is not moved we'll be up here.
                   digitalWrite(pulsePin, LOW);
                   delayMicroseconds(500);//fixed pulse width of half a millisec.
                   digitalWrite(pulsePin, HIGH);
                   
                   delayMicroseconds(PotValue);   
                   delayMicroseconds(PotValue);// four times to make up for /4
                   delayMicroseconds(PotValue);
                   delayMicroseconds(PotValue);
                 
                    //Serial.println ("no change ") ;
                    //Serial.println (PotValue);
                    //Serial.println (error);
              }   
                 
                 if  (abs(error) >= minPotDelta)

              {     
                   // if the pot IS adjusted we'll be down here.
                   digitalWrite(pulsePin, LOW);
                   delayMicroseconds(500);//fixed pulse width of half a millisec.
                   digitalWrite(pulsePin, HIGH);
                   
                   delayMicroseconds(PotValue);   
                   delayMicroseconds(PotValue);// four times to make up for /4
                   delayMicroseconds(PotValue);
                   delayMicroseconds(PotValue);
                 
                    Serial.println ("                  new PV ") ;
                    Serial.println (PotValue);
                    Serial.println (" Change in PotValue ") ;
                    Serial.println (error); 
              }
                  
                   OldPotValue=PotValue;//store the current pot value to compare with the new.
      }
          
      //END OF TEST PULSE GENERATOR.    


      The sketch uses a timer to work out the interval
      between two consecutive rising edges on pin D2. This time we use a "rising"
      interrupt on D2 to notice the leading edge. We also set up a high-precision
      timer (Timer 1) which is a 16-bit timer.
      
      By using no prescaler, Timer 1 counts 1 for every clock cycle (say, every
      62.5 nS at 16 MHz).
      By multiplying the number of counts between the leading edges by 62.5, and 
      then taking the inverse, we can deduce the frequency.
      
      The advantage of this method is that we get a very quick calculation.
      For example, at 10 KHz the period is 1/10000, namely 100 µS, so we get our
      result 100 µS later.
      
      Note that due to the time taken to service the interrupts on the data's leading
      edges, the maximum achievable frequency you can sample is around 100 KHz 
      (which would mean the ISR(Interrupt Service Routine) is taking around 10 µS).
      
       Frequency timer
       Author: Nick Gammon
       Date: 10th February 2012
       Adapted and annotated for Generator RPM control Robert J Honders Sr 7/9/2013 - 9/2/13
       
       
       A variable should be declared volatile whenever its value
       can be changed by something beyond the control of the code section in which it appears,
       such as a concurrently executing thread. In the Arduino, the only place that this is
       likely to occur is in sections of code associated with interrupts, called an interrupt service routine.
      */
      
      
      volatile boolean first;
      volatile boolean triggered;
      volatile unsigned long overflowCount;
      volatile unsigned long startTime;
      volatile unsigned long finishTime;

      // here on rising edge on pin 2, is interrupt 0 always on pin 2 ??
 void isr () //Start of Interrupt Service Routine
          {
            //digitalWrite(2, HIGH);//sets pin 2 hi eliminates 10 k pullup, can be left in crkt.
            unsigned int counter = TCNT1;  // quickly save counter 1 count in counter.
            
          
            if (triggered)// wait until we notice last rising edge
              return;
          
                  if (first)
                    {
                    startTime = (overflowCount << 16) + counter;
                    first = false;
                    return;  
                    }
              
            finishTime = (overflowCount << 16) + counter;
            triggered = true;
            detachInterrupt(0);   
          }  // end of interrupt service routine



  // timer overflows (every 65536 counts)
  ISR (TIMER1_OVF_vect) 
        {
          overflowCount++;//increment overflow count by 1
        }   // end of TIMER1_OVF_vect


 void prepareForInterrupts ()
        {
        // get ready for next time
        EIFR = _BV (INTF0);  // clear flag for interrupt 0
        first = true;
        triggered = false;  // re-arm for next time
        attachInterrupt(0, isr, RISING); //look for next rising edge and run ISR    
        }  // end of prepareForInterrupts

 void setup () 
      {
        Serial.begin(9600);       
        //Serial.println("Tachometer");
        
        // reset Timer 1
        TCCR1A = 0;
        TCCR1B = 0;
        // Timer 1 - interrupt on overflow
        TIMSK1 = _BV (TOIE1);   // enable Timer1 Interrupt
        // zero it
        TCNT1 = 0;     
        // start Timer 1
        TCCR1B =  _BV (CS20);  //  no prescaling
      
      
        prepareForInterrupts (); // set up for interrupts to get new RPM data.
        
      } // end of setup

int previousMillis = 0;        // will store last TIME RPM was updated.
int previousRPM =0;        // will store last RPM read.


 void loop () // the main loop will have to be modified for PID.
        {
      
        if (!triggered)// if NOT triggered 
          return;//wait here until it is.
       
        unsigned long elapsedTime = finishTime - startTime;
        int RPM = 60.0 / ((float (elapsedTime) * 62.5e-9));  // each tick is 62.5 nS
        
       
        /* 1800 RPM = .333s per rev = frequency of 30 per second X 60 s/min = 1800 RPM
           So 1800 RPM is 33.33ms / .0000625ms = 533,333 ticks or counts of the 16 Mhz Arduino clock in one revolution! 
           That hapens between pulses from magnetic "Hall" motor pickup, so we get very high resolution RPM, 
           any small change will be detectable, probably overkill.
        */
        Serial.println () ;
        Serial.print (RPM); 
        Serial.println (" RPM ");
     
        
        //Figure Delta RPM here and work it into the if over/under corrections.      
        int currentRPM = RPM; //store the RPM now
        int DeltaRPM = currentRPM - previousRPM; //the change in RPM readings.
        previousRPM = currentRPM; // save the last time you got the RPMs
        
       
        /*
        
        The following attempt at PID control not successful so far.
        // figure Delta T here
        int currentMillis = millis(); //store the count now
        int DeltaT = (currentMillis - previousMillis)/60000; //the time between RPM readings in minutes.
        previousMillis = currentMillis; // save the last time you got the RPMs
        Serial.print (DeltaT);
        Serial.println (" Delta T ");
                             
        int Deriv=DeltaRPM/DeltaT; // Drpm/Dt 1st derivative variable Delta T
        Serial.print (Deriv);
        Serial.println (" Derivative ");
        */ 
         
  
      
        //this section will run the valve motor for a duration proportional to the deviation or error
        // to close valve if RPM is HI, or to open valve if RPM is LO. Also DeltaRPM will reduce the effective RunTime.
        
        //Added setup code, Do these go here as part of setup??
        //Yes, did not work in "void setup()" above, local variable scope? do we need a second Void Setup.
        //******************SET*UP***********************
        
        int CenterRPM=1820;// 1820, adjust center RPM to open valve with minimum pulse width (green blink)in grid mode.
        int Span = 20;// 10, sets max + AND - deviation from CenterRPM, (+ plus - ), sets system accuracy.
        int WindDownTime = 1000; // 100-2000, time for motor to stop, ms, before next pulse, if within range it is multiplied by InvDevMag.
        int RunTime = 6;//2-10, motor run time to move valve, ms, automatically reduced if deviation is small, increased if deviation is big.
        
        //**************END*SET*UP************************
        float Deviation;// Error signal signed, + is fast
        int DevMag; //absolute value of Deviation, magnitude only, unsigned.
        float InvDevMag;//the inverse of deviation magnitude.
        int openPin = 8; // sets which output pin to open valve, these 2 pins must not both be high.
        int closePin = 7; //sets what pin to set high to close valve.
        pinMode (openPin, OUTPUT);// set digital pins to OUTPUT, they default to inputs.
        pinMode (closePin, OUTPUT);//analog pins do not have to be declared inputs or outputs.
        //end of added setup code 
        
        //DeltaRPM = constrain (DeltaRPM,-RunTime+25,RunTime-25); 
        //Serial.print (DeltaRPM);
        //Serial.println (" Delta RPM ");
        
        Deviation = RPM-CenterRPM;// positive is running FAST
                                  //if(Deviation < 0)//running slow, ERROR signal.
        
        
        if (Deviation == 0) (Deviation = 1);// so we don't end up dividing by 0 in the next line.
        
        InvDevMag =((Span)/Deviation);//less deviation bigger number, stay put longer time when within Span.
        InvDevMag =(abs(InvDevMag)); //no negative time allowed, Inverse Deviation Magnetude, small deviation stay put longer.
        //InvDevMag = map(InvDevMag,0,Span, 0,(3*Span));    
            
            //Serial.print ("Deviation ");
            //Serial.println (Deviation); 
            //Serial.print ("inverse of deviation ");
            //Serial.println (InvDevMag); 
        
        
        DevMag = (abs(Deviation));//just the magnitude to set the output motor RunTime time proportionally.
      
        
            //Serial.print ("DevMag ");                          
            //Serial.println (DevMag);
        
        //DevMag = map(DevMag,0,Span, 1,(Deviation)*Span);  // re maps 0 to Span >> 1 to abs Deviation*Span eliminates 0 from DevMag. 
        //DevMag = abs(DevMag);//no negative values   
            
            //Serial.print ("DevMag "); 
            //Serial.println (DevMag);
            
        DevMag = constrain (DevMag,1,2000); //keeps deviations from blowing up when motor stopped.
            //Serial.print ("Constrained DevMag ");                          
            //Serial.println (DevMag); 
        
        // These error bands progressively increase duration of RunTime and decrease duration of 
        // WindDownTime in proportion to the Deviation Magnitude or error, modulating the AC motor speed and direction.
       
        // WAY OVER,  OVER,  NEAR+,  WITHIN SPAN,  NEAR-,  UNDER,  WAY UNDER.
        
        
        if (Deviation > 2*Span)  // RPM Deviation way too high, close valve longer. 
       
                  {
                    Serial.println ("WAY OVER");
                    
                    digitalWrite(openPin,LOW);//GREEN LED off, allow CLOSE VALVE 
                    //delay(WindDownTime);//so we allow the motor to spin to a stop between pulses.
                    digitalWrite(closePin,HIGH);//RED LED on to CLOSE VALVE.
                    
                       delay (RunTime*DevMag/4);// keep motor running CLOSING valve longer if Dev Magnitude is big.
                    
                    digitalWrite(closePin,0);//reset RED closePin (5) to stop motor.
                    digitalWrite(openPin,0);//reset GREEN openPin (6) to stop motor. 
                    delay(2*WindDownTime*InvDevMag);//so we allow the motor to spin to a stop between pulses for shorter time if deviation is big.
                   
                  }
        
        
        
          
        else if (Deviation > (Span) && (Deviation <= 2*Span)) // positive deviations, RPM a little too high, CLOSE valve short time.
          
                  { 
                    Serial.println ("OVER");
                    
                    digitalWrite(openPin,LOW);//GREEN LED off, allow CLOSE VALVE 
                    //delay(WindDownTime);//so we allow the motor to spin to a stop between pulses.
                    digitalWrite(closePin,HIGH);//RED LED on to CLOSE VALVE.
                   
                       delay ((RunTime)*(DevMag/5));// keep motor running CLOSING valve longer if Dev Magnitude is big.
                    
                    digitalWrite(closePin,0);//reset RED closePin (5) to stop motor.
                    digitalWrite(openPin,0);//reset GREEN openPin (6) to stop motor. 
                    delay(4*WindDownTime*InvDevMag);//so we allow the motor to spin to a stop between pulses for short time if deviation is big.
                  }
          
        
        
        
        else if (Deviation > Span/2 && Deviation <= Span) // positive deviations, RPM a little too high, CLOSE valve short time.
          
                  { 
                    Serial.println ("NEAR+");
                    
                    digitalWrite(openPin,LOW);//GREEN LED off, allow CLOSE VALVE 
                    //delay(WindDownTime);//so we allow the motor to spin to a stop between pulses.
                    digitalWrite(closePin,HIGH);//RED LED on to CLOSE VALVE.
                    
                       delay (RunTime*(DevMag/2));// keep motor running CLOSING valve longer if Dev Magnitude is big.
                    
                    digitalWrite(closePin,0);//reset RED closePin (5) to stop motor.
                    digitalWrite(openPin,0);//reset GREEN openPin (6) to stop motor. 
                    delay(2*WindDownTime*InvDevMag);//so we allow the motor to spin to a stop between pulses for short time if deviation is big.
                  }
          
          
          
          
        else if (Deviation >= (Span/-2) && (Deviation <= Span/2)) //within span, just keep the Valve motor stopped longer.
                                      
                  {
                      Serial.println ("Within Span");
                        
                      digitalWrite(closePin,LOW);//reset RED closePin to keep motor stopped.
                      digitalWrite(openPin,LOW);//reset GREEN openPin to keep motor stopped. 
                      delay((InvDevMag/4)*WindDownTime);//Speed is within span so wait a while proportional to how close to center RPM 
                                                      //so we allow the motor to spin to a stop between adjustments.  
                  }
          
         
        else if (Deviation < (Span/-2) && (Deviation >= -1*Span)) // small negative deviations, RPM a little too low, OPEN valve short time.
          
                  { 
                    Serial.println ("NEAR-");
                    
                    digitalWrite(closePin,LOW);//RED LED off, allow OPEN VALVE 
                    //delay(WindDownTime);//put some time between OPEN and last CLOSE commands so we don't do both.
                    digitalWrite(openPin,HIGH);//GREEN LED on OPEN VALVE.
                    
                       delay ((RunTime*DevMag/2));// keep motor running OPENING valve longer if Deviation Magnitude is big.  
                    
                    digitalWrite(closePin,LOW);//reset RED closePin to stop motor.
                    digitalWrite(openPin,LOW);//reset GREEN openPin to stop motor. 
                    delay(2*WindDownTime*InvDevMag);//so we allow the motor rest a shorter time if dev is big, between pulses. 
                  }
         
         
         
         
         
          else if (Deviation < (-1*Span) && (Deviation >= -2*Span)) // small negative deviations, RPM a little too low, OPEN valve short time.
          
                  { 
                    Serial.println ("UNDER");
                    
                    digitalWrite(closePin,LOW);//RED LED off, allow OPEN VALVE 
                    //delay(WindDownTime);//put some time between OPEN and last CLOSE commands so we don't do both.
                    digitalWrite(openPin,HIGH);//GREEN LED on OPEN VALVE.
                    
                       delay ((RunTime)*(DevMag/5));// keep motor running OPENING valve longer if Deviation Magnitude is big.  
                    
                    digitalWrite(closePin,LOW);//reset RED closePin to stop motor.
                    digitalWrite(openPin,LOW);//reset GREEN openPin to stop motor. 
                    delay(4*WindDownTime*InvDevMag);//so we allow the motor rest a shorter time if dev is big, between pulses. 
                  }
         
         
         
       
          
         else  // big negative deviations, RPM way too low, open valve longer time.
        
                  { 
                    Serial.println ("WAY UNDER");
                    
                    digitalWrite(closePin,LOW);//RED LED off, allow OPEN VALVE 
                    //delay(WindDownTime);//put some time between OPEN and last CLOSE commands so we don't do both.
                    digitalWrite(openPin,HIGH);//GREEN LED on OPEN VALVE.
                    
                       delay (RunTime*DevMag/4);// keep motor running OPENING valve longer if Deviation Magnitude is big.  
                    
                    digitalWrite(closePin,LOW);//reset RED closePin to stop motor.
                    digitalWrite(openPin,LOW);//reset GREEN openPin to stop motor. 
                    delay(2*WindDownTime*InvDevMag);//so we allow the motor rest a shorter time if dev is big, between pulses. 
                  }
         
        
          
        prepareForInterrupts ();  // get a new reading of RPM   
      }   // end of loop

Choosing penstock pipe

In choosing pipe consider these:

1.  In larger sizes ( > 6" ) steel / iron pipe is cheaper for the same pressure rating. And used ( gas line) steel pipe is even more cost effective.

2.  I'm a pretty good welder, but even hiring a welder to do the job costs as much as hiring an HDPE fusing machine and operator.

3.  HDPE needs more supports to keep the pipe from sagging under the weight of the water where it is up in the air.

4.  For gentle bends (< 45°) steel pipe ends can be cut at a slight angle and welded together avoiding the use of expensive fittings.

5.  If there is ever a forrest fire plastic pipe on top of the ground may well burn up.

6.  In cold temperatures a tree falling on exposed HDPE will crack it.

Of course the best way to protect any pipe is to burry it and that would make plastic more attractive as it also limits thermal expansion and contraction which can be a problem with HDPE on the surface. (I have seen exposed plastic pipe pull apart at joints when the temperature dropped at night. The 8" PVC pipe was glued up on a hot day, empty, when the overnight temperatures dropped it pulled two of 12 joints apart.)

All things considered, if you have more than 100' of head and need > 8" diameter pipe you are a good candidate to use steel pipe especially if you can weld it yourself reasonably well. If you have to come down rocky cliffs, like I did, then that would favor steel pipe also.

For lower heads and / or smaller diameters HDPE or even PVC would be easier to handle and more durable when buried. If plastic pipe is not buried it will need to be protected from UV exposure.

Marking & cutting 8"  0.25" wall steel pipe.

Make the cut with an angle grinder and thin cutoff blade.

Welding pipe on pipe dolly







                  Using homemade alignment clamp.

                         Welding pipe on the ground                          

Below, the blown out schedule 40 T
static pressure 94 PSI, must have surged.

The fiberglass reinforced schedule 40 elbow.

Dealing with sand, gravel, ice, leaves just to mention a few things in the water.

PVC moving belt trash rack


Frazil ice, leaves and gravel have been my biggest maintenance headaches. But I'm hoping those headaches are behind me now that I've designed and built a PVC moving belt trash rack.

Freezing up of the intake screen after 3 to 4 nights of subzero temperatures is a common problem in cold climates. As the water splashes down over rocks it ends up supercooled (30°F) and slushy. The instant supercooled water hits any cold material, especially metal, it sticks and builds up, shutting off the largest of openings, even with trash rack / screens totally removed.

In a case here I have a 48" wide X 8" high opening at the inlet end of a 30 ft near horizontal covered flume that leads water to a 4' X4'X 5' deep box with a plastic, moving conveyor screen installed near the top that dumps debris and slush (sometimes referred to as frazile ice) over the downstream edge of the box. The penstock pipe leaves the bottom of the box and the whole thing is covered with PT 2X.

Now I thought I had my freezing intake screen problems solved, using a covered, PVC, moving screen, that runs mostly underwater except for the 6 inches or so that sticks out over the edge of the baffle to dump the leaves, gravel and ice. This screening arrangement allowed me to remove the metal trash rack at the 48"X8" entrance to the flume. ' Thought that big hole would never be able to freeze up with water running into it. Wrong!  The water gets so thick with slush that it dams up the stream itself, then naturally, the ice dam overflows and the overflow freezes on the lip of the ice dam. And so, once the slush freezes solid, you get these interesting ice stairs, ice dam with level ice behind it, then another ice dam with level area... and so on up stream. Usually after a few days of ice stair formation, and as daytime temps rise, the water and slush disappear from the surface and water will continue to run underneath the now frozen hard ice cover. So long as the ice cover remains it will keep the water from supercooling and forming slush. You will have no problem running your micro hydro as the water runs under the ice cover. But how to deal with those few days of slushy ice damming water?

A deep (6') collection reservoir will go a long way toward solving this problem, but my stream flows over bedrock before falling off a cliff. A small dam would probably work but for various reasons was ruled out for now. I thought about heating tapes. They might ease the slush formation in the immediate area of the intake. They would have to be put inside antifreeze filled iron pipes to protect them from the rocks, logs and other storm debris. But thinking along these lines I remembered that we have a spring on a somewhat distant higher hillside. I had previously run a 1 1/2" PVC pipe from this source of 50°F spring water to our house for use as a domestic water supply. There is plenty of water especially in winter.  So I ran another 500' of 1/2 inch PVC downhill to the 48X8 problem intake flume and squirted the warm? water out upstream from the flume. This did the trick, at least this last winter, which was plenty cold. I think this could also work with pumped well water which is also relatively warm. The water would only have to run for the few days before the ice covers the stream. The pipe would retain more heat if it were buried and/or insulated, it should be pitched so it drains out completely when shut off.

You can purchase plastic conveyor belt with a large % of open space for the water. Order it to size or get it used (cheap) on Ebay and reconfigure it to the size you need. I am anxious to try this stuff in really cold weather. I have had to remove my old metal screen whenever the temps went below Zero °F. I also covered the whole intake flume, box and screen to keep it from freezing up. So far it has worked very well to keep all kinds of debris out of my penstock. The excess water that does not go down the pipe rinses the leaves off as they invert over the drive roller. The 18 RPM Bodine gear motor is directly coupled to the 3" PVC pipe that drives the screen. A slew of 3/16 holes drilled into the PVC pipe in exact locations matching the screen holes, and fitted with plastic pins, gives positive traction to the screen. Even though the screen moves slowly at about 6"/second, I still put a timer on the drive motor so it is on for 3 minutes then off for 6. This saves energy and wear and tear.



The PVC belt is made up of small sections hinge pinned together with 3/16" plastic (welding) rod to make any size screen. The short section of belt wrapped around the PVC pipe allows the accurate drilling of holes to accept short (1/2") pieces of 3/16 rod that act as sprocket teeth. I had to make the outside diameter of the standard 3" PVC pipe bigger by 1/4 inch to get it to accept the pitch of the plastic belt. If you are going to build this send me an email and I'll send you more specific 'how to' info.


Here is how I got my belt, and I turned the square hole sprockets on the lathe to just fit inside the 3" PVC pipe so it could be driven with a square tube drive shaft.



The basic drawing of the whole thing. Double (or Right?) click on the image to see it enlarged.


The 'Gravel Baffle Box' with the covers removed from the butterfly valve drive (left) and the screen drive motor box on the right. (looking up stream, the dam and falls are behind the viewer)

Building a Micro Hydro - Video Overview

Pumps as Turbines (PaT) Motors as Generators

I have been using Pumps as Turbines and motors as generators very successfully for almost four years now. The optimum (maximum power) speed of a PaT is around 1/2 of its no load speed. So to test,run your PaT and generator with the available head but no electrical load or excitation. Then, for maximum power, you should load the system so it runs at 1/2 this No Load speed. So let's assume you have a six pole electric motor running as a generator at 1200 RPM (nominally). You would be looking for a No Load speed of (approximately) 2400 RPM at the generator shaft. If the PaT is direct coupled the only thing that can be tuned is the impeller diameter assuming the head is fixed. Cut down (on a lathe) the impeller diameter to increase the No Load RPM. If the generator is coupled to the PaT by a V belt the shiv ratios can be changed to give the correct RPMs.


How can I estimate roughly the maximum no load speed when impeller diameter and the net head are known?


No Load RPM= (19.1)(SQRT(64 H))/D
Where H= Head in feet, D= impeller diameter in feet (not inches)

So if H = 200 feet and Impeller Diameter is 7 inches we get a No Load RPM = 3699
This is a little high for a 4 pole (1800 RPM) generator, I'd rather be on the low end for better efficiency (less friction due to lower velocities). I would choose an 8" impeller. Or, (even better) go to a 6 pole 1200 RPM (direct coupled) motor, bring the no load speed down to 2400 RPM and calculate the required impeller diameter as below.


More often, you would know the full load normal operating speed of the generator to produce 60Hz from the name plate or the number of poles. Also the head is fixed and known. So you'll want to know what the impeller diameter should be for a direct coupled setup:


Impeller Diameter in inches = 230(SQRT(64 H)/R


Where H = head in feet, R = No Load RPM and SQRT = Square root


So if H = 200' and R = 2400, we get an impeller diameter of 10.8 inches.


These admittedly rough calculations work well with Pelton wheels as well as Francis type runners.


By the way, larger pumps are well designed and optimized to be very efficient. When run in reverse as turbines they perform just like Francis type turbines and are every bit as efficient, assuming you match up head, impeller diameter and operating speed.
The graph above shows how I reverse engineered the pump curves for for operation as a turbine. This analytical approach is not as easy to understand as the empirical approach described above. Note the U shaped > 73 % efficiency region. This is where you want to be operating this particular PaT with a 12 inch impeller, 230 ft of head, and using 750 Gpm with expected output of 25 Hp mechanical energy. BTW, pumps are designated by their outlet X suction inlet X impeller diameter. So this is a 3X4X12 end suction pump with a 30HP, 1800 RPM 3 Phase electric motor.

Rolling logs uphill unloading from a trailer.

In the early 90's I built a circular saw mill on the back 40. I pick up logs in the local area, often felled by homeowners, and I often end up with a trailer load of big heavy logs to unload at the mill. I put a winch in the back of my old F250 and here is how I load and unload my trailer by just pushing a button.

Best little Hydro House in NY, 20 KW of renewable energy.

A quick overview of the building process. Picked up some inspiration in Costa Rica where pelton wheels could be seen laying around in yards, as ornaments, like wagon wheels here in the US. This is my first attempt at creating a video with music composition. So keep in mind, I'm an engineer not a liberal artist.



It appears my video's no longer play since Google takeover.

Single Phase from a 3 Phase induction motor/generator

Are pumps and electric motors usable as turbine/generators?

Hi Robert,

Thank you so much for your generous answer. As I am not electrical, and so I am really not able to understand those diagrams and some terms, before I contact a technician here to helping me with the job, let me ask you some, in my words, willing to get your answer in the most possible simple words (as if it were for kids!):

Thanks in anvance for your teachings!.

Cheers,

Felipe

1- Are pumps (and electric motors) used as PAT (and MAG), just as they are/come from manufacturer?, or, do they need to be modified for a micro-hydro (if so, what kind of modifications)?.

1. No modifications are needed. Just force the water into where it squirted out when it was a pump. You will need to add excitation capacitors to the motor to make it generate electricity all by itself. But if it is hooked to the grid you don't need any capacitors.

2- What is the capacitors function?

2. The capacitors basically store up a bunch of electrons in a few milliseconds and dump them back into the induction generator in the next few milliseconds. So the capacitors help to bounce the current back and forth in tune with 50 or 60 Hz (cycles per second).

3- Why is it neccesary to double (2x) the pump-labeled speed (rpm) of pumps, for micro-hydro purposes?

3. There are 2 extremes with a turbine / generator. At one end we have no load and the machine spins the fastest that the water velocity will allow. At the other end we load it down so much that the speed drops to 0 RPM. The best efficiency and maximum power happens somewhere close to the middle between these two extremes. And we know where we want to be operating normally (at the midpoint) so the no load speed should be around 2X that.

4- What 'delta' connections is?

4. Delta = triangle, the three windings are connected in a triangular configuration, as opposed to star configuration. See: http://www.allaboutcircuits.com/worksheets/deltawye.html

5- What are the differences (both constructive and energy-flow-path meanning) between electric motors, and generators?.

5. Induction motors and induction generators are identical in every way. You can have an induction motor plugged in, running at 1800 RPM, consuming 746 watts (1 HP) and as soon as you start spinning that motor's shaft a little faster (with say a gasoline motor coupled to the shaft) it will start to generate electricity and feed it back to the grid and any other loads connected. This is a great and legal way to make your meter stop or even reverse.

Rob

Someone asked:


How can I  estimate roughly the maximum no load speed when impeller diamater and the net head are known.


No Load RPM= (19.1)((SQRT(64 H))/D)

Where H= Head in feet D= impeller diameter in feet



More often, you would know the full load normal operating speed of the generator to produce 60Hz from the name plate or from the number of poles. Also the head is fixed and known. So you'll want to know what the impeller diameter should be for a direct coupled setup:


Impeller Diameter in inches =(230)((SQRT(64 H))/R)


Where H = head in feet, R = No Load RPM OR 2X name plate RPM and SQRT = Square root