FUELLESS CAR PROTOTYPE by ISMAEL MOTOR

[kEhYo77]

@ Anyone interested in playing with this, here is a little bit of ArduinoUNO code for my Coil Shorting Module to do its thing.
One just needs to hook up 4 pots to analog input pins 1-4; pin 10 is the output to the CSM; pin 2,5 input from zero crossing detector (from Schmitt trigger)

/////////////////////////////////////////////////////////////////// COIL SHORTING v1.0 /////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// by kEhYo77@gmail.com ////////////////////////////////////////////////////////////////

const int plsPin = 5;                                                  // dedicated pin for using hardware counter to measure triggering frequency
const int csmPin = 10;                                               // signal pin output to control COIL SHORTING MODULE (CSM)
const int int0Pin = 2;                                                // dedicated pin for using hardware interrupt 0
const int delayPot = 1;                                              // potentiometer for setting the delay period before the shorting starts to occure
const int countPot = 2;                                              // potentiometer for setting the number of shorting pulses per trigger event
const int pulsePot = 3;                                              // potentiometer for setting the pulse width of shorting event
const int bemfPot = 4;                                               // potentiometer for setting the period to collect BEMF from the shorting event

unsigned int count;
unsigned int shtDelay = 0;                                       // time window delaying shorting sequence after zero crossing detection trigger
unsigned int shtPulse = 0;                                       // time window for coil shorting pulse width
unsigned int shtBEMF = 0;                                       // time window for BEMF recovery from shorting the coil
unsigned int shtCount = 0;                                       // number of shorting events per trigger
unsigned int frequency = 0;                                      // zero crossing detector triggering frequency from the hardware counter
unsigned int val = 0;                                                 // temp storage for value
unsigned int pot = 0;                                                // temp storage for pot value
volatile boolean pulseON = false;                            // variable that can be changed from within the interrupt function
 
//////////////////////////////////////////////////////////////////// INITIALISATION ////////////////////////////////////////////////////////////////////
 
void setup() {
   pinMode(csmPin, OUTPUT);                                   // preparing output pin for coil shorting module ON/OFF control
   digitalWrite(csmPin, LOW);                                   // CSM is OFF which means that the coil has 'OPEN' ends
   pinMode(plsPin, INPUT);                                       // preparing the pin for input
   digitalWrite(plsPin, HIGH);                                    // hardware counter setup for counting input pulses
   pinMode(int0Pin, INPUT);                                      // preparing the pin for input to trigger hardware interrupt 0
   
   bitClear(ADCSRA,ADPS0);                                     //  \
   bitClear(ADCSRA,ADPS1);                                    //   } running analog pot inputs with higher than normal speed clock (set prescale to 16)
   bitSet(ADCSRA,ADPS2);                                       //  /
   
   TCCR1A=0;                                                          // reset timer/counter control register & starting the clock counting pulses from pin 5 input
   getCount();                                                         // getting the value from the hardware trigger counter on pin 5
   
   attachInterrupt(0, trigger, RISING);                    // enables INT0 interrupt on Pin 2 input to execute CSM turn ON/OFF cycle
   
   Serial.begin(115200);                                         // send and receive through USB serial port at 9600 baud rate


////////////////////////////////////////////////////////////////////// MAIN  LOOP //////////////////////////////////////////////////////////////////////

void loop() {
   
   if (millis()%1000==0) {                                              // executed when a real time clock reaches full second (every second)
   
     frequency = getCount();                                              // triggering frequency readout from the hardware counter
   
     pot = analogRead(delayPot)/2;                                              // setting the delay time window of the coil shorting event
     if (pot==0 && shtDelay!=0) shtDelay=0;
     shtDelay = pot;
     
     pot = analogRead(countPot)/128;                                              // setting the pulse width of a coil shorting event
     if (pot==0 && shtCount!=0) shtCount=0;
     shtCount = pot;
   
     pot = analogRead(pulsePot)/64;                                              // setting the pulse width of a coil shorting event
     if (pot==0 && shtPulse!=0) shtPulse=0;
     shtPulse = pot;
     
     pot = analogRead(bemfPot)/32;                                              // setting the time window for BEMF recovery
     if (pot==0 && shtBEMF!=0) shtBEMF=0;
     shtBEMF = pot;
   }
     
   if (millis()%3000==0) { // executed every 3 seconds
     
     Serial.print("pulseCOUNT: ");
     Serial.println(shtCount);                                              // prints the shorting pulse count in serial monitor
     Serial.print("pulseWIDTH: ");
     Serial.println(shtPulse);                                              // prints the shorting pulse width
     Serial.print("windowBEMF: ");
     Serial.println(shtBEMF);                                              // prints the shorting pulse width for BEMF recovery
     Serial.print("tFREQUENCY: ");
     Serial.println(frequency);                                              // prints the triggering frequency
     Serial.println("");
   }
   
  //---------------------------------------------- executed X times whenever there was a trigger event ----------------------------------------------//


   if (shtPulse!=0 && shtBEMF!=0 && shtCount!=0 && pulseON) {    // do the shorting when every pot's value is bigger than 0 and trere was a trigger event


     for (int k=0; k<=shtDelay; k++){                                                      // time delay before the shorting event
       val = analogRead(0);                                                                        // 'blank' readout that takes 'some' time to execute
     }
 
     for (int j=1; j<=shtCount; j++){                                                         // do the shorting X times
        for (int i=0; i<=10; i++){                                                                 // do the coil shorting, output goes HIGH
           bitSet(PORTB, csmPin -8);                                                         // the quickest way to turn the output pin HIGH
             for (int x=0; x<=shtPulse; x++) {
             val = analogRead(0);                                                                  // 'blank' readout that takes 'some' time to execute
             }
           bitClear(PORTB, csmPin -8);                                                      // output goes LOW for a period of BEMF recovery value
             for (int x=0; x<=shtBEMF; x++) {
             val = analogRead(0);
             }
         }
     }
     pulseON = false;                                                        // ends shorting sequence, resets the trigger variable
   }
 
}

///////////////////////////////////////////////////////////////// End of the MAIN LOOP /////////////////////////////////////////////////////////////////


void trigger() {                                              // function executed at trigger event
   pulseON = true;
}


unsigned long getCount()  {                                              // returns the current count of pulses from pin 5, resets the count, and starts counting again 
   TCCR1B = 0;                                                           // Gate Off / Counter Tn stopped
   count = TCNT1;
   TCNT1 = 0;
   bitSet(TCCR1B ,CS12);                                           // Counter Clock source is external pin
   bitSet(TCCR1B ,CS11);                                          // Clock on rising edge
   bitSet(TCCR1B ,CS10);                                          // you can clear this bit for falling edge
   return count;
}

[WilbyInebriated]

You moron, I don't know jack shit about dynos but I have read by comments by people that I believe to be credible.

you mental midget... if you don't know jack shit about dynos (by your own admission) then there is no way for you to know if someone is "credible" when they speak of dynos...   again, tu  stultus es!

Let Ismael prove that the chassis dyno can be used.

NO. YOU are the uneducated dolt saying it can't be used... YOU PROVE YOUR CLAIM... the burden is not on ismael over the dyno, it is on you.

Do you believe that the test done at the Filipino DOT was legit and credible Wil-beast?

what i "believe" is none of your business you troll...

[MileHigh]

I stand by what I said and you can kiss my ass if you don't like it you slimy bitch.  You go to back to the cesspool Wil-beast you grotesque burping and farting little Chet-monster.

http://www.youtube.com/watch?v=IfggccwQrcY

Making you unhappy makes grovelling snotty little Wil-beast happy.

[konehead]

hey Mile too-high
The DOE lab doesnt rely on instinct to do measurements of input power in HP and watts at the wheels in Ismaels car.   

[MileHigh]

Konehead:

How much do you know about dynos?

More importantly, this is now the third time I am asking you about the input energy or the average input power measurement.  What is your response?

MileHigh