Arduino Manager Development for All

Ok take a look at this, so now if if the first “if” statement is true, will it now read the “else if” line of code after it while its happening?

#include <Servo.h> 
 
Servo myservo;  // create servo object to control a servo 
 
 //VG 02 Mixture Controller v0.2
//Craeted by Matt Ryder, Vulcan Gasifier LLC May 5, 2015
  //Last edit; May 12, 2015 

// These constants won't change:
const int O2SensePin = A1;    // pin that the O2 sensor is attached to
const int O2SwtPin = A2;   //Pin Auto Mode Switch is attached to
const int O2ManPin = A0; // Reads the O2 Manual Adjust Potentiometer on pin A1


const int threshold1 = 600;   //Threshold limits for rich gas condition
const int threshold2 = 640;   
const int threshold3 = 690;

const int target1 = 710;      // Target Parameter for rich condition
const int target2 = 700;      // Target Parameter for lean condition
const int target3 = 790;       // Target Paremeter for extream Lean condition

const int threshold4 = 720;    //Threshold limits for lean gas condition
const int threshold5 = 800;

int pos = 0;    // variable to store the servo position
int val;    // variable to read the value from the analog pin 
int lastpos = val;     // variable to store the servo last position
int O2SwticthState = 0;         // variable for reading the Fuel Mixer Mode status

void setup() 
{ 
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object 



      // Need to create a set point for servo start position after manual tuning
  {
  val = analogRead(O2ManPin);  // reads the value of the potentiometer (value between 0 and 1023) 
  val = map(val, 0, 1023, 20, 180);     // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                  // sets the servo position according to the scaled value 
  lastpos = val;                       // sets lastpos to equaul the position of the manually set position
  delay(10);                           // waits for the servo to get there 
 
  }
} 

void loop() 
{
    // read the state of the pushbutton value:
  O2SwticthState = digitalRead(O2SwtPin);
   // read the value of the O2 sensor:

   int sensorReading = analogRead(A1);

  if (O2SwticthState == LOW)
  {
  val = analogRead(O2ManPin);  // reads the value of the potentiometer (value between 0 and 1023) 
  val = map(val, 0, 1023, 20, 180);     // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                  // sets the servo position according to the scaled value 
  lastpos = val;                       // sets lastpos to equaul the position of the manually set position
  delay(10);                           // waits for the servo to get there 
  
  }
    else 
    {
         
         delay (10);
    
 
  }
   if  (sensorReading <= threshold1)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        
         myservo.write (lastpos + 10); // Moves servo negative 1 degrees

         // now we need to save that last position value 
         lastpos = lastpos +10;
         
         delay(10); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }
    else if (sensorReading >= target1);
         myservo.write (lastpos);
         delay (50);
         
   if  (sensorReading <= threshold2)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        
         myservo.write (lastpos + 2); // Moves servo negative 1 degrees

         // now we need to save that last position value 
         lastpos = lastpos +2;
         
         delay(10); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }
    else if (sensorReading >= target1);
         myservo.write (lastpos);
         delay (50);
         
    if  (sensorReading <= threshold3)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        
         myservo.write (lastpos + 1); // Moves servo negative 1 degrees

         // now we need to save that last position value 
         lastpos = lastpos +1;
         
         delay(200); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }
    else if (sensorReading >= target1);
         myservo.write (lastpos);
         delay (100);
         
   if  (sensorReading > threshold4)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        
         myservo.write (lastpos - 1); // Moves servo negative 1 degrees
         
         // now we need to save that last position value 
         lastpos = lastpos -1;
         delay(200);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }
    else if (sensorReading <= target2);
         myservo.write (lastpos);
         delay (100);

   if  (sensorReading > threshold5)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        
         myservo.write (lastpos - 1); // Moves servo negative 1 degrees
         
         // now we need to save that last position value 
         lastpos = lastpos -1;
         delay(100);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }
    else if (sensorReading <= target3);
         myservo.write (lastpos);
         delay (50);
}

No. Just the opposite. It is like a series of sieves maybe like a grain sorter. I can’t think of a better example offhand so im running with it. (I will look over the code in a few minutes, but this needed a separate explanation.)

while(grain !=NULL){
if(grain==too_big)
{toss grain;}
else if(grain==too_small)
{toss grain;}
else
{store grain}
get grain;
}

if it is too_big, it gets immediately tossed, there is no sense is testing for anything else, it gets the next piece of grain, and goes back to the top;

If it is too_small… First it checks to see if it is too_big, which it isn’t, then it checks to see if it is too_small, which it is, so it tosses it. gets the next piece of grain and heads to the top.

If it is the right_size, then it checks too_big, then too_small, both are false then it has to assume it is the correct size so it stores it. then it gets the next piece of grain and goes back to the top

(at the top of the loop, it checks to make sure there is a piece of grain, if there isn’t it exits the loop.)


If you want something where the first thing is true, then check for another condition you nest them.
if(condition==true)
{
if(secondcondition==true)
{ print “first and second condition are true”;}
else
{ print “first condition is true, second condition is false”;}
}else{
if(secondcondition==true)
{ print “first condition is false, and second condition is true”;}
else
{ print “first condition is false, second condition is false”;}
}

Do I need to use an “else” statement? What if I were to just make all If statements? As long as my second “if” statement is within the brackets it will look at both?

   if  (sensorReading <= threshold1)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        
         myservo.write (lastpos + 10); // Moves servo negative 1 degrees

         // now we need to save that last position value 
         lastpos = lastpos +10;
         
         delay(10); // Delay time between 10 degree movments
                                   // Decreasing the number = slower response time
             if (sensorReading >= target1);
         myservo.write (lastpos);
         delay (50);   
   }

No you don’t need an else, it is optional. I forgot to put that in the last post to be honest. :slight_smile:

Very cool, thank you for your input and excellent help with this. I re written the code and will try this again this weekend when we get another batch of fuel to run. :fire:

What does
if (O2SwticthState == LOW)
actually check for? on or off condition?

Here i simplified it a little bit. but I really am not sure what to do with the targets. I left them out and put a delay at the end, but it probably needs more delay…I have a feeling the O2 sensor doesn’t change values that fast. I am guessing it is more along the lines of 1 second, which would be 1000 of the milliseconds.


#include  
 
Servo myservo;  // create servo object to control a servo 
 
 //VG 02 Mixture Controller v0.2
//Craeted by Matt Ryder, Vulcan Gasifier LLC May 5, 2015
  //Last edit; May 12, 2015 

// These constants won't change:
const int O2SensePin = A1;    // pin that the O2 sensor is attached to
const int O2SwtPin = A2;   //Pin Auto Mode Switch is attached to
const int O2ManPin = A0; // Reads the O2 Manual Adjust Potentiometer on pin A1


const int threshold1 = 600;   //Threshold limits for rich gas condition
const int threshold2 = 640;   
const int threshold3 = 690;

const int target1 = 710;      // Target Parameter for rich condition
const int target2 = 700;      // Target Parameter for lean condition
const int target3 = 790;       // Target Paremeter for extream Lean condition

const int threshold4 = 720;    //Threshold limits for lean gas condition
const int threshold5 = 800;

int pos = 0;    // variable to store the servo position
int val;    // variable to read the value from the analog pin 
int lastpos = val;     // variable to store the servo last position
int O2SwticthState = 0;         // variable for reading the Fuel Mixer Mode status

void setup() 
{ 
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object 



      // Need to create a set point for servo start position after manual tuning
  {
  val = analogRead(O2ManPin);  // reads the value of the potentiometer (value between 0 and 1023) 
  val = map(val, 0, 1023, 20, 180);     // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                  // sets the servo position according to the scaled value 
  lastpos = val;                       // sets lastpos to equaul the position of the manually set position
  delay(10);                           // waits for the servo to get there 
 
  }
} 
   
void loop() 
{
    // read the state of the pushbutton value:
  O2SwticthState = digitalRead(O2SwtPin);
   // read the value of the O2 sensor:

   int sensorReading = analogRead(A1);

  if (O2SwticthState == LOW)
  {
  val = analogRead(O2ManPin);  // reads the value of the potentiometer (value between 0 and 1023) 
  val = map(val, 0, 1023, 20, 180);     // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                  // sets the servo position according to the scaled value 
  lastpos = val;                       // sets lastpos to equaul the position of the manually set position
  delay(10);                           // waits for the servo to get there 
  
  }
    else 
    {
         
         delay (10);
    
 
  }
  
  
   if  (sensorReading <= threshold1)
  {
         // we need to move the servo 10 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
         lastpos = lastpos +10;
         myservo.write (lastpos); // Moves servo negative 1 degrees

   
         
         delay(10); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }        
 else  if  (sensorReading <= threshold2)
  {
         // we need to move the servo 2 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos +2;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         
         delay(10); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }
    else if  (sensorReading <= threshold3)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
         lastpos = lastpos +1;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         
         delay(200); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }
    else if  (sensorReading > threshold4)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos -1;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         delay(200);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }
    else if  (sensorReading > threshold5)
  {
         // we need to move the servo 2 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos -2;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         delay(100);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }
    else {
         delay (50);
         }
}



 <\code><\pre>

Yes the Switch state is for switching from a manual pot mode to the 02 sensor mode. It needs to read the position of the potentiometer before entering the loop. When you start the machine its just easier to use the pot to get things tuned when starting up. Starting on 100% gas is no problem with it this way.

ok I got ya.

The targets are to stop the code from over shooting. But maybe with it written like this it will react a bit faster and they won’t be needed. I’ll load this up and give it whirl too.

How did you get the code to upload so nicely in the box?.. :slight_smile: my post looks like crap… and I am not sure exactly what it ate up…

after you paste it, high lite it and then hit Ctrl+K

#include <Servo.h> 
 
Servo myservo;  // create servo object to control a servo 
 
 //VG 02 Mixture Controller v0.2
//Craeted by Matt Ryder, Vulcan Gasifier LLC May 5, 2015
  //Last edit; May 12, 2015 

// These constants won't change:
const int O2SensePin = A1;    // pin that the O2 sensor is attached to
const int O2SwtPin = A2;   //Pin Auto Mode Switch is attached to
const int O2ManPin = A0; // Reads the O2 Manual Adjust Potentiometer on pin A1


const int threshold1 = 600;   //Threshold limits for rich gas condition
const int threshold2 = 640;   
const int threshold3 = 690;

const int target1 = 710;      // Target Parameter for rich condition
const int target2 = 700;      // Target Parameter for lean condition
const int target3 = 790;       // Target Paremeter for extream Lean condition

const int threshold4 = 720;    //Threshold limits for lean gas condition
const int threshold5 = 800;

int pos = 0;    // variable to store the servo position
int val;    // variable to read the value from the analog pin 
int lastpos = val;     // variable to store the servo last position
int O2SwticthState = 0;         // variable for reading the Fuel Mixer Mode status

void setup() 
{ 
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object 



      // Need to create a set point for servo start position after manual tuning
  {
  val = analogRead(O2ManPin);  // reads the value of the potentiometer (value between 0 and 1023) 
  val = map(val, 0, 1023, 20, 180);     // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                  // sets the servo position according to the scaled value 
  lastpos = val;                       // sets lastpos to equal the position of the manually set position
  delay(10);                           // waits for the servo to get there 
 
  }
} 
   
void loop() 
{
    // read the state of the pushbutton value:
  O2SwticthState = digitalRead(O2SwtPin);
   // read the value of the O2 sensor:

   int sensorReading = analogRead(A1);

  if (O2SwticthState == LOW)
  {
  val = analogRead(O2ManPin);  // reads the value of the potentiometer (value between 0 and 1023) 
  val = map(val, 0, 1023, 20, 180);     // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                  // sets the servo position according to the scaled value 
  lastpos = val;                       // sets lastpos to equal the position of the manually set position
  delay(10);                           // waits for the servo to get there 
  
  }
    else 
    {
         
         delay (10);
    
 
  }
  
  
   if  (sensorReading <= threshold1)
  {
         // we need to move the servo 10 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
         lastpos = lastpos +10;
         myservo.write (lastpos); // Moves servo negative 1 degrees

   
         
         delay(10); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }        
 else  if  (sensorReading <= threshold2)
  {
         // we need to move the servo 2 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos +2;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         
         delay(10); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }
    else if  (sensorReading <= threshold3)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
         lastpos = lastpos +1;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         
         delay(200); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }
    else if  (sensorReading > threshold4)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos -1;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         delay(200);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }
    else if  (sensorReading > threshold5)
  {
         // we need to move the servo 2 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos -2;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         delay(100);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }
    else {
         delay (50);
         }
         //might need a delay for the o2 sensor in general for everything to catch up.
         // delay (800);
}

It will react faster. It is skipping a bunch of delays and writes to the servo. It might be too fast. In the last one, i put a commented delay() in there just in case. It is better to try and slow the loop down in one spot.

Im looking at the delay time.
How many revs is this going to need to take effect? Which is clearing out the current pipeline and getting a valid new reading on the O2 sensor.

At 3600rpm, you are looking at 60 revs per second for a 4 cycle, that is 30 intakes per second, so 1000/30 == 33ms between intake cycles. I suspect it needs a couple strokes to clear it out, and a couple strokes to see if it is stable, and have an accurate O2 reading. It probably doesn’t make a lot of difference for running with the Pot, but it will turn into an issue with the O2 sensor.

Yes, when things are running along at or near where we want it to be, we just want the servo to just creep along making very minor adjustments at a time. However, if a sudden WOT event takes place we need to react much faster but we will want it to slow down once it gets close to our target parameters or it will over shoot.

If you watch the video at the point where I block of the intake to the gasifier you can see this faster reaction. When I block off the gasifier intake I am creating a lean condition and when I release its almost as if there is a WOT very rich condition. The way I was doing this was not messing with delay time but moving the servo more degrees at a time and using delay to check things.

1 Like

I will look at the video.
I was just wondering what the delay should be. I also need to re-add the "ideal"s back into the code since it needs that logic, before you go test or else it will probably run pretty rough. I will repost again, probably on friday unless that is not soon enough. . I don’t want to spam the forum. There might be one other small edit, which is really the wait.

No problem, we plan to test run Sat and Sunday. I will mess around with the other updated code as well.

Its really hard saying what the delays will need to be until you bench test and then do actual test. Any time you make changes like you said the faster the code can react or vs versa, I can play with this on the fly when we test again. :fire:

I would expand it a little however.
Abandon the governor.

Build a mixer carb with only 2 shutters for both mixture and speed control.
Let the controller controll the speed.
Furthermore I would scrap the ignition.
Let the Controller set timing too.

These things have come a long way since the days of the 6800HC-11 kits I played with in the 80s and 90s.
This Arduino is the best thing I have seen since sliced bread.

1 Like

Can you tap the ignition module to get the shaft speed sensor? I just thought of it so I haven’t poked around for it.

If I had all these toys available now when I was a kid, I don’t even know what I would be like. the raspi 2 at 35 bucks really would have changed my world. We couldn’t justify the 2-3k for the Apple.

I guess if its electric start you could you could use the ring gear sort of like a reluctor wheel, and the flywheel leading edge magnet as a trigger for the home position.

From those two references you could have a fairly tight feeling for crank angle.

These new generation kits like the raspberry and this arduino are much more friendly compared to the old Z80.
But it also reminds me how outdated I am.

Raise your hand if you owned an apple2, TRS80 or TI-99…

1 Like

I didn’t get time to do as much as I wanted, but this is should be quite a bit closer to what you intended.

#include <Servo.h> 
 
Servo myservo;  // create servo object to control a servo 
 
 //VG 02 Mixture Controller v0.2
//Craeted by Matt Ryder, Vulcan Gasifier LLC May 5, 2015
  //Last edit; May 12, 2015 

// These constants won't change:
const int O2SensePin = A1;    // pin that the O2 sensor is attached to
const int O2SwtPin = A2;   //Pin Auto Mode Switch is attached to
const int O2ManPin = A0; // Reads the O2 Manual Adjust Potentiometer on pin A1


const int threshold1 = 600;   //Threshold limits for rich gas condition
const int threshold2 = 640;   
const int threshold3 = 690;

const int target1 = 710;      // Target Parameter for rich condition
const int target2 = 700;      // Target Parameter for lean condition
const int target3 = 790;       // Target Paremeter for extream Lean condition

const int threshold4 = 720;    //Threshold limits for lean gas condition
const int threshold5 = 800;

int pos = 0;    // variable to store the servo position
int val;    // variable to read the value from the analog pin 
int lastpos = val;     // variable to store the servo last position
int O2SwticthState = 0;         // variable for reading the Fuel Mixer Mode status

void setup() 
{ 
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object 



      // Need to create a set point for servo start position after manual tuning
  {
  val = analogRead(O2ManPin);  // reads the value of the potentiometer (value between 0 and 1023) 
  val = map(val, 0, 1023, 20, 180);     // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                  // sets the servo position according to the scaled value 
  lastpos = val;                       // sets lastpos to equal the position of the manually set position
  delay(10);                           // waits for the servo to get there 
 
  }
} 
   
void loop() 
{
    // read the state of the pushbutton value:
  O2SwticthState = digitalRead(O2SwtPin);
   // read the value of the O2 sensor:

   int sensorReading = analogRead(A1);

  if (O2SwticthState == LOW)
  {
  val = analogRead(O2ManPin);  // reads the value of the potentiometer (value between 0 and 1023) 
  val = map(val, 0, 1023, 20, 180);     // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                  // sets the servo position according to the scaled value 
  lastpos = val;                       // sets lastpos to equal the position of the manually set position
  delay(10);                           // waits for the servo to get there 
  
  
  
  
   if  (sensorReading <= threshold1)
  {
         // we need to move the servo 10 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
         lastpos = lastpos +10;
         myservo.write (lastpos); // Moves servo negative 1 degrees

   
         
         delay(10); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }        
 else  if  (sensorReading <= threshold2)
  {
         // we need to move the servo 2 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos +2;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         
         delay(10); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }
    else if  (sensorReading <= threshold3)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
         lastpos = lastpos +1;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         
         delay(200); // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
                                   
  }   else if  (sensorReading < target1)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos + 1;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         delay(200);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }
  //we have to start with the largest one first, since the value tests true even for the smaller values too. 
      else if  (sensorReading > threshold5)
  {
         // we need to move the servo 2 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos -2;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         delay(100);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }
      else if  (sensorReading > threshold4)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos -1;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         delay(200);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }
     else if  (sensorReading > target3)
  {
         // we need to move the servo 1 degrees in the POSITIVE
         // direction so we need to add ADD to the last known 
         // position.
        lastpos = lastpos -1;
         myservo.write (lastpos); // Moves servo negative 1 degrees
         delay(200);  // Delay time between 1 degree movments
                                   // Decreasing the number = slower response time
  }


    else {
          //we were between the target values so we just wait. 
         delay (100);
         }
         //might need a delay for the o2 sensor in general for everything to catch up.
         // delay (400);


//end of if() read o2 pot
}
    else 
    {
         //delay waiting for pot
         delay (400);
    
 
  }
}

I had a z80, it was the first machine I ever bought (50 bucks + plus a small crate guitar amp) But it was well used, and outdated by the time I got it. It had procomm and a 300 baud modem so I was good to go. I could get to gopher, archie, veronica… muds, mushes, and bbs’s, irc, etc. I got it before netscape existed. :smile:

I used all those plus the macintosh, kaypro’s, osbournes, etc when I was a kid. It was whatever you could get time on. :slight_smile:

Both the Pi and the Arduino are nice low budget machines with a lot of features.

It just depends on whether you want a microcontroller or a general purpose computer. The lines get blurred, because the Pi also has the SPI, I2C, PWM, and GPIOs (not as many), that the Arduino has and the traditional PC (Intel, powerpc,sparc, etc.) platforms never had. Plus it has the normal computer things like HDMI, USB, ethernet, etc. The traditional Intel chip doesn’t do all of that.

They get blurred even more because in a lot of traditional microcontroller applications the potential delay from not using a real time OS, doesn’t really make any difference because of the faster speed of the General purpose chip.

This application is a great example. It doesn’t really matter if you are a couple of milliseconds off trying to correct the valves, however, if you start adding a crankshaft sensor, and controlling the ignition timing, then certainly a microcontroller is a much better choice.

1 Like