MKS 901p

Every fusor and fusion system seems to need a vacuum. This area is for detailed discussion of vacuum systems, materials, gauging, etc. related to fusor or fusion research.
Jerry Biehler
Posts: 727
Joined: Tue Nov 24, 2009 8:08 am
Real name:
Location: Beaverton, OR

Re: MKS 901p

Post by Jerry Biehler » Mon Jul 24, 2017 8:08 am

Ah, ok, it looked like you soldered onto the pins.

The reason it bounces between 750/760 is probably just because of the resolution of the ADC inside the unit. Don't worry about it.

Code: Select all

#include <PID_v1.h>
#define ENCODER_DO_NOT_USE_INTERRUPTS
#include <Encoder.h>
#include <LiquidCrystalFast.h>

// initialize the library with the numbers of the interface pins
LiquidCrystalFast lcd(33, 32, 31, 30, 29, 28, 27);
         // LCD pins: RS  RW  EN  D4  D5  D6  D7
//Pressure Gauge Variables
const int numReadings = 10;
int readings[numReadings];      // the readings from the analog input
int indexr = 0;                  // the index of the current reading
int total = 0;                  // the running total
int average = 0;                // the average
int decade;
int exponent;
double torr;
float pa;
float volts;
float pressure;
float significand;
float x;
int error;
//Evap Controller Variables
const int chanA =  3;
const int chanB =  4;
const int chanC =  5;
const int chanD =  6;
const int buttonRight =  9;
const int buttonMid =  12;
const int ButtonLeft =  15;
Encoder knobLeft(13, 14);
Encoder knobMid(10, 11);
Encoder knobRight(7, 8);
int chanAvolt = A12;
int chanCvolt = A11;
int chanDvolt = A10;
int pressVolt = A8;
int pressIdent = A9;
int chanArem = A7;
int chanCrem = A6;
int chanDrem = A5;
int chanAfb = A4;
int chanCfb = A3;
int chanDfb = A2;
double SetpointA, InputA, OutputA;
double SetpointC, InputC, OutputC;
double SetpointD, InputD, OutputD;
PID PIDchanA(&InputA, &OutputA, &SetpointA,2,5,1, DIRECT);
PID PIDchanC(&InputC, &OutputC, &SetpointC,2,5,1, DIRECT);
PID PIDchanD(&InputD, &OutputD, &SetpointD,2,5,1, DIRECT);

void setup() {
    Serial.begin(9600);   
  // set up the LCD's number of rows and columns: 
  lcd.begin(24, 2);
  // Print a message to the LCD.
  lcd.print("hello, world!");
  analogWriteFrequency(3,40000);
  analogWriteFrequency(4,40000);
  analogWriteFrequency(5,40000);
  analogWriteFrequency(6,40000);
  pinMode(chanA, OUTPUT);
  pinMode(chanB, OUTPUT);
  pinMode(chanC, OUTPUT);
  pinMode(chanD, OUTPUT);
  pinMode(7, INPUT_PULLUP);
  pinMode(8, INPUT_PULLUP);
  pinMode(9, INPUT_PULLUP);
  pinMode(10, INPUT_PULLUP);
  pinMode(11, INPUT_PULLUP);
  pinMode(12, INPUT_PULLUP);
  pinMode(13, INPUT_PULLUP);
  pinMode(14, INPUT_PULLUP);
  pinMode(15, INPUT_PULLUP);
    //initialize the variables we're linked to
  InputA = analogRead(chanAfb);
  InputC = analogRead(chanCfb);
  InputD = analogRead(chanDfb);
  SetpointA = 100;
  SetpointC = 100;
  SetpointD = 100;

  //turn the PID on
  PIDchanA.SetMode(AUTOMATIC);
  PIDchanC.SetMode(AUTOMATIC);
  PIDchanD.SetMode(AUTOMATIC);
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:

  analogWrite(chanA, 51);
  analogWrite(chanB, 102);
  analogWrite(chanC, 153);
  analogWrite(chanD, 204);
  //Gauge loop
    // subtract the last reading:
  total= total - readings[indexr];         
  // read from the sensor:  
  readings[indexr] = analogRead(pressVolt); 
  // add the reading to the total:
  total= total + readings[indexr];       
  // advance to the next position in the array:  
  indexr = indexr + 1;                    

  // if we're at the end of the array...
  if (indexr >= numReadings)              
    // ...wrap around to the beginning: 
    indexr = 0;                           

  // calculate the average:
  average = total / numReadings;
  volts = average * .0097;   
  torr = pow(10,(1.667 * volts - 11.46));
  if torr 
  decade = floor(x);
  exponent = decade - 7;
  significand = pow(10,(x - decade));


  //Serial.println(x);  
  Serial.println(volts); 
  Serial.println(torr);
  //Serial.println(pressVolt);
  //Serial.println(decade); 
  //Serial.println(significand);
  if (volts >= 1.8 && volts <= 8.61) {
    lcd.setCursor(4, 1);
    // Print a message to the LCD.
    lcd.print("e");
    lcd.setCursor(0, 1);
    lcd.print(significand); 
    lcd.setCursor(5, 1);
    lcd.print(exponent);
    error = 0;
   lcd.setCursor(7, 1);
    lcd.print(" Torr");
  }
  
  
  else {
    if (volts > 8.61) {
      lcd.setCursor(0, 1);
      lcd.print(" Overrange     ");
      error = 1;
    }
    if (volts < 1.8 && volts > 0.5) {
      lcd.setCursor(0, 1);
      lcd.print(" Underrange     ");
      error = 0;
    }
    if (volts < 0.5) {
      lcd.setCursor(0, 1);
      lcd.print("Sensor Error   ");
      error = 1;
    }
  }
}
There is also this mess:

Code: Select all


#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(PIN_D0, PIN_B7, PIN_B3, PIN_B2, PIN_B0, PIN_B1);
const int numReadings = 10;
int readings[numReadings];      // the readings from the analog input
int index = 0;                  // the index of the current reading
int total = 0;                  // the running total
int average = 0;                // the average
int decade;
int inputPin = 9;
int exponent;
float torr;
float pa;
float volts;
float pressure;
float significand;
float x;
int error;
int state = HIGH;      // the current state of the output pin
int reading;           // the current reading from the input pin
int previous = LOW;    // the previous reading from the input pin
int state1 = HIGH;      // the current state of the output pin
int reading1;           // the current reading from the input pin
int previous1 = LOW;    // the previous reading from the input pin
// the follow variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long time = 0;         // the last time the output pin was toggled
long time1 = 0;         // the last time the output pin was toggled
long debounce = 200;   // the debounce time, increase if the output flickers
int state2 = HIGH;      // the current state of the output pin
int reading2;           // the current reading from the input pin
int previous2 = LOW;    // the previous reading from the input pin
long time2 = 0;         // the last time the output pin was toggled
int state3 = HIGH;      // the current state of the output pin
int reading3;           // the current reading from the input pin
int previous3 = LOW;    // the previous reading from the input pin
long time3 = 0;         // the last time the output pin was toggled
int state4 = HIGH;      // the current state of the output pin
int reading4;           // the current reading from the input pin
int previous4 = LOW;    // the previous reading from the input pin
long time4 = 0;         // the last time the output pin was toggled
int stateo = HIGH;      // the current state of the output pin
int readingo;           // the current reading from the input pin
int previouso = LOW;    // the previous reading from the input pin
long timeo = 0; 
int mvenab;
int pvenab;
int override = LOW;
int overridden = LOW;
void setup()
{
  // initialize serial communication with computer:
  Serial.begin(9600);   

  // initialize all the readings to 0: 
  for (int thisReading = 0; thisReading < numReadings; thisReading++)
    readings[thisReading] = 0;
  pinMode (PIN_F4, OUTPUT);  //Turbo Pump
  pinMode (PIN_F5, OUTPUT);  //Fore Pump
  pinMode (PIN_F0, OUTPUT);  //Main Valve
  pinMode (PIN_F1, OUTPUT);  //Probe Valve
  pinMode (PIN_D2, INPUT_PULLUP);  //Override Input
  pinMode (PIN_C7, INPUT_PULLUP);  //Main Valve Input
  pinMode (PIN_C6, INPUT_PULLUP);  //Probe Valve Input
  pinMode (PIN_D3, INPUT_PULLUP);  //Turbo In
  pinMode (PIN_D6, INPUT_PULLUP);  //Fore In
  pinMode (PIN_D1, INPUT_PULLUP);  //Mode Switch
  lcd.begin(24, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  // Print a message to the LCD.
  lcd.print("FP:   TP:   MV:   PV:");    

}

void loop() {
  reading = digitalRead(PIN_D3); // Turbo Control
  if (reading == HIGH && previous == LOW && millis() - time > debounce) {
    if (state == HIGH)
      state = LOW;
    else
      state = HIGH;
    time = millis();    
  }
  digitalWrite(PIN_F5, state); 
  previous = reading;
  reading1 = digitalRead(PIN_D6); // Fore Control
  if (reading1 == HIGH && previous1 == LOW && millis() - time1 > debounce) {
    if (state1 == HIGH)
      state1 = LOW;
    else
      state1 = HIGH;
    time1 = millis();    
  }
  previous1 = reading1; 
  digitalWrite(PIN_F4, state1);
  if (state == 0) {
    lcd.setCursor(10, 0);
    lcd.print(byte(0x95));
  }
  else {
    lcd.setCursor(10, 0);
    lcd.print(byte(0x94));
  }
  if (state1 == 0) {
    lcd.setCursor(4, 0);
    lcd.print(byte(0x95));
  }
  else {
    lcd.setCursor(4, 0);
    lcd.print(byte(0x94));
  }
  reading2 = digitalRead(PIN_D1); // Pressure Mode Switch
  if (reading2 == HIGH && previous2 == LOW && millis() - time2 > debounce) {
    if (state2 == HIGH) 
      state2 = LOW;

    else 
      state2 = HIGH;

    time2 = millis();    
  }
  previous2 = reading2; 
  

  // subtract the last reading:
  total= total - readings[index];         
  // read from the sensor:  
  readings[index] = analogRead(inputPin); 
  // add the reading to the total:
  total= total + readings[index];       
  // advance to the next position in the array:  
  index = index + 1;                    

  // if we're at the end of the array...
  if (index >= numReadings)              
    // ...wrap around to the beginning: 
    index = 0;                           

  // calculate the average:
  average = total / numReadings;
  volts = average * .0097;   
  if (state2 == 0)  torr = volts - 2.1249;
  else torr = volts - 2;
  x = torr - 1.5;
  decade = floor(x);
  exponent = decade - 7;
  significand = pow(10,(x - decade));


  //Serial.println(x);  
  Serial.println(volts); 
  Serial.println(average);
  //Serial.println(decade); 
  //Serial.println(significand);
  if (volts >= 1.8 && volts <= 8.5) {
    lcd.setCursor(4, 1);
    // Print a message to the LCD.
    lcd.print("e");
    lcd.setCursor(0, 1);
    lcd.print(significand); 
    lcd.setCursor(5, 1);
    lcd.print(exponent);
    error = 0;
    if (state2 == 0) {

    lcd.setCursor(7, 1);
    lcd.print(" Torr");
  }
  else {
    lcd.setCursor(7, 1);
    lcd.print(" mBar");
  }
  }
  else {
    if (volts > 8.5) {
      lcd.setCursor(0, 1);
      lcd.print(" Overrange     ");
      error = 1;
    }
    if (volts < 1.8 && volts > 0.5) {
      lcd.setCursor(0, 1);
      lcd.print(" Underrange     ");
      error = 0;
    }
    if (volts < 0.5) {
      lcd.setCursor(0, 1);
      lcd.print("Sensor Error   ");
      error = 1;
    }
  }

  if (volts < 6.5 && error == 0) pvenab = 1;
  else pvenab = 0;  
  if (volts < 6.5 && error == 0) mvenab = 1;
  else mvenab = 0;
  readingo = digitalRead(PIN_D2); // Overridee Switch
  if (readingo == HIGH && previouso == LOW && millis() - timeo > debounce) {
    if (stateo == HIGH) 
      stateo = LOW;   
    else 
      stateo = HIGH;    
    timeo = millis();    
  }
  previouso = readingo; 
  stateo = override;
  reading3 = digitalRead(PIN_C7); // Main Valve Switch
  if (reading3 == HIGH && previous3 == LOW && millis() - time3 > debounce) {
    if (state3 == HIGH) 
      state3 = LOW;   
    else 
      state3 = HIGH;    
    time3 = millis();    
  }
  previous3 = reading3; 
  //if (mvenab == 0 && override == 1) overridden = 1;
  if (override == HIGH || mvenab == 1) digitalWrite(PIN_F0, state3);
  else {
    digitalWrite(PIN_F0, LOW);
    state3 = 0;
  }
  reading4 = digitalRead(PIN_C6); // Probe Valve Switch
  if (reading4 == HIGH && previous4 == LOW && millis() - time4 > debounce) {
    if (state4 == HIGH) 
      state4 = LOW;   
    else 
      state4 = HIGH;     
    time4 = millis();    
  }
  previous4 = reading4; 
  if (pvenab == 1) digitalWrite(PIN_F1, state4);
  else {
    digitalWrite(PIN_F1, LOW);
    state4 = 0;
  }
  if ( state3 == HIGH && override == LOW) {
    lcd.setCursor(16,0);
    lcd.print(byte(0x3D));
  }
  else {
    if (state3 == HIGH && mvenab == 1) {
      lcd.setCursor(16,0);
      lcd.print(byte(0x88));
    }
    else {
      lcd.setCursor(16,0);
      lcd.print(byte(0x8D));
    }
  }
  if (state4 == HIGH) {
    lcd.setCursor(22,0);
    lcd.print(byte(0x3D));
  }
  else {
    lcd.setCursor(22,0);
    lcd.print(byte(0x8D));
  }


  delay(50);
}




Bruce Meagher
Posts: 72
Joined: Fri May 13, 2011 3:25 am
Real name: Bruce Meagher
Location: San Diego

Re: MKS 901p

Post by Bruce Meagher » Mon Jul 24, 2017 8:12 am

Pablo,

Like Richard mentioned above just start with a cheap voltmeter (like the free ones we get at Harbor Freight). Nothing fancy required. What voltage do you measure on the analog output at atmosphere? One thing to note is that these gauges often read high (inaccurate) at atmosphere (close to 9V). I’d then recommend connecting the gauge to your chamber and pumping on it. Just watching the voltage will give you a reasonable idea if the gauge’s analog output has been set to emulate a different type of gauge by the previous owner (explained in the manual).

If you’ve been able to create a nice plasma ball then I’d expect the gauge’s analog output to be approximately 4V - 5V if it’s set to the factory default curve.

If you’re determined to start with the Arduino then having your program calculate and display the pressure will just make it harder to determine if the gauge is working properly. I would think the 750 Torr vs 760 Torr you're currently seeing ’s just your program reading between two ADC values. Printing the raw ADC values and hand calculating the voltages might be instructive. Measuring the voltage with a voltmeter at the divider should also be instructive. What you do not want to do is set constants in your code to match what you believe the pressure should be at atmosphere.

You can also use an inexpensive serial to USB adaptor to connect the serial link on the gauge to your Mac’s USB port (you could even jumper between the gauge and USB/Serial adaptor cable to test it without making a proper cable). This is assuming you have the RS-232 version. With OSX's Terminal app and the “screen" command you should be able to directly connect to the gauge and issue commands digitally over the serial port. Or just use one of the Arduino’s serial ports.

Bruce

Jerry Biehler
Posts: 727
Joined: Tue Nov 24, 2009 8:08 am
Real name:
Location: Beaverton, OR

Re: MKS 901p

Post by Jerry Biehler » Mon Jul 24, 2017 8:57 am

The arduino's serial is ttl level so you will have to add in a MAX3232 (assuming 3.3v). You will need one of these: https://www.sparkfun.com/products/11189

User avatar
Richard Hull
Site Admin
Posts: 10515
Joined: Fri Jun 15, 2001 1:44 pm
Real name: Richard Hull

Re: MKS 901p

Post by Richard Hull » Mon Jul 24, 2017 6:42 pm

Your oscillation between 750 and 760 could be the Arduino's 10 bit resolution limit over the 0-9v range of the sensor. I would check it with a voltmeter and see what the wiggle is on voltage at atmosphere. If it is a resolution problem, then once in the low range of fusor pressures, you might have accuracy issues. You could get better resolution if you limit the Arduino to the voltage from a much narrower span of the decade voltages from 9 volts to say 2 or 3 volts in the 0-9v range of interest for fusor work.

Finally, 1% resistors are very common and inexpensive now. However, why fiddle with such a divider? Use two 1% resistors where the division point is say 4.8 volts and then insert a modern 10 turn pot in the middle of an appropriate ohmic span and put 9.000 volts on the divider and turn the pot until its wiper reads 5.000 volts. This should eliminate any error to the limit of the sensor and your ability to supply and read accurately 9.000 and 5.000 volts in the adjustment phase. Heck, you could probably just get a 10 or 20 turn pot of about 10k and ground one end and put 9.000 v on the other and tune it to 5.000 on the wiper. The elegance of the two resistor one pot solution offered up first is to be preferred.

Richard Hull

P.S. I posted late on this and others hit on the 10 bit resolution limit of the arduino. I did not see their posts. The updated divider idea and narrower reporting span is still a good one
Progress may have been a good thing once, but it just went on too long. - Yogi Berra
Fusion is the energy of the future....and it always will be
Retired now...Doing only what I want and not what I should...every day is a saturday.

Pablo Llaguno
Posts: 47
Joined: Sun Feb 05, 2017 11:00 pm
Real name: Pablo Llaguno

Re: MKS 901p

Post by Pablo Llaguno » Mon Jul 24, 2017 11:35 pm

Thanks for all the help, it is a lot to process, but I think that I will understand it one day.

My multimeter doesn't even read decimals, but connected to my gauge it displays 8volts. Tomorrow I'll go with a friend that has a nice digital voltmeter and test the gauge output Sadly we don't have harbor freight here, so I would prefer to order one from amazon (does someone has any recommendations for one?).

Bruce I totally agree that I should not set constants in my code to match what I believe is the pressure, that is why I am trying to fix the thing with my voltage divider. Also I didn't fully understand this part
You can also use an inexpensive serial to USB adaptor to connect the serial link on the gauge to your Mac’s USB port (you could even jumper between the gauge and USB/Serial adaptor cable to test it without making a proper cable). This is assuming you have the RS-232 version. With OSX's Terminal app and the “screen" command you should be able to directly connect to the gauge and issue commands digitally over the serial port. Or just use one of the Arduino’s serial ports.
I haven't read anything about the serial user interface, would you mind PM me about this? Thanks

Richard so you are saying that I might get better resolution if I set the voltage divider to a narrower span of voltage, instead of 0-5, something like 0-3? Also your solution for the voltage divider using a potentiometer is very clever, I never thought of that. I've never used turn potentiometers, just normal 10k potentiometers, could I use a 10k potentiometer and adjust it while reading the voltage with a voltmeter until I get 5.000 V?

User avatar
Richard Hull
Site Admin
Posts: 10515
Joined: Fri Jun 15, 2001 1:44 pm
Real name: Richard Hull

Re: MKS 901p

Post by Richard Hull » Tue Jul 25, 2017 5:38 pm

You seem to insist on using the Arduino with 10 bit resolution. Within the prgramming language, you can instruct the full 10 bits to examine only a much narrower range of voltages (span). this span might be where the gauge is looking at ouputing voltages far less than 9 volts or 7 volts, where the pressure is in the lower ranges within the fusor's operational range.

Thus, your Arduino would not even report a pressure until you were under 1 torr or even under 100 microns. Why do you need to accurately display 123 torr of 396 microns? They are without any value to you. It isn't until you hit 100 microns that you might really be interested in what pressure to have in the chamber. All of that upper end pressure is a waste of bits.

Some rather fancy preconditioning of the 9 v to 0 v signal may be required.

i am working on this.

Richard Hull
Progress may have been a good thing once, but it just went on too long. - Yogi Berra
Fusion is the energy of the future....and it always will be
Retired now...Doing only what I want and not what I should...every day is a saturday.

Rex Allers
Posts: 178
Joined: Sun Dec 30, 2012 8:39 am
Real name:
Location: San Jose CA

Re: MKS 901p

Post by Rex Allers » Tue Jul 25, 2017 8:54 pm

Using the ADC on an Arduino to read the pressure from these 901P sensors seems like a pain unless you enjoy the project. If you learn how to talk to the serial interface of the 901P, it will send back the pressure. I'm sure they spent a lot of time getting that result, that they send back, as accurate as possible.

If you have a good DVM then measuring the analog signal to see how things are working is an easy way to start.

If you want to talk serial, first check your part number to be sure it has an RS232 interface, not RS485. (It probably does.) Talking serial from the Arduino pins, the signals are inverted TTL so you need to get a little converter board. There are many on eBay. Try searching for 'rs232 to ttl board'. Some of these little boards come with a DB-9 connector mounted on them, but that would just complicate things for this application. There are also boards with just solder tabs that probably would be easier for this. Just now, I saw one listing from china with 5 boards for $1.15.

You will have to learn to use the serial drivers for the arduino and write some code to send commands and process the results. To start, you can print to the debug port and see that on a PC attached through the USB cable. Actually, for 1st pass learning you could probably wire a DB-9 connector and talk to the sensor with a PC or Mac, no Arduino. You may need a USB to Serial adapter to get a serial port on the PC. Then just use some kind of serial terminal program. On a PC, XP and below gave you Hyper Terminal. Win 7 and newer dropped Hyper Terminal but there are ways to get it back or use a different program. I'm not a Mac guy but there must be something similar.

I gave a 901 manual link earlier. That manual describes using the serial port on pages 9-11. Then pages 15 & 16 talk about reading the pressure with commands. Simplifying out possible complications you would do something like this:
Send: @253PR4?;FF
Receive: @253ACK1.230E-3;FF

It's probably good to learn to talk on the serial interface to the 901P in case you need to change some nonstandard configuration that it may have or to program something that might be useful like relay outputs.

So that's what I think I will do when I have time to try the 901P sensor that I bought but haven't tried yet.
Rex Allers

Pablo Llaguno
Posts: 47
Joined: Sun Feb 05, 2017 11:00 pm
Real name: Pablo Llaguno

Re: MKS 901p

Post by Pablo Llaguno » Wed Jul 26, 2017 12:09 am

Richard Hull wrote:You seem to insist on using the Arduino with 10 bit resolution. Within the prgramming language, you can instruct the full 10 bits to examine only a much narrower range of voltages (span). this span might be where the gauge is looking at ouputing voltages far less than 9 volts or 7 volts, where the pressure is in the lower ranges within the fusor's operational range.

Thus, your Arduino would not even report a pressure until you were under 1 torr or even under 100 microns. Why do you need to accurately display 123 torr of 396 microns? They are without any value to you. It isn't until you hit 100 microns that you might really be interested in what pressure to have in the chamber. All of that upper end pressure is a waste of bits.

Some rather fancy preconditioning of the 9 v to 0 v signal may be required.

i am working on this.

Richard Hull
Thanks Richard for the clarification, I didn't understand you at first. You are right, I don't need to accurately display 120 Torr, the best range for me would be from the lower micron end to 1 Torr, if possible, but the most important pressure range is when I hit 100 microns as you say. So let me ask once again, because I am not sure I understand you correctly, but what you are telling me is that I will be better with the Arduino reading a shorter span of voltage, instead of reading 0-9, I would be better by reading 0 - 6 volts, or even smaller spans?

Rex, my part number does indicate I have a RS232 interface. I just started learning Arduino this week, so if I want to go serial the best option would be to get that USB to RS232 adapter, page 9 on the manual shows how it should be wired. In Mac it is literally called terminal.

Jerry Biehler
Posts: 727
Joined: Tue Nov 24, 2009 8:08 am
Real name:
Location: Beaverton, OR

Re: MKS 901p

Post by Jerry Biehler » Wed Jul 26, 2017 12:16 am

The terminal app is a terminal for the OS, it is not a serial terminal. Download Zterm, that will talk to a serial port. You can set up macros with it to send the serial strings with a key combo, some devices will ignore manual typed in commands because it will time out if the time period between characters is too long.

Pablo Llaguno
Posts: 47
Joined: Sun Feb 05, 2017 11:00 pm
Real name: Pablo Llaguno

Re: MKS 901p

Post by Pablo Llaguno » Wed Jul 26, 2017 4:40 am

Jerry Biehler wrote:The terminal app is a terminal for the OS, it is not a serial terminal. Download Zterm, that will talk to a serial port. You can set up macros with it to send the serial strings with a key combo, some devices will ignore manual typed in commands because it will time out if the time period between characters is too long.
Thanks for the correction.

I don't even know where I got the idea of measuring the pressure with the ADC from the Arduino, I just thought it would work, I simply ignored the fact of the 10 bit resolution of the ADC and thought the voltage divider would do. So what I am going to do is check with the voltmeter, and then try to do some serial communication.

Thanks for the help,

Pablo

Post Reply