Académique Documents
Professionnel Documents
Culture Documents
BACHELOR OF TECHNOLOGY
In
ELECTRICAL AND ELECTRONICS ENGINEERING
By
Raheema Begum (09241A0289)
G.SriKeerthi
(09241A02A6)
L.R.SindhuPriya (09241A02A2)
B.Himabindu
(09241A0270)
CERTIFICATE
This is to certify that the project report entitled FUZZY LOGIC BASED
CONTROL OF WASHING MACHINE USING ARDUINO that is being
submitted
by
Raheema
Begum,
G.SriKeerthi,
L.R.SindhuPriya,
Prof P.M.Sharma
HOD, EEE Dept,
GRIET,Hyderabad
Mr.M.Ramesh
External Examiner
Asst. Professor, EEE Dept
GRIET, Hyderabad
(Internal Guide)
ACKNOWLEDGEMENT
We have immense pleasure in expressing our thanks and deep sense of
gratitude to our guide Mr.M.Ramesh, Assistant Professor, Department of
Electrical Engineering, G.R.I.E.T for his guidance throughout this project.
We also express our sincere thanks to Prof. P.M.Sharma, Head of the
Department, G.R.I.E.Tfor extending his help.
We wish to express our profound sense of gratitude to Prof. P. S. Raju,
Director, G.R.I.E.Tfor his encouragement, and for all facilities to complete this
project.
Finally we express our sincere gratitude to all the members of faculty and
my friends who contributed their valuable advice and helped to complete the
project successfully.
ABSTRACT
Our project deals with the control of operation of washing machine by using fuzzy
logic control and Arduino. This control is with respect to the degree of dirt, amount of load
and the type of load, since the wash time is based on the amount of clothes to wash, the type
of loadand the degree of dirt in clothes.
First, the dirt in water is sensed by optical sensor after 5 rotations which gives the
output voltage in the range of 0-5 volts. For high level of contamination of water, the voltage
range is 0 to 2 volts and for low level of contamination the range is 4-5 volts approximately.
Secondly with respect to load, the supply current drawn increases as the load on the
washing machine increases. By sensing the amount of current and optical sensor output
voltage, the wash time is determined. So the control is done for both cases i.e. based on dirt
level and amount of load. For lightly loaded and less dirt requires less wash time. For heavily
loaded and more dirt condition wash time is more. The wash time is varied in order to control
the type of load.
By giving these signals (current and voltage) as input to Arduino we determine the
required amount of wash time for which the machine is operated. Thus, Fuzzy logic
controlled washing machine controller gives a correct wash time even though a precise model
of input and output relationship is not given.
CONTENTS
LIST OF FIGURES
ABSTRACT
CHAPTER-1:INTRODUCTION ....................................................................................................... 1
CHAPTER-2:HISTORY OF WASHING MACHINE ........................................................................ 2
2.1 THE PROCESS BY HAND ..................................................................................................... 2
2.2WASHING BY MACHINE ...................................................................................................... 3
2.3 TECHNOLOGY IMPROVEMENT ......................................................................................... 3
2.4 MODERN WASHING MACHINES........................................................................................ 5
CHAPTER-3:PROJECT OVERVIEW .............................................................................................. 7
3.1 ADVANTAGES OF USING FUZZY LOGIC CONTROL....................................................... 7
3.2 DESIGN DETAILS ................................................................................................................. 8
3.2.1 HARDWARE ................................................................................................................... 8
3.2.2 SOFTWARE ................................................................................................................... 15
CHAPTER-4:ARDUINO ................................................................................................................ 20
4.1 ARDUINO PIN DESCRIPTION ........................................................................................... 20
4.1.1 CHARACTERISTICS .................................................................................................... 22
4.1.2 SCHEMATIC & REFERENCE DESIGN........................................................................ 22
4.1.3 COMMUNICATION ...................................................................................................... 24
4.1.4 PROGRAMMING .......................................................................................................... 25
4.1.5 AUTOMATIC (SOFTWARE) RESET............................................................................ 25
LIST OF FIGURES
CHAPTER 1
INTRODUCTION
Washing machines are a common feature today in the Indian household. The most
important utility a customer can derive from a washing machine is that he saves the effort
he/she had to put in brushing, agitating and washing the cloth. Most of the people wouldnt
have noticed that different type of cloth need different amount of washing time which
depends directly on the degree of dirt, amount of load, type of cloth quality etc.
The washing machines that are used today (the one not using fuzzy logic control)
serves all the purpose of washing, but which cloth needs what amount of agitation time is a
business which has not been dealt with properly. In most of the cases either the user is
compelled to give all the cloth same agitation or is provided with a restricted amount of
control. The thing is that the washing machines used are not as automatic as they should be
and can be.
Our project aims at presenting the idea of controlling the washing time using fuzzy
logic control and Arduino. Our project describes the procedure that can be used to get a
suitable washing time for different cloths. The process is based entirely on the principle of
taking non-precise inputs from the sensors, subjecting them to fuzzy arithmetic and obtaining
a crisp value of the washing time.
This method can be used in practice to further automate the washing machines. Never
the less, this method, though with much larger number of input parameters and further
complex situations, is being used by the giants like LG and Samsung.
CHAPTER-2
HISTORY OF WASHING MACHINE
A washing machine[1] is a machine to wash laundry, such as clothing and sheets.
Washing entails immersing, dipping, rubbing, or scrubbing in water usually accompanied by
detergent, or bleach. The simplest machines may simply agitate clothes in water while
switched on; automatic machines may fill, empty, wash, spin, and heat in a cycle. Most
washing machines remove substantial amounts of water from the laundry at the end of a wash
cycle, but do not completely dry it.
2.2WASHING BY MACHINE
Clothes washer technology developed as a way to reduce the manual labor spent,
providing an open basin or sealed container with paddles or fingers to automatically agitate
the clothing. The earliest machines were hand-operated and constructed from wood, while
later machines made of metal permitted a fire to burn below the washtub, keeping the water
warm throughout the day's washing. As electricity was not commonly available until at least
1930, some early washing machines were operated by a low-speed single-cylinder hit and
miss gasoline engine.
Figure 2.4:A see-through Bosch washing machine at the IFA 2010 in Berlin shows off its internal
components
Child lock
Steam
Future functionalities will include energy consumption prognosis before starting the program,
and electricity tariff induced delayed start of the machines. Integration into home local
(wireless) networks will allow to monitor energy demand via different clients like computers
or smart phones.
CHAPTER-3
PROJECT OVERVIEW
Our project is based entirely on the principle of taking non-precise inputs from the
sensor,subjecting them to fuzzy arithmetic using Arduino and obtaining crisp value of
washing time.
In our project we control the operation of washing machine with respect to:
i.
Amount of load
ii.
Degree of dirt
iii.
Type of load
The amount of load is directly proportional to the current drawn by the current
transformer.As the load increases the current drawn will be more and hence the wash time is
decided.
The degree of dirt is determined by the transparency of wash water.Thedirtier the
clothes, less transparent the water being analyzed by the sensors is.The dirt in water is sensed
by optical sensor which gives the output voltage in the range of 0-5 volts. For high level of
contamination of water, the voltage range is low and for low level of contamination the range
is high.
The wash time is varied for different types of load based on the program in Arduino
and also by using fuzzy logic.
3.2.1HARDWARE
The hardware part of our project can be divided into two parts:
1. the basic washing machine and
2. the relevant control circuit.
BASIC WASHING MACHINE
The basic washing machine is constructed as follows. A simple Plastic tub is taken as
the washer drum where the washing takes place. A propeller is fixed to the bottom of the
drum which is used for agitating the water. A normal tap is attached to the bottom of the
drum which is used as the outlet valve to drain the used water. The shaft of the propeller is
coupled to the shaft of a single phase A.C. motor.
CONTROL CIRCUIT
The Control circuit of the washing machine consists of :
i.
ii.
iii.
iv.
POWER CIRCUIT
RELAY CIRCUIT
The relay circuit is used to guide the motor to rotate in the forward and reverse
directions. The circuit consists of relays, transistors(2N2222) and resistors(220ohm). Three
digital output pins of Arduino Uno are connected to each of these and to the three terminals
of the motor.
When the relay gets energized the 230V A.C. gets connected to the respective
terminal of the motor. The programming is done in such a way that the neutral terminal of the
motor should always be connected to the neutral of the supply. The other two terminals are
connected according to the program whenever forward or reverse direction rotation of the
motor is needed.
DIRT SENSOR
The dirt sensor circuit consists of two test tubes in which the LED(Light Emitting
Diode) and LDR(Light Detecting Resistor) are placed. The principle of the dirt sensor is that
when the water is dirtier (i.e., more opaque) the light from the LED falling on the LDR is
less,so the resistance of the LDR increases.The voltage across the resistor which is connected
in series with the LDR reduces.The amount of voltage reduced or increased shows the
dirtiness of the water.
SELECTOR DIAL
There are different varieties of textiles made of different fibers. Some may be of thick
cloth and some are sensitive fiber. For these textiles, the wash time given in the washing
machine varies. Since for hard textiles agitating motion should be more whereas for light
clothes, they may not withstand more washing. For this we are providing a selector switch for
noted textiles like silk, cotton, woolen, nylon, terylen, etc. For which the wash time and the
delay is pre-programmed. Whenever the required textile is selected, the washing machine
runs for the given wash time and delay and stops. This is independent of the fuzzy logic and
used only when the particular clothes needs to be washed. As the fuzzy logic is the last option
of the washing machine. This option takes in all the required parameters and determines the
wash time, which is actually a best way of washing.
3.2.2 SOFTWARE
The software part of our project consists of programming done in Arduino and
interfacing it with the hardware setup.
ARDUINO PROGRAM
voidwashtime(int,int);
void fuzzy(void);
constintstartmotor=10; // starting of motor
constint forward=9; // forward direction
constint reverse=8; // reverse direction
constint voltage=A4; //voltage input
constint current=A5; //current input
//**************initialisation of diff inputs**************
boolean s;
boolean c;
boolean t;
boolean w;
boolean l;
boolean f;
constint silk=2;
constint cotton=3;
constinttereline=4;
constint woolen=5;
constintlenin=6;
constint fuzzy1=7;
// ******************* initialization of revolution count ***************************
int i = 0;
// initialization of revolution
int count = 0; // maximum revolutions
// setup section of the washing machine program
void setup()
{
pinMode(startmotor,OUTPUT); // set up of starting of the machine
pinMode(forward,OUTPUT); //forward direction
pinMode(reverse,OUTPUT); //reverse direction
pinMode(silk,INPUT);
pinMode(cotton,INPUT);
pinMode(tereline,INPUT);
pinMode(woolen,INPUT);
pinMode(lenin,INPUT);
pinMode(fuzzy1,INPUT);
}
// iteration section of washing machine progrom
void loop()
{
s= digitalRead(silk);
c= digitalRead(cotton);
t= digitalRead(tereline);
w= digitalRead(woolen);
l= digitalRead(lenin);
f= digitalRead(fuzzy1);
if(s==LOW)
for(i = 0; i <=10 ; i++)
{
digitalWrite(startmotor,HIGH); // starting of the motor
delay(500);
digitalWrite(forward,HIGH); //forward rotation
digitalWrite(reverse,LOW);
delay(500);
digitalWrite(forward,LOW); //reverse rotation
digitalWrite(reverse,HIGH);
delay(500);
}
else if(c==LOW)
for(i = 0; i <=12 ; i++)
{
digitalWrite(startmotor,HIGH); // starting of the motor
delay(500);
digitalWrite(forward,HIGH); //forward rotation
digitalWrite(reverse,LOW);
delay(2000);
digitalWrite(forward,LOW); //reverse rotation
digitalWrite(reverse,HIGH);
delay(2000);
}
else if(t==LOW)
for(i = 0; i <=16 ; i++)
{
digitalWrite(startmotor,HIGH); // starting of the motor
delay(500);
digitalWrite(forward,HIGH); //forward rotation
digitalWrite(reverse,LOW);
delay(700);
digitalWrite(forward,LOW); //reverse rotation
digitalWrite(reverse,HIGH);
delay(700);
}
else if(w==LOW)
for(i = 0; i <= 20 ; i++)
{
digitalWrite(startmotor,HIGH); // starting of the motor
delay(500);
digitalWrite(forward,HIGH); //forward rotation
digitalWrite(reverse,LOW);
delay(3000);
digitalWrite(forward,LOW); //reverse rotation
digitalWrite(reverse,HIGH);
delay(3000);
}
else if(l==LOW)
for(i = 0; i <= 18 ; i++)
{
digitalWrite(startmotor,HIGH); // starting of the motor
delay(500);
digitalWrite(forward,HIGH); //forward rotation
digitalWrite(reverse,LOW);
delay(2000);
else if(current<=60&¤t>=80)
washtime(18,3000);
else if(current<=80&¤t>=100)
washtime(20,4000);
}
else if(voltage<=60&&voltage>=40)
{
if(current<=0&¤t>=20)
washtime(14,2000);
else if(current<=20&¤t>=40)
washtime(16,2000);
else if(current<=40&¤t>=60)
washtime(18,3000);
else if(current<=60&¤t>=80)
washtime(20,4000);
else if(current<=80&¤t>=100)
washtime(22,4000);
}
else if(voltage<=40&&voltage>=20)
{
if(current<=0&¤t>=20)
washtime(16,2000);
else if(current<=20&¤t>=40)
washtime(18,3000);
else if(current<=40&¤t>=60)
washtime(20,4000);
else if(current<=60&¤t>=80)
washtime(22,4000);
else if(current<=80&¤t>=100)
washtime(24,4000);
}
else if(voltage<=20&&voltage>=0)
{
if(current<=0&¤t>=20)
washtime(18,3000);
else if(current<=20&¤t>=40)
washtime(20,4000);
else if(current<=40&¤t>=60)
washtime(22,4000);
else if(current<=60&¤t>=80)
washtime(24,4000);
else if(current<=80&¤t>=100)
washtime(26,4000);
}
}
CHAPTER-4
ARDUINO
Arduino[2] is an open-source electronics prototyping platform based on flexible, easyto-use hardware and software. It's intended for artists, designers, hobbyists, and anyone
interested in creating interactive objects or environments. Arduino can sense the environment
by receiving input from a variety of sensors and can affect its surroundings by controlling
lights, motors, and other actuators. The microcontroller on the board is programmed using the
Arduino programming language (based on Wiring) and the Arduino development
environment (based on Processing). Arduino projects can be stand-alone or they can
communicate with software running on a computer (e.g. Flash, Processing, MaxMSP).
The boards can be built by hand or purchased preassembled; the software can be
downloaded for free. The hardware reference designs (CAD files) are available under an
open-source license.
Revision 2 of the Uno board has a resistor pulling the 8U2 HWB line to ground,
making it easier to put into DFU mode.
1.0 pinout: added SDA and SCL pins that are near to the AREF pin and two other new
pins placed near to the RESET pin, the IOREF that allow the shields to adapt to the voltage
provided from the board. In future, shields will be compatible both with the board that use the
AVR, which operate with 5V and with the Arduino Due that operate with 3.3V. The second
one is a not connected pin, that is reserved for future purposes.
4.1.1 CHARACTERISTICS
Microcontroller
ATmega328
Operating Voltage
5V
6-20V
40 mA
50 Ma
Flash Memory
SRAM
2 KB (ATmega328)
EEPROM
1 KB (ATmega328)
Clock Speed
16 MHz
The Arduino Uno can be powered via the USB connection or with an external power
supply. The power source is selected automatically. External (non-USB) power can come
either from an AC-to-DC adapter (wall-wart) or battery. The adapter can be connected by
plugging a 2.1mm center-positive plug into the board's power jack. Leads from a battery can
be inserted in the Gnd and Vin pin headers of the POWER connector. The board can operate
on an external supply of 6 to 20 volts. If supplied with less than 7V, however, the 5V pin may
supply less than five volts and the board may be unstable. If using more than 12V, the voltage
regulator may overheat and damage the board. The recommended range is 7 to 12 volts.
VIN.
The input voltage to the Arduino board when it's using an external power source (as opposed
to 5 volts from the USB connection or other regulated power source). You can supply voltage
through this pin, or, if supplying voltage via the power jack, access it through this pin.
5V.
This pin outputs a regulated 5V from the regulator on the board. The board can be supplied
with power either from the DC power jack (7 - 12V), the USB connector (5V), or the VIN pin
of the board (7-12V). Supplying voltage via the 5V or 3.3V pins bypasses the regulator, and
can damage your board. We don't advise it.
3.3V.
A 3.3 volt supply generated by the on-board regulator. Maximum current draw is 50 mA.
GND.
Ground pins.
IOREF
This pin on the Arduino board provides the voltage reference with which the microcontroller
operates. A properly configured shield can read the IOREF pin voltage and select the
appropriate power source or enable voltage translators on the outputs for working with the 5V
or 3.3V.
Memory
The ATmega328 has 32 KB (with 0.5 KB used for the bootloader). It also has 2 KB
of SRAM and 1 KB of EEPROM (which can be read and written with the EEPROM library).
Each of the 14 digital pins on the Uno can be used as an input or output,
using pinMode(), digitalWrite(), and digitalRead()functions. They operate at 5 volts. Each pin
can provide or receive a maximum of 40 mA and has an internal pull-up resistor
(disconnected by default) of 20-50 kOhms. In addition, some pins have specialized functions:
Serial: 0 (RX) and 1 (TX). Used to receive (RX) and transmit (TX) TTL serial data.
These pins are connected to the corresponding pins of the ATmega8U2 USB-to-TTL Serial
chip.
PWM:
3,
5,
6,
9,
10,
and
11. Provide
8-bit
PWM
output
with
LED: 13. There is a built-in LED connected to digital pin 13. When the pin is HIGH
value, the LED is on, when the pin is LOW, it's off.
The Uno has 6 analog inputs, labeled A0 through A5, each of which provide 10 bits of
resolution (i.e. 1024 different values). By default they measure from ground to 5 volts,
though is it possible to change the upper end of their range using the AREF pin and
the analogReference() function. Additionally, some pins have specialized functionality:
TWI: A4 or SDA pin and A5 or SCL pin. Support TWI communication using
the Wire library.
There are a couple of other pins on the board:
AREF. Reference voltage for the analog inputs. Used with analogReference().
Reset. Bring this line LOW to reset the microcontroller. Typically used to add a reset
button to shields which block the one on the board.
4.1.3 COMMUNICATION
The Arduino Uno has a number of facilities for communicating with a computer,
another Arduino, or other microcontrollers. The ATmega328 provides UART TTL (5V)
serial communication, which is available on digital pins 0 (RX) and 1 (TX).
An ATmega16U2 on the board channels this serial communication over USB and appears as
a virtual com port to software on the computer. The '16U2 firmware uses the standard USB
COM drivers, and no external driver is needed. However, on Windows, a .inf file is required.
The Arduino software includes a serial monitor which allows simple textual data to be sent to
and from the Arduino board. The RX and TX LEDs on the board will flash when data is
being transmitted via the USB-to-serial chip and USB connection to the computer (but not for
serial communication on pins 0 and 1).
A SoftwareSerial library allows for serial communication on any of the Uno's digital
pins. The ATmega328 also supports I2C (TWI) and SPI communication. The Arduino
software includes a Wire library to simplify use of the I2C bus; see the documentation for
details. For SPI communication, use the SPI library.
4.1.4 PROGRAMMING
The Arduino Uno can be programmed with the Arduino software (download). Select
"Arduino Uno from the Tools > Board menu (according to the microcontroller on your
board).
The ATmega328 on the Arduino Uno comes preburned with a bootloader that allows
you to upload new code to it without the use of an external hardware programmer. It
communicates using the original STK500 protocol (reference, C header files).
The ATmega16U2 (or 8U2 in the rev1 and rev2 boards) firmware source code is
available . The ATmega16U2/8U2 is loaded with a DFU bootloader, which can be activated
by:
On Rev1 boards: connecting the solder jumper on the back of the board (near the map
of Italy) and then resetting the 8U2.
On Rev2 or later boards: there is a resistor that pulling the 8U2/16U2 HWB line to
ground, making it easier to put into DFU mode.
4.1.5 AUTOMATIC (SOFTWARE) RESET
Rather than requiring a low), the reset line drops long enough to reset the chip. The
Arduino software uses this capability to allow you to upload code by simply pressing the
upload button in the Arduino environment. This means physical press of the reset button
before an upload, the Arduino Uno is designed in a way that allows it to be reset by software
running on a connected computer. One of the hardware flow control lines (DTR) of
theATmega8U2/16U2 is connected to the reset line of the ATmega328 via a 100
nanofaradcapacitor. When this line is asserted (taken that the bootloader can have a shorter
timeout, as the lowering of DTR can be well-coordinated with the start of the upload.
This setup has other implications. When the Uno is connected to either a computer
running Mac OS X or Linux, it resets each time a connection is made to it from software (via
USB). For the following half-second or so, the bootloader is running on the Uno. While it is
programmed to ignore malformed data (i.e. anything besides an upload of new code), it will
intercept the first few bytes of data sent to the board after a connection is opened. If a sketch
running on the board receives one-time configuration or other data when it first starts, make
sure that the software with which it communicates waits a second after opening the
connection and before sending this data.
The Uno contains a trace that can be cut to disable the auto-reset. The pads on either
side of the trace can be soldered together to re-enable it. It's labeled "RESET-EN". You may
also be able to disable the auto-reset by connecting a 110 ohm resistor from 5V to the reset
line; see this forum thread for details.
4.1.6 USB OVERCURRENT PROTECTION
The Arduino Uno has a resettable polyfuse that protects your computer's USB ports
from shorts and overcurrent. Although most computers provide their own internal protection,
the fuse provides an extra layer of protection. If more than 500 mA is applied to the USB
port, the fuse will automatically break the connection until the short or overload is removed.
4.1.7 PHYSICAL CHARACTERISTICS
The maximum length and width of the Uno PCB are 2.7 and 2.1 inches respectively,
with the USB connector and power jack extending beyond the former dimension. Four screw
holes allow the board to be attached to a surface or case. Note that the distance between
digital pins 7 and 8 is 160 mil (0.16"), not an even multiple of the 100 mil spacing of the
other pins.
Arduino programs are written in C or C++. The Arduino IDE comes with a software
library called "Wiring" from the original Wiring project, which makes many common
input/output operations much easier.
CHAPTER-5
FUZZY LOGIC
The concept of Fuzzy Logic[4] (FL) was conceived by LotfiZadeh, a professor at the
University of California at Berkley, and presented not as a control methodology, but as a way
of processing data by allowing partial set membership rather than crisp set membership or
non-membership. This approach to set theory was not applied to control systems until the 70's
due to insufficient small-computer capability prior to that time. Professor Zadeh reasoned that
people do not require precise, numerical information input, and yet they are capable of highly
adaptive control. If feedback controllers could be programmed to accept noisy, imprecise
input, they would be much more effective and perhaps easier to implement. Unfortunately,
U.S. manufacturers have not been so quick to embrace this technology while the Europeans
and Japanese have been aggressively building real products around it.
5.1 DEFINITION
In this context, Fuzzy Logic is a problem-solving control system methodology that
lends itself to implementation in systems ranging from simple, small, embedded microcontrollers to large, networked, multi-channel PC or workstation-based data acquisition and
control systems. It can be implemented in hardware, software, or a combination of both.
Fuzzy Logic provides a simple way to arrive at a definite conclusion based upon vague,
ambiguous, imprecise, noisy, or missing input information. Fuzzy Logic's approach to control
problems mimics how a person would make decisions.
When one uses a washing machine, the person generally select the length of wash
time based on theamount of clothes he/she wish to wash and the type and degree of dirt cloths
have. To automate thisprocess, we use sensors to detect these parameters (i.e. volume of
clothes, degree and type of dirt). Thewash time is then determined from this data.
Unfortunately, there is no easy way to formulate a precisemathematical relationship between
volume of clothes and dirt and the length of wash time required.Consequently, this problem
has remained unsolved until very recently. Conventionally, people simply setwash times by
hand and from personal trial and error experience. Washing machines were not asautomatic
as they could be. The sensor system provides external input signals into the machine
fromwhich decisions can be made. It is the controller's responsibility to make the decisions
and to signal theoutside world by some form of output. Because the input/output relationship
is not clear, the design of awashing machine controller has not in the past lent itself to
traditional methods of control design. Weaddress this design problem using fuzzy logic.
Fuzzy logic has been used because a fuzzy logiccontrolled washing machine controller gives
the correct wash time even though a precise model of input/output relationship is not
available
Details about the Problem
The problem[6]in this project has been simplified by using only two variables. The two inputs
are:
1. Degree of dirt
2. Type of dirt
The fuzzy controller takes two inputs, processes the information and outputs a wash
time. How to get these two inputs can beleft to the sensors (optical, electrical or any type).
The working of the sensors is not a matter of concern inthis paper. We assume that we have
these inputs at our hand. Anyway the two stated points need a bit ofintroduction which
follows. The degree of dirt is determined by the transparency of the wash water. Thedirtier
the clothes, less transparent the water being analyzed by the sensors is. On the other hand,
type ofdirt is determined by the time of saturation, the time it takes to reach saturation.
Saturation is a point, atwhich there is no more appreciable change in the color of the water.
Degree of dirt determines how muchdirty a cloth is. Whereas type of dirt determines the
quality of dirt. Greasy cloths, for example, take longer for water transparency to reach
transparency because grease is less soluble in water than otherforms of dirt. Thus a fairly
straight forward sensor system can provide us the necessary input for our fuzzycontroller.
Before the details of the fuzzy controller are dealt with, the range of possible values
for the input andoutput variables are determined. These (in language of Fuzzy Set theory) are
the membership functionsused to map the real world measurement values to the fuzzy values,
so that the operations can beapplied on them. Values of the input variables degree_of_dirt
and type_of_dirt are normalizedrange (1 to 100) over the domain of optical sensor.The
decision which the fuzzy controller makes is derived from the rules which are stored in the
database.These are stored in a set of rules. Basically the rules are if-then statements that are
intuitive and easy tounderstand, since they are nothing but common English statements. Rules
used in this project are derivedfrom common sense, data taken from typical home use, and
experimentation in a controlled environment.
The rules too have been defined in imprecise sense and hence they too are not crisp
but fuzzy values.The two input parameters after being read from the sensors are fuzzified as
per the membership function of the respective variables. These in additions with the
membership function curve are utilized to come to a solution (using some criteria). At last the
crisp value of the washtime is obtained as an answer.
CONCLUSION
By the use of fuzzy logic control along with manual control options using a selector
dial we have been able to obtain a wash time for different type of load and different degree of
dirt. The conventional method required the human interruption to decide upon what should be
the wash time for different cloths. In other words this situation analysis ability has been
incorporated in the machine which makes the machine much more automatic and represents
the decision taking power of the new arrangement. Though the analysis in this project has
been very basic, but this clearly depicts the advantage of adding the fuzzy logic controller in
the conventional washing machine.
FUTURE SCOPE
A more fully automatic washing machine is straightforward to design using fuzzy
logic technology. Moreover, the design process mimics human intuition, which adds to the
ease of development and future maintenance. Although this particular example controls only
the wash time of a washing machine, the design process can be extended without undue
complications to other control variables such as water level and spin speed. The formulation
and implementation of membership functions and rules is similar to that shown for wash
time.
REFERENCES
1. History of washing machines
http://en.wikipedia.org/wiki/Washing_machine
2. Arduino
http://www.arduino.cc/
3. Labview
http://en.wikipedia.org/wiki/LabVIEW
4. Fuzzynet technical case studies
http://www.aptronix.com/
5. Technical manual of washing machines, Samsung electronics ;
http://www.samsungelectronics.com.my/washing_machine/tech_info/index.html
6. Weijing Zhang, Applications Engineer, Aptronics Incorporated, Copyright 1992 by
Aptronix Inc.
APPENDIX
APPENDIX A
TRANSISTOR 2N2222
APPENDIX B
12V D.C. RELAY COIL
Detail Parameter
Outline Dimensions
Contact Arrangement
(China)
1H, 1D, 1Z
(International)
1A, 1B, 1C
Contact Rating
10A/220VAC TV-8
<=100 m
420W 1800VA
100Vdc 380Vac
15A
1 107
1 105
Coil resistance
0.36, 0.45W
12
Release voltageVDC(min)
Operate Time
<=15ms
Release Time
<=5ms
Coil MaximanVoltageVDC
Insulation Resistance
Dielectric Strength
(Between contacts)
50Hz, 750V
50Hz, 1500V
Shock Resistance
10G
Vibration resistance
Ambient Temperature
-40 ~ 70 C
Relative Humidity
85% (at 40 C)
Mass
13g
Cross Reference
ORIGINAL SRU
APPENDIX - C
SINGLE PHASE A.C. MOTOR
As a "rules of thumb" amps horsepower rating can be estimated as
Always check nameplate information before designing protective devices, wiring and
switchgear.
Motor Size
(hp)
115 V
208 V
230 V
1/6
4.4
2.4
2.2
5.8
3.2
2.9
1/3
7.2
4.0
3.6
9.8
5.4
4.9
13.8
7.6
6.9
16
8.8
1 1/2
20
11
10
24
13.2
12
34
18.7
17
56
30.8
28