Analysis of the Effect of Vignetting on MIMO Optical Wireless Systems Using Spatial OFDM

Abstract—The performance of pixelated multiple-input multiple output optical wireless communication systems can be impaired by vignetting, which is the gradual fall-off in illumination at the edges of a received image. This paper investigates the effect of vignetting for a pixelated system using spatial orthogonal frequency division multiplexing (OFDM). Our analysis shows that vignetting causes attenuation and intercarrier interference (ICI) in the spatial frequency domain. MATLAB simulations indicate that for a given constellation size, spatial asymmetrically clipped optical OFDM (SACO-OFDM) is more robust to vignetting than spatial dc biased opticalOFDM (SDCO-OFDM).Moreover, for the case of SDCO-OFDM, the very large zeroth subcarrier causes severe ICI in its neighbourhood causing flattening of the bit error rate (BER) curves. We show that this BER floor can be eliminated by leaving some of the lower spatial frequency subcarriers unused. The BER performance can also be improved by applying a vignetting estimation and equalization scheme. Finally, it is shown that equalized SACO-OFDM with 16-QAM has the same overall data rate as equalized SDCO-OFDM using 4-QAM, but requires less optical power.

Block diagram of a spatial OFDM system

                     Illustration of a pixelated MIMO wireless communication system

IEEE PAPER :http://ieeexplore.ieee.org/xpl/articleDetails.jsp?tp=&arnumber=6681890&ranges%3D2014_2014_p_Publication_Year%26subscribed%3Dtrue%26queryText%3Dofdm



FULL MATLAB CODE AVAILABLE 

CONTACT FOR PROJECTS 

Read more »

Temperature controlled Water Pump using PIC16f877A and LM35

Automatic Garden Light And Water Pump

Maybe someone today need everything more easy and effective, included with their garden lamp at home. There are many garden lamp operated manually to turn-on and turn-off. Someone need to turn on in the night and turn off in the morning manually. Garden lamp can not work automatically, when condition is dark garden lamp will turn on and when condition is bright garden lamp will turn off automatically too.

I think it is very important in this day. Someone will not again confuse when they go to leave home who will turn on and turn off garden lamp. To take solution for this problem i think someone can use automatically garden lamp that can work automatically. Garden lamp will turn on when condition is dark, and garden lamp will turn off when condition is bright.

Components
PIC16F877A
This powerful (200 nanosecond instruction execution) yet easy-to-program (only 35 single word instructions) CMOS FLASH-based 8-bit microcontroller packs Microchip's powerful PIC® architecture into an 40- or 44-pin package and is upwards compatible with the PIC16C5X, PIC12CXXX and PIC16C7X devices. The PIC16F877A features 256 bytes of EEPROM data memory, self programming, an ICD, 2 Comparators, 8 channels of 10-bit Analog-to-Digital (A/D) converter, 2 capture/compare/PWM functions, the synchronous serial port can be configured as either 3-wire Serial Peripheral Interface (SPI™) or the 2-wire Inter-Integrated Circuit (I²C™) bus and a Universal Asynchronous Receiver Transmitter (USART). All of these features make it ideal for more advanced level A/D applications in automotive, industrial, appliances and consumer applications.

LDR LDR (or Light Dependant Resistor, or Photoresistor) is a variable resistor. Light falling on the sensor decreases its resistance.

Output: This module outputs 5v when the sensor receives no light (the circuit is open) and 0v when exposed to bright light (the circuit is closed). When connected to an input on the Arduino using the TinkerKit Shield, you can expect to read values from 0 to 1023.

Module Description: This module features a Light Dependent Resistor, a signal amplifier, the standard TinkerKit 3pin connector, a green LED that signals that the module is correctly powered and a yellow LED whose brightness changes according to the amount of lightness.

This module is a SENSOR. The connector is an OUTPUT which must be connected to one of the INPUT connectors on the TinkerKit Shield.

LM35
Description

The LM35 series are precision integrated-circuit temperature sensors, whose output voltage is linearly proportional to the Celsius (Centigrade) temperature. The LM35 thus has an advantage over linear temperature sensors calibrated in ° Kelvin, as the user is not required to subtract a large constant voltage from its output to obtain convenient Centigrade scaling. The LM35 does not require any external calibration or trimming to provide typical accuracies of ±¼°C at room temperature and ±¾°C over a full -55 to +150°C temperature range. Low cost is assured by trimming and calibration at the wafer level. The LM35's low output impedance, linear output, and precise inherent calibration make interfacing to readout or control circuitry especially easy. It can be used with single power supplies, or with plus and minus supplies. As it draws only 60 µA from its supply, it has very low self-heating, less than 0.1°C in still air. The LM35 is rated to operate over a -55° to +150°C temperature range, while the LM35C is rated for a -40° to +110°C range (-10° with improved accuracy). The LM35 series is available packaged in hermetic TO-46 transistor packages, while the LM35C, LM35CA, and LM35D are also available in the plastic TO-92 transistor package. The LM35D is also available in an 8-lead surface mount small outline package and a plastic TO-220 package.

Program 

#include<htc.h>

void initialize(void)

{

        TRISA0=1;

        TRISA1=1;

ADCS1 = 0; //select Fosc/8

ADCS0 = 1;

ADCON1=0; // A/D port configuration 0

ADFM = 1; //right justified result

ADON=1; // turn on the AD conversion module

}

/* return a 10-bit result */

unsigned int read_adc(unsigned char channel)

{

channel&=0x07; // truncate channel to 3 bits

ADCON0&=0xC5; // clear current channel select

ADCON0|=(channel<<3); // apply the new channel select

DelayMs(10);

ADGO=1; // initiate conversion on the selected channel

while(ADGO)continue;

return(((ADRESH&0x03)<<8)+ADRESL); // return the 10-bit result

}

void main(void)

{

long int temp,pres;

initialize();

while(1)

{

temp =read_adc(0)*((5.0*100.0)/1023.0);

               

if (temp>27)

{

PORTD=0x00;

}

else

{

Read more »

How to Set Up a Timer in PIC16F877A

We have Three Timers in PIC16F877A , and here we have a look to how to setup the TIMER0 in PIC16F877A using HiTech C programm 




• To set up the timer, one must first disable interrupts so that an interrupt doesn’t occur when the timer expires.
• Then, enable the timer and assign the prescaler to the timer.
• Establish the prescaler value, and finally, load the timer register.

 Whenever the timer expires, the T0IF bit in the INTCON register will be set.

• We must clear this bit, reload the timer register, and then execute the code that is to be done at this time.

In code, the setup portion might look something like:

########################## IN ASSEMBLY PROGRAM ###########################

banksel INTCON

bcf INTCON,T0IE ; Mask timer interrupt

banksel OPTION_REG

bcf OPTION_REG,T0CS ; Enable timer

bcf OPTION_REG,PSA ; Prescaler to timer

bcf OPTION_REG,PS2 ; \

bsf OPTION_REG,PS1 ; >- 1:16 prescale

bsf OPTION_REG,PS0 ; /

movlw D’100’ ; Timer will count

movwf TMR0 ; 156 (256-100) counts

######################## IN HITECH C PROGRAM #######################################

OPTION_REG= 0x0F;

  TMR0=0x0F;

  while(TMR0IF=0);

  TMR0IF=0;

##################################################

• Clearly, the individual bits in the option register could all be set with a single store.

• If we didn’t care about the RB0 interrupt, the weak pullups, or the transition of RA4, then instead of five bit manipulations we could have said:

• movlw B’10000011’ ; Set up prescaler and

• movwf OPTION_REG ; timer

The execution loop might look something like:

main:

    btfss INTCON,T0IF ; Did timer overflow?

    goto main ; No, hang around some more 

    movlw D’100’ ; Timer will count

    movwf TMR0 ; 156 (256-100) counts

    bcf INTCON,T0IF ; reset overflow flag

    call DoCode ; Execute main code

    goto main ; Go back and wait

Read more »

Using Timers in PIC16F877A

A timer counts pulses of a fixed, known frequency usually the system clock for the processor.Physically, timer is a register whose value is continually increasing to 255, and then it starts all over again: 0, 1, 2, 3,4...255....0,1, 2, 3......etc. 

This incrementing is done in the background of everything a microcontroller does.It is up to programmer to think up a way how he will take advantage of this characteristic for his needs.One of the ways is increasing some variable on each timer overflow.

 – If we know how much time a timer needs to make one complete round, then multiplying the value of a variable by that time will yield the total amount of elapsed time.

PIC16F877A has 3 timer modules, Timer0,Timer1 and Timer2.The device has three readable and writeable hardware timers that can increment automatically each instruction cycle (if no prescaler is used).All timers can cause an interrupt on overflow, and then restart from zero.

• Timer 0

timer/counter with prescale ,an 8-bit timer with an eight bit prescaler, which can make the timer run 2 to 256 times slower than normal

• Timer 1

timer/counter with prescale  a 16-bit timer (two 8-bit registers) with a 1:1 to 1:8 prescaler and some other features. Used by given C code to generate soft timer and sound

• Timer 2

timer only with prescale and postscale , an 8-bit timer with 1:1 to 1:16 prescaler and a 1:1 to 1:16 postscaler It also has a period register.Used by given C code for PWM motor control

Timer 0

• 8 bit timer/counter with prescaler
• Readable and writeable
• 8-bit software programmable prescaler
• Internal or external clock set
• Interrupt on overflow from 0xFF to 0x00
• Edge Select for external clock

use TMR0 in program in hitech-c  MPLAB X 

  OPTION_REG= 0x0F;

  TMR0=0x0F;

     while(TMR0IF=0);

       TMR0IF=0;

TIMER1

• 16-bit timer/counter with prescaler
• Readable and writeable
• 1, 2, 4, 8 programmable prescaler
• Internal or external clock select
• External clock can be syn. or asyn.
• Interrupt on overflow
• Second crystal permitted

use TMR1 in Hitech C Program 

    T1CON= 0x0F;

    TMR1= 0x0F;

    TMR1ON=1;

        while(TMR1IF=0);

          TMR1IF=0;

          TMR1ON=0;

TIMER2

8-bit timer/counter with prescaler and postscaler

• Readable and writeable

• 1,4 or 16 programmable prescaler

• 4-bit programmable postscaler

• Interrupt on overflow

• Output to port pin

Using Timer2 in Hitech C program

   T2CON= 0x0F;

    TMR2= 0x0F;

    TMR2ON=1;

       while(TMR2IF=0);

             TMR2IF=0;

            TMR2ON=0;

Read more »

Displaying a Word or String in an 16x2 LCD with PIC16F877A and MPLAB X

We have seen how to interface an LCD with PIC16F877A  . In this we are printing only a letter in the  LCD , now we are going to Display a string on the LCD  for this following steps are followed

First Create a MPLAB X project as in the steps for  Blinking a LED using MPLAB X , PIC16F877A

And check the  Interfacing LCD with PIC16F877A in MPLAB X  to know how to interface a LCD

Components
1.PIC16F877A micro controller
2. 2x16 LCD Display


we are using the following functions 

void delay(unsigned int msec) // Time delay function
void lcd_cmd(unsigned char item) // Function to send command to LCD
void lcd_data(unsigned char item) // Function to send data to LCD
void lcd_data_string(unsigned char *str) // Function to send data to string
void lcd(unsigned char str[10])

To display the string in  LCD , just call the below lines in main function

 lcd_cmd(0x01);
  lcd_cmd(0x86);
  lcd("STRING TO DISPLAY");

The functions are defined below 

void delay(unsigned int msec) // Time delay function
{
int i,j ;
for(i=0;i<msec;i++)
  for(j=0;j<1275;j++);
}

void lcd_cmd(unsigned char item) // Function to send command to LCD
{
dataport = item;
rs= 0;
rw=0;
en=1;
delay(1);
en=0;
return;
}

void lcd_data(unsigned char item) // Function to send data to LCD
{
dataport = item;
rs= 1;
rw=0;
en=1;
delay(1);
en=0;
return;
}

void lcd_data_string(unsigned char *str) // Function to send data to string
{
int i=0;
while(str[i]!='\0')
{
  lcd_data(str[i]);
  i++;
  //delay(10);
}
return;
}

void lcd(unsigned char str[10])
{
lcd_cmd(0x38);
lcd_cmd(0x0e);
lcd_data_string(str);
}

Read more »

ANALOG TO DIGITAL CONVERTION using PIC16F877A and MPLABX

Many electrical signals around us are Analog in nature. That means a quantity varies directly with some other quantity. The first quantity is mostly voltage while that second quantity can be anything like temperature, pressure, light, force or acceleration.

The PIC16F877A has a built-in Analogue to Digital converter. What ADC does is basically convert an analogue voltage ranging from -Vref to +Vref (usually 0V to 5V) and converts it to a binary value. The ADC on the PIC16F877A has 10-bit resolution and this provides 1024 steps (2^10=1024) which is more than enough for normal applications.

Programming ADC in HI-TECH C for MPLAB

ADC is connect to the PIC CPU by 3 control register and 2 data register. The control registers are used to setup and give commands to the ADC. They also provides the status of ADC. The two data registers holds the 10 bit of converted data. Since each resister in PIC18 is of 8 bits therefore 2 registers are required to hold the 10bit data.

We will develop two functions to support ADC in our projects. One will help initialize the module and other will help us select any of the 13 channels and start the conversion. After the conversion is done it will return us the results.

I am not giving here the description of the control and data registers as they are very clearly explained in PIC18F4520's datasheet on page 223 to 225. I request you to download the datasheet and read the description so that you will have an Idea of what every bit in the registers do. As I told before, ADC is connected to the CPU via three control register and two data registers. The three control registers are :-

• ADCON0 - Used to select analog input channel,start the conversion, check if the conversion is done and to switch on/off the module.(We use this in ADCRead() function.)

• ADCON1 - Used to Select Voltage reference, and to configure ports as Analog of digital. (We leave these to defaults)

• ADCON2 - Used to select ADC data format, Set acquisition time, ADC clock setup (We setup these in ADCInit() function)

First we configure the ADC to our needs in the ADCInit() function.

//Function to Initialise the ADC Module
void ADCInit()
{
   //We use default value for +/- Vref

   //VCFG0=0,VCFG1=0
   //That means +Vref = Vdd (5v) and -Vref=GEN

   //Port Configuration
   //We also use default value here too
   //All ANx channels are Analog

   /*
      ADCON2

      *ADC Result Right Justified.
      *Acquisition Time = 2TAD
      *Conversion Clock = 32 Tosc
   */

   ADCON2=0b10001010;
}

 

ADCRead function ...

//Function to Read given ADC channel (0-13)
unsigned int ADCRead(unsigned char ch)
{
   if(ch>13) return 0;  //Invalid Channel

   ADCON0=0x00;

   ADCON0=(ch<<2);   //Select ADC Channel

   ADON=1;  //switch on the adc module

   GODONE=1;  //Start conversion

   while(GODONE); //wait for the conversion to finish

   ADON=0;  //switch off adc

   return ADRES;
}

THE PROGRAM IS AVAILABLE ON GITHUB : https://github.com/ebine/

Read more »

Interfacing LCD with PIC16F877A in MPLAB X

Most of the embedded projects have some user interfaces, most of them uses LCD displays for output

Here we are going to see how to interface an 16x2 LCD with PIC16F877A

First Create a MPLAB X project as in the steps for  Blinking a LED using MPLAB X , PIC16F877A


Components
1.PIC16F877A micro controller
2. 2x16 LCD Display




Most of the  LCD have 16 Pins
3 Control Pins
8 Data Pins
4 Power Pins

Steps For Interfacing LCD 

1. Take two ports make one as input and other as output by loading 1 to TRIS register and 0 to TRIS respectively

             Step 1: Initialize the LCD.

          The LCD must be initialized the by following pre-defined commands of character LCD.

·         0x38, to configure the LCD for 2-line, 5x7 font and 8-bit operation mode

·         0x0C, for Display On and Cursor Off

·         0x01, to Clear Display screen

·         0x06, to increment cursor

·         0x80, to set cursor position at first block of the first line of LCD.

Step 2: Send the commands to LCD.

·         Send the command byte to the port connected to LCD data pins

·         RS=0, to select command register of LCD

·         RW=0, to set the LCD in writing mode

·         EN=1, a high to low pulse to latch command instruction

·         Delay of 1ms

·         EN=0

Step 3: Send data to LCD.

·         Send data at the port which connected to LCD data pins

·         RS=1, register select to select data register of LCD

·         RW=0, this set the LCD in writing mode

·         EN=1, a high to low pulse to latch data

·         Delay of 1ms

·         EN=0

Step 4: Display character on LCD.

The functions lcdcmd() and lcddata() are user-defined functions. They are used to send a character (E in this case) to be displayed on LCD.

LCD_CMD(0x38);             // send command 0x38 to LCD

LCD_DAT(‘E’);                // send character E to LCD

schematic diagram :

THE PROGRAM IS AVAILABLE ON GITHUB : https://github.com/ebine/lcd-interface-pic16f877a


# include<htc.h>

#if defined(WDTE_OFF)
__CONFIG(WDTE_OFF & LVP_OFF);
#elif defined (WDTDIS)
__CONFIG(WDTDIS & LVPDIS);
#endif

#define RS RE0
#define RW RE1
#define EN RE2
#define DATA PORTB

void LCD_CMD(unsigned int value);
void LCD_DAT(unsigned int value);
void delay();


int main(void)
{
    ADCON0 = 0x00;//Disable ADC ports
    ADCON1 = 0x06;//Disable ADC ports

    TRISE =0x00;
    TRISB =0x00;
    //DATA=0x01;
    LCD_CMD(0x01);
    delay ();
    LCD_CMD(0x38);
    delay ();
    LCD_CMD(0x0F);
    delay ();
   // LCD_CMD(0x07);
    delay();
    LCD_CMD(0x06);
    delay ();
    LCD_CMD(0x0c);
    delay ();


    LCD_CMD(0x80);
    delay ();

    //DATA='A';
    LCD_DAT('S');
    LCD_DAT('E');
    LCD_DAT('R');
    LCD_DAT('V');
    LCD_DAT('4');
    LCD_DAT('U');

    LCD_CMD(0x80);
     while(1);
    return (0);

}

void LCD_CMD(unsigned int value)
{
    DATA =value;
    RS=0;
    RW=0;
    EN=1;
    delay ();
    EN=0;
    delay ();
 }

void LCD_DAT(unsigned int value)
{
    DATA=value;
    RS=1;
    RW=0;
    EN=1;
    delay ();
    EN=0;
    delay();

}

void delay(void)
{
    int counter = 0;
    for (counter = 0; counter<10000; counter++) {
        ;
    }
}

Read more »