Serial Port to Ethernet converter (Software)

Description of Serial to Ethernet converter: Serial to Ethernet Converter facilitates access to any serial port device connected to a local computer/device from any remote location and the remote computer will treat this device as if it was physically connected to its serial port. Here there is no need for installation of additional software. You can share more than 500 serial port devices over TCP/IP network without any restriction. These created ports can also be accessed simultaneously.

How to use Serial to Ethernet converter: You start with the installation of the software on all the computers that will use the serial device. By doing this, the serial device will be made available over the Ethernet to you and every other person who is going to use the serial device.

Serial to Ethernet Converter enables conversion of COM port data to Ethernet. These converted data can in turn be shared and accessed over network. Here the remote computer will display a virtual serial connection that helps the software communicate with the port.

A noteworthy feature of Serial to network converter is that it runs as a Windows service. This guarantees that every single connection is automatically reconfigured on system reboot. This is a feature I found interesting because you don’t need to keep the interface constantly open, it will be running in the background. The other fantastic thing about Serial to Ethernet Converter is the ability to transfer a configuration to another computer in form of backup.

It is available for Windows and Linux platform. It is also interesting that you have the flexibility to decide which platform will be the server and which will be the client. However, the Linux version available now is a command-line solution. It can as well broadcast over UDP too.

Hardware Solutions that can convert serial port to Ethernet:

#include<LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  // sets the interfacing pins

void setup()
{
 lcd.begin(16, 2);  // initializes the 16x2 LCD
}

void loop()
{
  lcd.setCursor(0,0);           //sets the cursor at row 0 column 0
  lcd.print("16x2 LCD MODULE"); // prints 16x2 LCD MODULE
  lcd.setCursor(2,1);           //sets the cursor at row 1 column 2
  lcd.print("HELLO WORLD");     // prints HELLO WORLD
}

About the program.

Library function “LiquidCrystal.h” is used for displaying the desired characters on the LCD module. It is readily available with the Arduino user interface and it can be accessed through the “Import library” in the “sketch” tab in the main menu bar. The LiquidCrystal.h provides functions for almost all applications like printing a string, setting the cursor, initializing the LCD, scrolling the display etc.

Program for scrolling the display.

A simple program for scrolling a text on the LCD using arduino is shown here. This is done using the “scroll()” function. For example the function “lcd.scrollDisplayRight()” will scroll the display to right and the function”lcd.scrollDisplayLeft()” will scroll the display to left. A “for” loop is used for selecting the number of positions to scroll at a time. In the program shown below, it is chosen to be 2 because the text to be displayed is comparatively long. For shorter texts more number of positions must be scrolled at a time to get a smooth display.
#include <LiquidCrystal.h>
int i=0;

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()
{
 lcd.begin(16, 2);                              //initializes 16x2 LCD
 lcd.print("16x2 LCD MODULE JHD162A & ARDUINO-UNO"); //text to display
}

void loop()
{
  for(i=0;i<2;i++)
  {lcd.scrollDisplayLeft();}   //scrolls display left by two positions
  delay(800);                  //sets the speed at which display moves
}

#include<LiquidCrystal.h>
LiquidCrystal lcd(12,11,6,5,4,3);
int pwm=9;
int pot=A0;
float value=0;
int percent;
float rev=0;
int rpm;
int oldtime=0;
int time;

void isr() //interrupt service routine
{
rev++;
}

void setup()
{
lcd.begin(16,2);                //initialize LCD
attachInterrupt(0,isr,RISING);  //attaching the interrupt
}

void loop()
{
delay(1000);
detachInterrupt(0);           //detaches the interrupt
time=millis()-oldtime;        //finds the time 
rpm=(rev/time)*60000;         //calculates rpm
oldtime=millis();             //saves the current time
rev=0;
value=analogRead(pot);        //reads the speed control POT
value=value/4;
analogWrite(pwm,value);       //sets the desired speed
percent=(value/255)*100;      //finds the duty cycle %
lcd.clear();
lcd.setCursor(0,0);
lcd.print("___TACHOMETER___");
lcd.setCursor(0,1);
lcd.print(rpm);
lcd.print(" RPM");
lcd.print("   ");
lcd.print(percent);
lcd.print("%");
attachInterrupt(0,isr,RISING);

}

Notes :

The arduino board can be powered using a 9V supply through the external power jack.
The 5V needed at some parts of the circuit can be tapped from the 5V source on the arduino board.
The fan I used was rated 9V/100mA. The transistor 2N2222 can handle only upto 800mA. Keep this in mind while selecting the load.
The LCD module used was JHD162A.
POT R5 can be used to adjust the contrast of the LCD display. When connected first, the LCD may not show up anything. Adjust the R5 until you get the display. The optimum voltage at the wiper of R5 is between 0.4 to 1V.
The IR photo transistor and the IR diode both were taken from an LTH-1550 photo interruptor module.
The lateral surface of the photo transistor must be masked using a tape.

int pwm = 12; // assigns pin 12 to variable pwm
int pot = A0; // assigns analog input A0 to variable pot
int t1 = 0;   // declares variable t1
int t2 = 0;   // declares variable t2
void setup()  // setup loop
{
  pinMode(pwm, OUTPUT); // declares pin 12 as output
  pinMode(pot, INPUT);  // declares pin A0 as input
}
void loop()
{
  t2= analogRead(pot); // reads the voltage at A0 and saves in t2
  t1= 1000-t2;         // subtracts t2 from 1000 ans saves the result in t1
  digitalWrite(pwm, HIGH); // sets pin 12 HIGH
  delayMicroseconds(t1);   // waits for t1 uS (high time)
  digitalWrite(pwm, LOW);  // sets pin 12 LOW
  delayMicroseconds(t2);   // waits for t2 uS (low time)
}

Example :

The following example helps you to understand the stuff better.

Suppose the slider of the potentiometer is adjusted so that the voltage at its slider is 3V. Since the slider terminal is connected to  A0 pin, the voltage at A0 pin will be also 3V.  analogRead function in arduino   reads the voltage  (between  0 to 5V) at the analog input pin,converts it in to a digital value between 0 and 1023 and stores it in a variable.

Since the analog input voltage here is 3 volts the digital reading will be 3/(5/1023)  which is equal to 613. This 613 will be saved to variable t2 (low time). Then t2 is subtracted from 1000 and the result which is 387 is stored in variable t1 (high time). Then digital pin will be switched on for t1 uS and switched off for t2 uS and the cycle is repeated. The result will be a square wave with high time = 387 uS and low time = 613 uS and the time period will be always 1000uS. The duty cycle of this wave form will be (387/(387+613))*100 which is equal to 38.7%. The wave form will look something like what is shown below.



Motor speed control using arduino :

Circuit diagram of DC motor speed control using arduino is shown in the figure below. The working principle and program of this circuit is same as that of the LED brightness control. Only difference is that and additional motor driver circuit using a transistor is included in the circuit. Each digital pin of the arduino can sink or source only 40mA. DC motors usually consume much more than this and it is not safe to directly connect a heavy load to the digital pin.







In the circuit diagram, slider of the potentiometer is connected to analog input pin A0 of arduino. Resistor R1 limits the base current of the transistor Q1. Motor is connected as collector load to the transistor. Capacitor C1 by-passes voltage spikes and noises produced by the motor. This filter capacitor is very essential and if it is not there the circuit may not work properly.

Program :
int pwm = 12; // assigns pin 12 to variable pwm
int pot = A0; // assigns analog input A0 to variable pot
int t1 = 0;   // declares variable t1
int t2 = 0;   // declares variable t2
void setup()  // setup loop
{
  pinMode(pwm, OUTPUT); // declares pin 12 as output
  pinMode(pot, INPUT);  // declares pin A0 as input
}
void loop()
{
  t2= analogRead(pot); // reads the voltage at A0 and saves in t2
  t1= 1000-t2;         // subtracts t2 from 1000 ans saves the result in t1
  digitalWrite(pwm, HIGH); // sets pin 12 HIGH
  delayMicroseconds(t1);   // waits for t1 uS (high time)
  digitalWrite(pwm, LOW);  // sets pin 12 LOW
  delayMicroseconds(t2);   // waits for t2 uS (low time)
}

Notes :

In both circuits shown above the arduino is supposed to be powered through the 9V external power input jack.
+5V supply for the potentiometer can be taken from the 5V regulator output on the arduino board.
The DC motor I used while testing was rated 9V/100mA.
The LED I used while testing was a general purpose 4mm bright green LED.
The maximum collector current 2N2222 can handle is 800mA. Keep this in mind while selecting the motor.
Be very careful while handling the arduino board. Any wrong connections might damage the board

Difference between Conventional Antenna and Smart Antenna

Smart Antenna – Functions

Types of Smart Antennas

Advantages

• Both beam smart and adaptive arrays provide high efficiency and thus high power for the desired signal. When a large number of antenna elements are used at a higher frequency, Beam Smart antennas use narrow pencil beams. Thus high efficiency is obtained in the direction of the desired signal. If a fixed number of antenna elements are used the same amount times the power gain will be produced with the help of adaptive array antennas.
• Another advantage is in the amount of interference that is suppressed. Beam smart antennas suppress it with the narrow beam and adaptive array antennas suppress the interference by adjusting the beam pattern.

Disadvantages

• Cost

• Size

• Diversity

• Tracking
• Spatial-temporal processing
• Hooks in international
• standards to include provisions for smart antennas
• Vertical integration

Program :

int t=0;
int vcc=A0; // sets analog input A0 as +5V source for LM35
int sensor=A1; // sets A1 as the sensor input
int gnd=A2; // sets analog input A2 as ground for LM35
float temp;
float tempc;
float tempf;
void setup()
{
  pinMode(vcc,OUTPUT);
  pinMode(gnd,OUTPUT);
  pinMode(sensor,INPUT);
  digitalWrite(vcc,HIGH); // sets analog input A0 HIGH
  digitalWrite(gnd,LOW);  // sets analog input A2 LOW
  Serial.begin(9600);     // sets the baud rate at 9600

}
void loop()
{ delay(2000); // calls a 2 second delay
  t=t+2;       // increments the time by 2 every two seconds
  temp=analogRead(sensor); // reads the LM35 output
  tempc=(temp*5)/10;       // converts the digital value into temperature degree C
  tempf=(tempc*1.8)+32;    // converts degree C to degree F
  Serial.println("...............");
  Serial.println("Temperature logger");
  Serial.print("Time in sec = ");  // prints the time on serial monitor window
  Serial.println(t);
  Serial.print("Temperature in deg C = "); // prints the temperature in degreeC
  Serial.println(tempc);
  Serial.print("Temperature in deg F = "); // prints the temperature in degreeF
  Serial.println(tempf);
}

About the program :

The voltage output of LM35 is connected to the  analog input A1 of the arduino. The voltage at this pin will be proportional to the temperature and this voltage is read using analogRead function. The analogRead function will read the voltage (in a range 0 to 5) at a particular analog input pin and converts it into a digital value between 0 and 1023. For example, if 29°C is the temperature, the output of LM35 will be 290mV.  The result of the analogRead function will be 290mV/(5/1023) =59. There must be some way to convert this 59 to 29.0 for displaying in the serial monitor window. This is done by multiplying 59 by 5 and then dividing the result by 10. The result will be the temperature in °C and it is displayed using Serial.print function. Then it is converted to °F using the following formula: °F= (°C*1.8)+32. The temperature in °F is also displayed. The serial monitor can be accessed from the Tools tab in the arduino IDE. The shortcut for serial monitor is ctrl+shift+M. The snapshot of the serial monitor window is shown in the figure below.

int a;
int vin;
int input=A0;
int disp1=1;
int disp2=2;
int disp3=3;
int segA=5;
int segB=6;
int segC=7;
int segD=8;
int segE=9;
int segF=10;
int segG=11;
int segDP=12;
void setup()
{
pinMode(disp1, OUTPUT);
pinMode(disp2, OUTPUT);
pinMode(disp3, OUTPUT);
pinMode(segA, OUTPUT);
pinMode(segB, OUTPUT);
pinMode(segC, OUTPUT);
pinMode(segD, OUTPUT);
pinMode(segE, OUTPUT);
pinMode(segF, OUTPUT);
pinMode(segG, OUTPUT);
pinMode(segDP, OUTPUT);
pinMode(input,INPUT);
}
void loop()
{
vin=analogRead(input);
vin=vin/2.046;
a = vin%10;
if(a<=5)
{a=0;}
else
{a=5;}
digitalWrite(disp1,LOW);
digitalWrite(disp2,LOW);
digitalWrite(disp3, HIGH);
digitalWrite(segDP,HIGH);
display(a);
delay(5);
vin = vin/10;
a = vin%10;
digitalWrite(disp3,LOW);
digitalWrite(disp2,HIGH);
digitalWrite(segDP,HIGH);
display(a);
delay(5);
vin=vin/10;
a=vin;
digitalWrite(disp2,LOW);
digitalWrite(disp1,HIGH);
digitalWrite(segDP,LOW);
display(a);
delay(5);

}
int display (int a)
{
switch (a)
{
case 0:
digitalWrite(segA, LOW);
digitalWrite(segB, LOW);
digitalWrite(segC, LOW);
digitalWrite(segD, LOW);
digitalWrite(segE, LOW);
digitalWrite(segF, LOW);
digitalWrite(segG, HIGH);
break;

case 1:
digitalWrite(segA, HIGH);
digitalWrite(segB, LOW);
digitalWrite(segC, LOW);
digitalWrite(segD, HIGH);
digitalWrite(segE, HIGH);
digitalWrite(segF, HIGH);
digitalWrite(segG, HIGH);
break;

case 2:
digitalWrite(segA, LOW);
digitalWrite(segB, LOW);
digitalWrite(segC, HIGH);
digitalWrite(segD, LOW);
digitalWrite(segE, LOW);
digitalWrite(segF, HIGH);
digitalWrite(segG, LOW);
break;

case 3:
digitalWrite(segA, LOW);
digitalWrite(segB, LOW);
digitalWrite(segC, LOW);
digitalWrite(segD, LOW);
digitalWrite(segE, HIGH);
digitalWrite(segF, HIGH);
digitalWrite(segG, LOW);
break;

case 4:
digitalWrite(segA, HIGH);
digitalWrite(segB, LOW);
digitalWrite(segC, LOW);
digitalWrite(segD, HIGH);
digitalWrite(segE, HIGH);
digitalWrite(segF, LOW);
digitalWrite(segG, LOW);
break;

case 5:
digitalWrite(segA, LOW);
digitalWrite(segB, HIGH);
digitalWrite(segC, LOW);
digitalWrite(segD, LOW);
digitalWrite(segE, HIGH);
digitalWrite(segF, LOW);
digitalWrite(segG, LOW);
break;

case 6:
digitalWrite(segA, LOW);
digitalWrite(segB, HIGH);
digitalWrite(segC, LOW);
digitalWrite(segD, LOW);
digitalWrite(segE, LOW);
digitalWrite(segF, LOW);
digitalWrite(segG, LOW);
break;

case 7:
digitalWrite(segA, LOW);
digitalWrite(segB, LOW);
digitalWrite(segC, LOW);
digitalWrite(segD, HIGH);
digitalWrite(segE, HIGH);
digitalWrite(segF, HIGH);
digitalWrite(segG, HIGH);
break;

case 8:
digitalWrite(segA, LOW);
digitalWrite(segB, LOW);
digitalWrite(segC, LOW);
digitalWrite(segD, LOW);
digitalWrite(segE, LOW);
digitalWrite(segF, LOW);
digitalWrite(segG, LOW);
break;

case 9:
digitalWrite(segA, LOW);
digitalWrite(segB, LOW);
digitalWrite(segC, LOW);
digitalWrite(segD, LOW);
digitalWrite(segE, HIGH);
digitalWrite(segF, LOW);
digitalWrite(segG, LOW);
break;
}}

About the program.

The analog voltage applied to analog input pin A0 is read using analogRead function. The digital equivalent on the analog input voltage is stored in variable vin. For example  if 2.5V is the analog input, then the data loaded into variable “vin” after analogRead will be 2.5V/4.8mV= 511. The digital value in variable “vin” is divided by2.056 in order to make a 0 t0 500 swing in the digital reading corresponding to the 0 to 5V swing in the input voltage. The variable “vin” is over written by the result of the division. The next job of the program is to display the number in the variable “vin”.

For that each digit in the variable “vin” is isolated and displayed on the appropriate segments. For example, if 256 is the number in “vin”, then 2 is displayed on display 1, 5 is displayed on display 2 and 6 is displayed on display 3. A small delay of around 5 mS is given in between switching of the segments. This is done continuously and the observer feels like 256 due to persistence of vision.  Decimal point of the first display is also kept activated while switching the first segment. The individual digits are isolated and displayed by the following method.

Suppose 256 is the number to be displayed. Firstly modulus of 256 is determined using “%” operator and the result will be 6. Then it is stored in variable “a”. The the variable “a” is checked using the if statement. If “a” is less than five then “a” is overwritten by 0 and if “a” is greater than 5 it is over written by 5. This reduces the sensitivity of the voltmeter but makes the third digit stable. Then the third display is switched ON and other displays are held OFF. Then the function “display” for displaying 6 is called. The result will be 6 displayed on the third display. Then a delay of 5 ms is called.

After this delay, 256 is divided by 10 and variable “vin” is overwritten by the quotient which is 25. Then the modulus of 25 is determined. The modulus of 25 is 5 and it is stored in variable a. The second display is activated and the other displays are deactivated. Then the function display is called again. The result will be 5 displayed on the second display. A delay of 5 mS is called again.

Then the number 25 in variable “vin” is divided by ten again. The quotient of the operation will be 2. This 2 is overwritten to variable “vin”. Then the variable “vin” is copied to variable a .The first display is activated and the other displays are deactivated. The decimal point of the first display is also activated. Then the display function is called again. The result will be the digit 2 displayed on the third display. A delay of 5 mS is called again and the entire cycle is repeated.

The function display is implemented using conditional branching based on “switch” and “break” statements. Whenever the “display” function is called it will output the segment drive pattern for the current digit in variable “a” on the digital output pins (5 to 12). This is done by checking the current digit in variable “a” and jumping to the appropriate case. Suppose 6 is the digit in variable “a”. Then the statement  “switch(a)” will make the program to jump to “case:6″ which will result in writing the segment drive pattern of 6 on the digital output pins ( 5 to 12) appropriately.

LCD version of the arduino voltmeter.

This is just an LCD version of the voltmeter shown above. JHD162A is the LCD display used here. It is a 16×2 LCD display with back light. The circuit diagram of the LCD voltmeter using arduino is shown in the figure below.

Circuit diagram.







Program.


#include<LiquidCrystal.h>
int vin=A0;
float value;
LiquidCrystal lcd(12,11,5,4,3,2); //library initialization
void setup()
{
  pinMode(vin,INPUT);
  lcd.begin(16,2);
  lcd.setCursor(1,0);
  lcd.print("LCD VOLTMETER");
}
void loop()
{
value=analogRead(vin);
value=value/200;
value=value*0.978;
lcd.setCursor(3,1);
lcd.print(value);
lcd.print(" volts");
delay(300);
}