Xilinx releases ARM Cortex-A9 MPCore platform

Xilinx has released architecture for an extensible processing platform that it claims will deliver unrivalled levels of performance, flexibility and integration to developers of embedded systems.
The ARM Cortex-A9 MPCore processor-based platform enables system architects and embedded-software developers to apply a combination of serial and  parallel processing address the challenging system requirements presented by the global demand for embedded systems to perform complex functions.
The Xilinx Extensible Processing Platform offers embedded-systems designers a processor-centric design and development approach for achieving the compute and processing horsepower required to drive tasks involving high-speed access to real-time inputs, high-performance processing and complex digital-signal processing – or any combination thereof – needed to meet their application-specific requirements, including lower cost and power.
A software-centric development flow is enabled by a processor-centric approach that presents a full processor system – including caches, memory controllers and commonly used connectivity and I/O peripherals – that boots and can run a variety of operating systems (OS) at power-up, such as Linux, Wind River’s Vxworks and Micrium’s UC-OSII.
The ARM architecture and its connected community ecosystem further maximise productivity for developers of embedded systems, while unrivalled performance is achieved by Xilinx architecting the subsystem around ARM’s dual-core Cortex-A9 MPCore processors, each running at up to 800MHz, combined with the parallel-processing capabilities of Xilinx’s high-performance, low-power 28nm programmable logic.
The programmable logic is tightly coupled with the processor system through the high-bandwidth AMBA-AXI interconnects to accelerate key system functions by up to 100x, using off-the-shelf and/or custom IP.

This architectural approach addresses common performance bottlenecks between these parallel and serial computing environments, memory and I/O.
It also gives the processor system configuration control of the programmable logic, including dynamic reconfiguration.
Software developers can leverage their existing system code based on ARM technology and utilise vast off-the-shelf open-source and commercially available software-component libraries.
Because the system boots an OS at reset, software development can get under way quickly within familiar development and debug environments, using tools such as ARM’s Realview development suite and related third-party tools, Eclipse-based IDEs, GNU, the Xilinx Software Development Kit and others.
Demand for higher levels of embedded-system performance is being driven by end-market applications that require multi-functionality and real-time responsiveness, such as automotive driver assistance, intelligent video surveillance, industrial automation, aerospace and defence, and next-generation wireless.
In the automotive sector  alone, with more than 50 million cars produced each year and an estimated 600 million motor vehicles on the road, today’s USD1.3bn (GBP850m) driver-assistance market is expected to grow to USD5.8bn by 2017 as manufacturers deploy more embedded systems in their vehicles to make them safer.
Research has indicated that 60 per cent of front-end collisions could have been avoided with an extra 0.5-second response time and that driver fatigue accounts for an estimated 30 per cent of all driver fatalities.
As developers of driver-assistance systems pack more computer power into their applications, radar and infrared sensors, cameras and other system components must be installed into confined spaces within the automobile.
The new Xilinx Extensible Processing Platform offers a single-chip solution for optimising application-specific hardware/software partitioning and accelerating functions in hardware to drive complex algorithms.
In a market expected to reach USD46bn by 2013, developers of new intelligent-video technologies need processing platforms for building applications that can automatically monitor video patterns and body language, combined with audio, to make intelligent decisions and send alerts, thus reducing the chance for errors.
The technology is already moving to full high-definition video and frame rates up to 60 frames per second.
The dual Cortex-A9 MPCore-based processor system, coupled with the massive parallel-processing capabilities of the programmable logic, enables this capability.
Developers also gain an opportunity for innovative algorithm design, scalability and field upgradability, within a familiar ARM-based design environment.
Wireless telecommunication is being driven by the need for lower power, smaller physical form factors and reduced development costs, to support an ever-increasing number of users and data-hungry applications.
New technologies such as 4G LTE (Long-Term Evolution) can address bandwidth requirements, but smaller, more efficient base stations are essential to meet overall market requirements.
The Xilinx Extensible Processing Platform will help developers of next-generation wireless base stations to meet these needs by providing high-bandwidth parallel processing of 4G signals in combination with multiuser data management on Cortex A9 processors – all in a small, power-efficient and cost-effective integrated solution.
Because the platform is extensible, developers have the flexibility to implement future equipment updates and performance upgrades of both hardware and software.

Freescale releases power management IC for new Intel® Atom™ processor

Extends battery life and reduces footprint for tablets, smartphones and other Internet consumer devices

TAIPEI (Computex 2010) – June 1, 2010 – Freescale Semiconductor today announced that it has developed a high-performance audio and power management solution for Intel’s new Atom processor-based platforms (formerly codenamed “Moorestown”). The highly integrated chip set is designed to efficiently manage processing power while enabling smaller form factors and longer battery life in next-generation mobile connected devices.

Developed in conjunction with Intel,Freescale’s power management IC (PMIC) is a two chip solution manufactured on Freescale’s advanced SMARTMOS technology, a high-voltage CMOS-based process that enables high integration of precision analog, power and logic. When paired with Intel’s low-power processors and chip sets, Freescale’s PMICs provide increased energy efficiency for Intel-based tablets, smartphones and other Internet consumer devices. Freescale’s solution combines hardware components, design support materials and support for Intel’s drivers to help OEMs deploy sophisticated products to market faster.

“The combination of Intel’s Atom processor and Freescale’s PMIC will allow advanced innovations and end user experiences not realized with current mobile products,” said Scott Ward, vice president and general manager of Freescale’s Analog, Mixed-Signal & Power Division. “The Freescale PMIC solution for Intel-based products allows customers to help develop compelling new devices that feature extended battery life, high speed graphics and exceptional performance.”

Freescale’s PMICs have been thoroughly tested and qualified to help provide solutions for customer compatibly for new product development. The PMIC chip set has integrated audio, charging, LED backlight, USB, ADS and power rails, which when fully integrated, are designed to reduce the footprint and software development cycles.

“The recently announced Intel Atom processor delivers industry-leading performance while significantly reducing idle and active power at the platform level,” said Pankaj Kedia, director of global ecosystem programs in Intel Corporation’s Ultra Mobility Group. “Intel’s collaboration with Freescale in developing the power management chip has played a key role in achieving these power reductions, which will result in handheld form factors with great battery life.”

In addition, Freescale is engaged with multiple ODM and OEM customers utilizing the PMIC for next-generation products targeting the consumer market.

“We welcome the Freescale solution, as it is a good match for market and technology requirements set by a growing number of Internet savvy devices,” said Vesa Kiviranta, vice president, Elektrobit Wireless Solutions.

Freescale’s PMICs for the Intel Atom processor-based platform are available now, as are Intel Development Kits, Freescale development boards and reference design kits.

Intel® Multi-Core Technology do to Enhance Embedded

What Can Intel® Multi-Core Technology do to Enhance Embedded and Communications Applications?

Let’s start with the obvious one: faster performance through parallel processing. But there’s more to it. Intel® multi-core technology also enables platform consolidation, including the ability to combine a multi-platform solution—such as a GUI and RTOS—onto a single piece of hardware. It can also extend the life of legacy applications, enabling old software to run side-by-side with new code on faster platforms. It can increase system utilization, increase performance while reducing energy consumption, and allow systems to share I/O resources—all through virtualization. And by enabling isolation of critical applications and tasks, Intel multi-core technology improves the security of your solutions. In fact, the implementation models for Intel multi-core technology are quite varied and include:

1. Symmetric Multiprocessing (SMP): Operating system (OS) manages memory, resources, and controls task/thread assignments. More threaded code in equals more performance out.
2. Virtualization: VMM/hypervisor manages system resources. Supports legacy software and multiple OSs, as well as platform consolidation and the ability toconverge a general purpose GUI with a real-time OS.
3. Asymmetric Multiprocessing (AMP): Manually assign resources at boot-up. Supports legacy software and multiple OSs and delivers more performance to applications as needed.

Intel multi-core technology is available in a complete array of industry-leading multi-core processors as well as single core processors equipped with hyper-threading technology. These processors deliver unprecedented platform performance and performance-per-watt—a critical requirement for next-generation communications and embedded solutions. Because each execution core in an Intel multi-core processor is clocked slower than a single-core processor, you get lower input voltage and greater performance without increasing the system footprint. And with support from Intel’s award-winning software development tools, you can optimize the software and hardware in your multi-core technology designs for maximum performance and efficiency.

Other benefits of Intel multi-core technology include:

• Backwards compatibility with Intel® architecture-based processors so you can continue to utilize the 32-bit applications of today while adopting 64-bit applications for the future. Virtualized hardware platforms can take advantage of this backwards approach for an even longer period, a benefit to very long-life market segments such as military/aerospace/government.
• Assign different tasks to each execution core, with each one functioning as a distinct processor, allowing you to dedicate multiple applications and OSs to a single execution core, unencumbered by tasks that would otherwise compete for CPU resources. You can even use virtualization to apply heterogeneous parallelism so that some cores function with greater capacity than others.

Renesas Electronics Introduces Compact, Slim Photocoupler Meeting Worldwide Safety Standards

Renesas Electronics Corporation (TSE: 6723), a premiere supplier of advanced semiconductor solutions, today introduced its new compact, slim photocoupler product, the PS2381-1, achieving the long creepage distance of 8 mm required by worldwide safety standards.

The new product is mounted in a 4-pin LSOP (long small outline package) in which the shortest distance between the LED (Light-Emitting Diode) side pin and the photo detector side pin along the package surface (the creepage distance) is 8 mm. This package achieves an insulation thickness of 0.4 mm, which is the shortest distance between the LED device and the photo detector device that are isolated within the package. In addition to these features, the new photocoupler is designed to provide package thickness of 2.3 mm, reduced by 40 percent from the existing 4-pin DIP (Dual-Inline package), and an operating ambient temperature of 115℃ as well as a guaranteed isolation voltage of 5,000 Vrms, maintaining the same voltage as the 4-pin DIP package.

A photocoupler is a semiconductor device that mounts both an LED device that converts an electrical signal to light in the input side and a photo detector device that converts light to an electrical signal in the output side in a single package. Since the signal is transmitted using light, a photocoupler completely isolates the input side from the output side. Therefore, photocouplers are used to protect electrical circuits between electrical equipment by isolating the input side from the output side, reducing noise, and are used in a wide variety of power supply circuits in TV game power supplies, cell phone chargers, office and factory automation equipments, and home appliances.

Of these applications, there is a growing demand for smaller and thinner TV game power supplies and cell phone chargers. To address this market demand, further miniaturization and thinner form factors in all types of electronic components, including photocouplers, are required. However, it had been impossible to assure electrical safety in terms of the creepage distance and the insulation thickness required by safety standards in other countries.

Renesas Electronics’ new photocoupler overcomes these issues by increasing the distance between the LED and the photo detector, and by optimizing the size of the light-emitting element to maintain the current transfer ratio, which is the strength of the light received by the photo detector.

Renesas Electronics’ new photocoupler also features an increased operating ambient temperature of 115℃ by optimizing materials. The new photocoupler also provides high insulation voltage of 5000 Vrms by adopting the highly-reliable double-molded structure used in existing photocoupler products. These features enable system designers to easily develop further miniaturized and thinner systems that comply with worldwide safety standards.

The main features of this new product are summarized below.

• • • • (1) Package thickness reduced by 40% from that of existing products, achieving a thinner form factor

  • • • (2) Industry’s first to achieve operating ambient temperature of 115℃ for a 4-pin LSOP

  • • • (3) Industry-leading high isolation voltage of 5,000 Vrms in a 4-pin LSOP package

The new photocoupler achieves an 8 mm creepage distance and a 0.4 mm isolation distance by adopting a structure in which the separation between the light-emitting and the photo detector devices is increased. The size of the light-emitting device is also optimized to maintain the current transfer ratio. Furthermore, the package thickness is 2.3 mm, a 40% reduction from the thickness of existing 4-pin DIP products. This makes it possible for system designers to develop even smaller and thinner systems that meet safety standards worldwide.
With lowered package thermal resistance and improved heat dissipation performance by changing the lead frame materials, the operating ambient temperature is increased to 115℃ even with the 4-pin LSOP miniature thin-form package, enabling system designers to develop more compact and thinner systems over a wide temperature range.
The new photocoupler achieves industry leading high isolation voltage of 5000 Vrms by adopting the highly reliable double-molded structure used in existing photocoupler products, maintaining the current transfer ratio of the photocouplers, and assuring the insulation thickness between the LED and the photo detector devices.

FlexRay

What is Flexray?
For these automotive applications to become commonplace, a number of protocol requirements must exist. Enter FlexRay. FlexRay is a communication system developed by a consortium founded in 2000 by BMW, DaimlerChrysler, Motorola, and Philips Semiconductors. In 2001, Robert Bosch GmbH and General Motors joined the consortium. So did Ford Motor Company this past June. The consortium members realized that despite the numerous automotive communications protocols out on the market—most from Europe, most in or just out of development—none would fulfill future automotive control requirements. Even the computer communications protocols don’t suffice. “None of them are automotive qualified,” explains Andreas Both, business and technology manager overseeing FlexRay for the Semiconductor Products Sector of Motorola (Munich, Germany). That is, they are not qualified for automotive operating temperatures and electromagnetic compatibility requirements. (Remember hearing spark plugs fire through your aftermarket AM radio?)
FlexRay is an open, common, scalable electronic architecture for automotive applications. It can operate in single- or dual-channel mode, providing redundancy where needed. It allows both synchronous and asynchronous data transmissions. With the former, other nodes on the network receive time-triggered messages in a predefined latency time. With the latter, messages get to their destinations quickly or slowly, depending on their priority. Currently, FlexRay can handle communications at 10 Mbps—the speed of your typical low-end home-computing local area network. Motorola’s Both is quick to add that this standard doesn’t mean that 10 Mbps is enough forevermore. Instead, it is fast enough for the foreseeable future, given the applications automakers have envisioned thus far.
Last, FlexRay’s clock synchronization mechanism aptly handles cheap clock oscillators, namely those made out of quartz. And that synchronization, as with all of FlexRay, is fault tolerant. For example, FlexRay automatically and digitally compensates for the differences in the variety of quartz clocks running on the network, as well as in their slight changes in clock frequencies. This clock synchronization is a distributed mechanism; there’s no master timekeeper here. So if one node fails or for some reason is taken off the network, the other nodes will continue to operate in synchrony.
(Insofar as the fault tolerance of motors and sensors, the normal rules of reliable systems design applies. For example, in a steer-by-wire system, the sensor system in the steering wheel will be a redundant array, with two or three sensors providing the same signal. A judging algorithm in the electronics will then determine the validity of the signals; that is, it will determine whether all three sensors are providing the same information, or at least two of the three.)
Simplification=dollar savings
Along with making X-by-wire control possible, FlexRay offers other advantages. First, “any time you can get the control mechanism closer to the actual mechanism you’re trying to control, that’s a performance enhancer,” says Baker. Second, FlexRay helps eliminate the amount of mechanical space required for hydraulic fluid systems—systems that will be totally replaced by electronics. Third, continues Baker, FlexRay “provides the flexibility needed to simplify integration with current control system, reducing overall system complexity.” Therein lies a major advantage. Both OEMs and automotive suppliers are saying, says Both, “`We don’t need more [communications] technologies. We need less technologies that are more versatile.’ They want technologies that can be used over a range of applications.” That is, rather than have one by-wire protocol for steering and another for power train, FlexRay aims to be the protocol for all the applications. That’s one protocol applied across platforms, across assembly plants, across regions.
Not only will this simplify automotive electronics and communications architectures, it should also help make automotive electronics more stable.
FlexRay is aimed at the automotive market. No royalties will have to be paid for automotive applications. Prototype implementations of FlexRay-based chips are available for FlexRay Consortium members. First silicon of protocol engines will be available in early 2004; qualified silicon is scheduled for late 2004. Engineering samples of the electrical physical layer will be available from Philips Semiconductors in the second quarter of 2003; product parts by the end of 2004. First series production cars with FlexRay are expected around 2006.
The price of FlexRay devices, as with any semiconductor device, depends on silicon size, chip test efforts, commercial relationships with customers, and other criteria. None of these are fixed just yet.
For more information about the FlexRay Consortium and its FlexRay communications protocol, trawl over to www.flexray.com. Read the FAQ; it’s excellent. For additional information or if you have specific questions, send an email to request@flexray-group.com

What is WiMAX? |WiMAX-FAQ

WiMAX is an IP based, wireless broadband access technology that provides performance similar to 802.11/Wi-Fi networks with the coverage and QOS (quality of service) of cellular networks. WiMAX is also an acronym meaning “Worldwide Interoperability for Microwave Access (WiMAX).
WiMAX is a wireless digital communications system, also known as IEEE 802.16, that is intended for wireless “metropolitan area networks”. WiMAX can provide broadband wireless access (BWA) up to 30 miles (50 km) for fixed stations, and 3 – 10 miles (5 – 15 km) for mobile stations. In contrast, the WiFi/802.11 wireless local area network standard is limited in most cases to only 100 – 300 feet (30 – 100m).

With WiMAX, WiFi-like data rates are easily supported, but the issue of interference is lessened. WiMAX operates on both licensed and non-licensed frequencies, providing a regulated environment and viable economic model for wireless carriers.

At its heart, however, WiMAX is a standards initiative. Its purpose is to ensure that the broadband wireless radios manufactured for customer use interoperate from vendor to vendor. The primary advantages of the WiMAX standard are to enable the adoption of advanced radio features in a uniform fashion and reduce costs for all of the radios made by companies, who are part of the WiMAX Forum™ – a standards body formed to ensure interoperability via testing. The more recent Long Term Evolution (LTE) standard is a similar term describing a parallel technology to WiMAX that is being developed by vendors and carriers as a counterpoint to WiMAX.

GSM BASED INDUSTRIAL AUTOMATION

ABSTRACT:
In normal we used to control the industrial equipments by manual operation. Hence it is to be updated step by step manually. It is overcome by a new mode of communication which is used to control all those equipments through a single message from anywhere. GSM is the most popular mobile phone system in the world which could be used for this controlling operation from anywhere else.

GSM – Global System for Mobile Communication is used as a media which is used to control and monitor the industrial equipments from anywhere by sending a message. It has its own deterministic character. Thereby, here GSM is used to monitor and control the DC motor, Stepper motor, Temperature sensor and Solid State Relay by sending a message through GSM modem. Hence no need to waste time by manual operation and transportation.

Hence it is considered as highly efficient communication through the mobile which will be useful in industrial controls, automobiles, and appliances which would be controlled from anywhere else. It is also highly economic and less expensive; hence GSM is preferred most for this mode of controlling.

CIRCUIT DIAGRAM:

PROJECT CODINGS:

ADC CODING:

#include
#include
#include
#include
#define ACK 1
#define NO_ACK 0
#define HIGH 01;
#define LOW 00;
idata unsigned char dat;
int ACK1 = 1,i;
float dat1;
char result,dat2;
unsigned char b,p,q;
sbit SDA = P2^3; // connect to SDA pin (Data)
sbit SCL = P2^4; // connect to SCL pin (Clock)
xdata char *ptr_cmd = (xdata char *) 0×0FFF8;
xdata char *ptr_en = (xdata char *) 0×0FFF9;

void lcd_comm();

void init_lcd();
void display1(char *name);
void disp(int name1);
void lcd_delay();
void Delay_Time();

void delay()
{
unsigned int i =1000;
while ( i– );
}

void busy_check()
{
*ptr_cmd = 0×02;
while ( ( *ptr_en & 0×80 ) != 0×00 );
}

void I2C_STOP()
{
SCL=HIGH;
SDA=LOW;
Delay_Time();
Delay_Time();
SDA=HIGH;
}

void I2C_START()
{
SCL =LOW;
SDA =LOW;
Delay_Time();
Delay_Time();
SCL=HIGH;
Delay_Time();
Delay_Time();
SDA=HIGH;
Delay_Time();
Delay_Time();
SDA=LOW;
Delay_Time();
Delay_Time();
SCL=LOW;
}

void I2C_WRITE(unsigned char j)
{
dat=j;
printf(”%c”,j);
for(i=0;i<8;i++)
{
SDA = dat & 0×80;
dat=dat<<1;
SCL=HIGH;
Delay_Time();
Delay_Time();
SCL = LOW;
}
SDA=HIGH;
Delay_Time();
Delay_Time();
SCL = HIGH;
Delay_Time();
Delay_Time();
ACK1 = SDA;
Delay_Time();
Delay_Time();
SCL=LOW;
if(ACK1!=0)
{
}
else
{
}
}
unsigned char I2C_READ()
{
unsigned char i,j;
j = 0;
j = SDA;
for(i=0; i<8; i++) //for reading the data bit by bit
{
j <<= 1; //shifting the data line one at a time
SCL = HIGH;
j |= SDA;
Delay_Time();
SCL=LOW;
}
Delay_Time();
Delay_Time();
Delay_Time();
SDA = LOW;
Delay_Time();
Delay_Time();
Delay_Time();
SCL = HIGH;
Delay_Time();
Delay_Time();
Delay_Time();
SCL = LOW;
Delay_Time();
Delay_Time();
Delay_Time();
SDA = HIGH;
Delay_Time();
Delay_Time();
Delay_Time();
return(j);
}

void adc_data()
{
init_lcd();
display1(”TEMPERATURE: “);
I2C_START();
I2C_WRITE(0X90);
I2C_WRITE(0X00);
I2C_STOP();
I2C_START();
I2C_WRITE(0X91) ;
dat1 =I2C_READ();
I2C_STOP();
printf(” result: %2.1f degree celcius\n”,dat1);
P2 = 0×0ff;
dat1=dat1;
q=dat1;
lcd_comm();
*(ptr_en)=0xc9;
busy_check();
disp(((q%100)/10)+48);
disp(((q%10)/1)+48);
display1(”.”);
disp((q%10)+48);
display1(0×6f);
display1(” C”);
for(q=0;q<25;q++)
{
lcd_delay();
}
}

void lcd_delay()
{
int i=15000;
while(i–){}
}

void Delay_Time()
{
unsigned long int i;
for(i=0;i<100;i++);
}
void display1(char *name)
{
int i,k = 15;
int l = strlen(name);
if (l <= 15)
k = l;
for(i = 0;i < k;i++)
{
*(ptr_cmd) = 0×01;
*(ptr_en) = name[i];
busy_check();
}
for (i; i
{
*(ptr_cmd) = 0×01;
*(ptr_en) = name[i];
busy_check();
}
}

void disp(int name1) //LCD display routine (for digits display )
{
*(ptr_cmd) = 0×01;
*(ptr_en) = name1;
busy_check();
Delay_Time();
}
void init_lcd()
{
lcd_comm();
*( ptr_en ) = 0×38;
busy_check();

lcd_comm();
*(ptr_en) = 0×0e;
busy_check();

lcd_comm();
*(ptr_en) = 0×01;
busy_check();

lcd_comm();
*(ptr_en) = 0×06;
busy_check();

lcd_comm();
*(ptr_en) = 0×80;
busy_check();

}

void lcd_comm()
{
*( ptr_cmd ) = 0×00;
}

void main()
{
init_lcd();
while(1)
{
adc_data();
}
}

STEPPER MOTOR CODING:

#include
#include
int i,j,k,p=0;
static int x;
char cmgs[60];

at 0xB2 sbit (int0);
sbit MDM = P2^1;

code char AT_CMD1[9]={’a',’t',’+',’c',’m',’g',’f',’=',’1′};

code char AT_CMD2[23] = {’a',’t',’+',’c',’s’,'c’,'a’,'=’,'”‘,’+',’9′,’1′,’9′,’8′,’4′,’3′,’0′,’0′,’0′,’0′,’4′,’0′,’”‘};

code char AT_CMD3[17] = {’a',’t',’+',’c',’n',’m',’i',’=',’1′,’,',’2′,’,',’0′,’,',’0′,’,',’0′};

xdata char *ptr_cmd = (xdata char *)0×0FFF8; //LCD command mode control
xdata char *ptr_en = (xdata char *)0×0FFF9; //LCD Enable

char AT1[13];
char AT2[28];
char AT3[21];
unsigned char a[]={0×66,0xcc,0×99,0×33};
unsigned char b[]={0×00,0×00,0×00,0×00};

char mybyte;
char serial_rx ();
void busy_check ();
void display (char* );
void send_sms ();
void slow();
void medium();
void fast();
void off();

//**********************************************************************
// SERIAL INIT_TX_RX
//**********************************************************************

void baud_init ()
{
TMOD = 0×20;
TH1 = 0xF4;
SCON = 0×50;
TR1 = 1;
}

//**********************************************************************
// DELAY ROUTINES
//**********************************************************************

void delayms ()
{
int i, j;
for( i = 0 ; i <= 1000 ; i++ )
for( j = 0 ; j <= 1000 ; j++ );
}

void delay()
{
int i,j;
for (i=0;i<10;i++)
for(j=0;j<400;j++);
}

void delay1()
{
int i,j;
for(i=0;i<75;i++)
for(j=0;j<500;j++);
}

void delay2()
{
int i,j;
for(i=0;i<50;i++)
for(j=0;j<250;j++);
}

void delay3()
{
int i,j;
for(i=0;i<25;i++)
for(j=0;j<100;j++);
}

//**********************************************************************
// SEND FIRST AT COMMAND
//**********************************************************************

void send_cmd1()
{
int j;
for( j = 0 ; j <= 8 ; j++ )
{
SBUF = AT_CMD1[j];
while(TI == 0);
TI = 0;
AT1[j] = serial_rx ();
}
SBUF = 0×0D;
while(TI == 0);
TI = 0;
AT1[9] = serial_rx ();
AT1[10] = serial_rx ();
AT1[10] = serial_rx ();
AT1[11] = serial_rx ();
AT1[12] = serial_rx ();
AT1[13] = ‘\0′;
}

//**********************************************************************
// SEND SECOND AT COMMAND
//**********************************************************************

void send_cmd2()
{
int j;
for( j = 0 ; j <= 22 ; j++ )
{
SBUF = AT_CMD2[j];
while(TI == 0);
TI = 0;
AT2[j] = serial_rx ();
}
SBUF = 0×0D;
while(TI == 0);
TI = 0;
AT2[23] = serial_rx ();
AT2[24] = serial_rx ();
AT2[24] = serial_rx ();
AT2[26] = serial_rx ();
AT2[27] = serial_rx ();
AT2[28] = ‘\0′;
}

//**********************************************************************
// READ SMS COMMAND
//**********************************************************************

void read_sms()
{
int k;
for( k = 0 ; k <= 16 ; k++ )
{
SBUF = AT_CMD3[k];
while(TI == 0);
TI = 0;
AT3[k] = serial_rx ();
}
SBUF = 0×0D;
while(TI == 0);
TI = 0;
AT3[17] = serial_rx ();
AT3[18] = serial_rx ();
AT3[18] = serial_rx ();
AT3[19] = serial_rx ();
AT3[20] = serial_rx ();
AT3[21] = ‘\0′;
}

//**********************************************************************
// LCD ROUTINE
//**********************************************************************

char serial_rx()
{
while(RI == 0);
mybyte = SBUF;
RI = 0;
return (mybyte);
}

void busy_check()
{
*ptr_cmd = 0×02;
while((*ptr_en & 0×80) != 0×00){}
}

void lcd_comm()
{
*(ptr_cmd) = 0×00;
}

void init_lcd()
{
lcd_comm();
*(ptr_en) = 0×38;
busy_check();

lcd_comm();
*(ptr_en) = 0×0C;
busy_check();

lcd_comm();
*(ptr_en) = 0×80;
busy_check();

lcd_comm();
*(ptr_en) = 0×01;
busy_check();
}

//**********************************************************************
// DISPLAY ROUTINE
//**********************************************************************

void display (char *name)
{
int l = strlen(name);
int i;
for( i = 0; i <= 15 ; i++ )
{
*(ptr_cmd) = 0×01;
*(ptr_en) = name[i];
busy_check();
}
*(ptr_cmd) = 0×00;
*ptr_en = 0xC0;
busy_check ();
for( i ; i < l ; i++ )
{
*(ptr_cmd) = 0×01;
*(ptr_en) = name[i];
busy_check();
}
}

void display1(char *name)
{
int i;
int l;
l = strlen(name);
for( i = 51; i <= 57 ; i++ )
{
*(ptr_cmd) = 0×01;
*(ptr_en) = name[i];
busy_check();
}
*(ptr_cmd) = 0×00;
*ptr_en = 0xc0;
busy_check ();
}

//**********************************************************************
// SMS_MOTOR CONTROL ROUTINE
//**********************************************************************

void sms_cntrl_mtr ()
{
int i,x,z,j;
char mtrF[] = “STPMTR-F”;
char mtrS[] = “STPMTR-S”;
char mtrO[] = “STPMTR-O”;

unsigned char a[]={0×66,0xcc,0×99,0×33};
unsigned char b[]={0×00,0×00,0×00,0×00};

IE = 0×85; //0×81=interrupt 0, 0×84=interrupt 1
IT0=1;
IT1=1;

while(1)
{
medium();
if( MDM == 0 )
{
off();
}

else
{
MDM=1;
medium();
}
}

i = 51; j = 0;
while ( (cmgs[i] == mtrF[j]) && (j != 8 ))
{
i++;
j++;
}
if ( j == 8 )
{
fast();
display ( ” MATCH-FAST ” );
}

i=51; j = 0;
while ( ( cmgs[i] == mtrS[j] ) && ( j != 8 ) )
{
i++;
j++;
}
if (j == 8 )
{
slow();
display ( ” MATCH-SLOW ” );
}

i=51; j = 0;
while ( ( cmgs[i] == mtrO[j] ) && ( j != 8 ) )
{
i++;
j++;
}
if (j == 8 )
{
off();
display ( ” MATCH-OFF ” );
}

while(cmgs[i])
{
i++;
*ptr_cmd = 0×01;
*ptr_en = cmgs[i];

}
}

//**********************************************************************
// SMS_STEPPER MOTOR FUNCTIONS ROUTINE
//**********************************************************************

void slow()
{
int x,z;

for(z=0;z<100;z++)
{
for(x=0;x<4;x++)
{
P1=a[x];
delay3();
}
}
}

void off()
{
int x,z;
for(z=0;z<100;z++)
{
for(x=0;x<4;x++)
{
P1=b[x];
delay3();
}
}
}

void medium()
{
int x,z;
for(z=0;z<100;z++)
{
for(x=0;x<4;x++)
{
P1=a[x];
delay2();
}
}
}

void fast()
{
int x,z;
for(z=0;z<100;z++)
{
for(x=0;x<4;x++)
{
P1=a[x];
delay1();
}
}
}

void ext_int0() interrupt 0
{
fast();
}

at 0×0013
void ext_int1() interrupt 1
{
slow();
}

void main( void )
{
unsigned int e = 65533;

//**********************************************************************
// AT+CMGF=1 – OK
//**********************************************************************

init_lcd ();
baud_init ();
send_cmd1 ();
display (AT1);
delayms ();

//**********************************************************************
// AT+CSCA =”MESSAGE CENTRE NO” – OK
//**********************************************************************

init_lcd ();
baud_init ();
send_cmd2 ();
display (AT2);
delayms ();

//**********************************************************************
// READ – SMS = OK
//**********************************************************************

while(1)
{
init_lcd ();
baud_init ();
read_sms ();

display (AT3);
p = 0;
while (p <= 58)
{
cmgs[p] = serial_rx();
++p;
}

cmgs[p] = ‘\0′;
sms_cntrl_mtr ();
while (e–);
e = 65533;
}
while(1);
}

D.C MOTOR CONTROL:

void sms_cntrl_mtr ()
{
int i,j;
char mtrL[] = “mtr-l”;
char mtrR[] = “mtr-r”;
char mtrO[] = “mtr-o”;

i = 51; j = 0;
while ( (cmgs[i] == mtrL[j]) && (j != 5 ))
{
i++;
j++;
}
if ( j == 5 )
{
mtrr = 0;
mtrl = 1;

display ( ” MATCH-LEFT ” );
}

i=51; j = 0;
while ( ( cmgs[i] == mtrR[j] ) && ( j != 5 ) )
{
i++;
j++;
}
if (j == 5 )
{
mtrl = 0;
mtrr = 1;

display ( ” MATCH-RIGHT ” );
}

i=51; j = 0;
while ( ( cmgs[i] == mtrO[j] ) && ( j != 5 ) )
{
i++;
j++;
}
if (j == 5 )
{
mtrl = 0;
mtrr = 0;

display ( ” MATCH-OFF ” );
}

while(cmgs[i])
{
i++;
*ptr_cmd = 0×01;
*ptr_en = cmgs[i];

}
}

LOAD CELL BASED PRODUCT CHEKING SYSTEM

PIC16F877A C CODE:
#include<16f877a.h>
#fuses HS,NOWDT,NOLVP,NOPROTECT
#use delay(clock=20000000)
#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7)

void main()
{
unsigned char load_cell_var;

setup_port_A(ALL_ANALOG);
setup_adc(ADC_CLOCK_INTERNAL);
output_c(0×01);
// printf(”Welcome To PC based Weight Scale System \n”);
// delay_ms(1000);

while(TRUE)
{

set_adc_channel(0);
delay_us(100);
load_cell_var=READ_ADC();
printf(”\r Digital value=%u\r\n”,load_cell_var);

if((load_cell_var>=76)&&(load_cell_var<=77))
{
output_c(0×01);
printf(”PRODUCT IS GOOD”);
delay_ms(1500);

}

else
{
output_c(0×00);
printf(”PRODUCT IS DEFECT “);
delay_ms(1500);
output_c(0×01);
}
}
}

PIC 16F877A BASED DATA MONITORING SYSTEM

In this project we have used two types of different R.F Module like 433Mhz and 315Mhz Interface into Pic16f877a,HT640 for R.F Encoder,HT648 for R.F Decoder Ic’s.Hence in this we have touse two sensors one is for temperature sensor LM35, another one is potentiometer, the two sensors have an output of analog signal so that analog signal is fed into to two adc channel of pic16f877a and the corresponding digital output is get from the serial port, continuously watching the real time parameter monitoring purposes.
one of the important factor for using 2 adc channel of pic16f877a in the coding section delay_us(100) is very very important. Do u have any project for using 1 more channel of adc using 100 Micro sec delay is must,
in this project using 2 different R.F frequencies,but data is collide each other so in the programming section we have to use R.F Encoder,Decoder connected port must be zero after getting the data,and one more thing if u use more R.F module in the same frequency is it possible to use bc547 transistor for R.F transmitter section to bc547 like as a switch to cut the r.f transmitter voltage, through the coding part is it possible.

R.F TRANSMITTER C CODE:

#include<16f877a.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=1200,xmit=PIN_C6,rcv=PIN_C7)

void main()
{
unsigned char trim=0,temp=0;
setup_port_a( ALL_ANALOG );
setup_adc( ADC_CLOCK_INTERNAL );
printf(” NODE1 is Initialising\r\n”);
printf(” NODE1 is Communicating wait……..\r\n”);
printf(” Network NODE2 is Initialising\r\n”);
printf(” Network NODE2 is Communicating wait……..\r\n”);
while(1)
{
set_adc_channel( 0 );
delay_us(100);
trim=read_adc();
output_b(trim);
printf(”trim pot=%u\r\n”,trim);
set_adc_channel( 1 );
delay_us(100);
temp=read_adc();
output_c(temp);
printf(”temp sensor=%u\r\n”,temp);
}
}

R.F RECEIVER C CODE:

#include<16f877a.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=1200,xmit=PIN_C6,rcv=PIN_C7)
float lm35=0;
unsigned char pot=0;

void main()
{
printf(”WIRELESS TRANSMISSION \r\n”);
delay_ms(1000);
printf(”NODE1 is Initializing\r\n”);
delay_ms(200);
printf(”NODE1 is Communicating wait……..\r\n”);
delay_ms(200);
printf(”NODE2 is Initializing\r\n”);
delay_ms(200);
printf(”NODE1 is Communicating wait……..\r\n”);
delay_ms(200);
while(1)
{

pot=input_b();
printf(”trim_pot value is=%u\r\n\n”,pot);

if(pot<=2)
{
printf("Node 1 is stop communicating\r\n");
}
if(pot>=254)
{
printf(”Avoid Data Collision between Node1 and Node2 zero to port B \r\n”);
}

output_b(0×00);
delay_ms(1000);
lm35=input_c();
lm35/=8;
if(lm35>=27)
{
printf(”L35 temp value is=%2.1f\r\n\n”,lm35);
}
if(lm35<27)
{
printf(”Node 2 is stop communicating\r\n”);
lm35=0;

}

delay_ms(500);
output_b(0×00);
output_c(0×00);

}

}

8051 Based Heart Rate Meter

C code for Heart Rate Meter:

//******************************************************//

8051 Based Heart Rate Meter Main Program

//*****************************************************//

#include <reg51.h>  // using ride 6.1.6 IDE ,Keil also use

#include <lcd.h>

sbit gg =P1^2;

unsigned char val[] = {’0′,’1′,’2′,’3′,’4′,’5′,’6′,’7′,’8′,’9′};

unsigned char bt=0,sec=0,sec100=0,min=0,r,t1,t2;

void extrint (void) interrupt 0

{

bt++;

}

void timer0 (void) interrupt 1 using 1

{

TH0 = 0xdc;

sec100++;

if(sec100>=10)

{

sec++;

sec100=0;

if(sec>=6)

{

min++;

sec=0;

}

}

}

void disp(unsigned char n)

{

LCD_putc(val[n/100]);

LCD_putc(val[(n/10)%10]);

LCD_putc(val[n%10]);

}

void main()

{

EA = 1;

TMOD = 0×02;

IT0 = 1;

EX0 = 1;

ET0 = 1;

TR0 = 1;

LCD_delay(100);

LCD_init();

LCD_delay(100);

LCD_row1();

LCD_delay(100);

LCD_puts(”Welcome to H.R.M. “);

LCD_delay(100);

t1=0;t2=0;

while(1)

{

if(min>=1)

{

LCD_command(0xc0);

LCD_delay(100);

LCD_putc((bt/100)+48);

r=bt%100;

LCD_putc((r/10)+48);

LCD_putc((r%10)+48);

LCD_delay(100);

bt=0;

min=0;

}

}

}

/ /***********************************************//

LCD Header File Routines

//************************************************//

#include<string.h>

#include<stdio.h>

#define LCD_clear() LCD_command(0×1) /* Clear display LCD */

#define LCD_origin() LCD_command(0×2) /* Set to origin LCD */

#define LCD_row1() LCD_command(0×80) /* Begin at Line 1 */

#define LCD_row2() LCD_command(0xC0)

sbit rs = P2^5;

sbit en = P2^6;

void lcd_en ()

{

en = 1; en = 1; en = 1;

en = 0; en = 0;

}

void LCD_delay(unsigned char ms)

{

unsigned char n;

unsigned int i;

for (n=0; n

{

for (i=0; i<1535; i++); /* For 1 ms */

}

}

void LCD_command(unsigned char command)

{

rs=0; rs = 0;

P0 = command;

lcd_en ();

LCD_delay(1);

}

void LCD_init()

{

LCD_command(0×38);

LCD_command(0×06);

LCD_command(0×0c);

LCD_command(0×01);

LCD_delay(256);

}

void LCD_putc(unsigned char ascii)

{

rs=1;

P0 = ascii;

lcd_en ();

LCD_delay(2);

LCD_command(0×0C);

}

void LCD_puts(unsigned char *lcd_string)

{

while (*lcd_string)

{

LCD_putc(*lcd_string++);

}

}