Upcycling Dishwasher

I used an Arduino Nano to fix my dishwasher.

Oct 7, 2020

•

31073 views

•

7 respects

dishwasher

home automation

Devices & Components

Arduino Nano

thermistor 10k

SparkFun 7-Segment Serial Display - Red

PHPoC 4-Port Relay Expansion Board (S-type or T-type)

Breadboard (generic)

Resistor 2.21k ohm

Rotary potentiometer (generic)

Hardware & Tools

Soldering iron (generic)

Drill / Driver, Cordless

Software & Tools

Arduino IDE

Project description

Code

dishwasher

c_cpp

1#include "TM1637.h"
2#define SEG_A 1   //      -- A --
3#define  SEG_B 2   //     |       |
4#define SEG_C 4   //     F       B
5#define SEG_D  8   //     |       |
6#define SEG_E 16  //      -- G --
7#define SEG_F 32  //     |       |
8#define SEG_G 64  //     E       C
9//                       |       |
10//                        -- D --
11// washing time
12int w_time =  40 * 60; // washing time in minutes
13int w_temp = 60;      // washing temperature
14int  r_time = 10 * 60; // rinsing time in minutes
15
16// pins
17const int pinPumpDir  = 12;    // relay - pump direction : wash/flush
18const int pinPumpPow = 11;    //  relay - pump power
19const int pinHeater  = 10;    // relay - heater
20const int  pinWatInlet = 9;    // relay - water inlet valve
21const int pinDoor  = 8;    //  switch on door
22const int pinModeSel  = 7;    // switch for mode select: temp/time  setting
23const int WaterSensorHig = 6; // switch on floater
24const int WaterSensorLow  = 5; // switch on floater
25const int pinLedDio = 4;      // I2C pin for TM1637  LCD
26const int pinLedClk = 3;      // I2C pin for TM1637 LCD
27// analog pins
28int  PinThermistor = 6;
29int PinPotMeter = 5;
30
31// variables
32int temp;
33int  potMeter;
34int WaterLow = 0;
35int WaterHig = 0;
36int doorState = 0;           //  variable for reading the pushbutton status
37unsigned long time_curr;    // current  timestamp
38unsigned long seconds;
39unsigned long time_cstart;  // cycle start  timestamp
40
41// motor modes
42#define mstop 0
43#define mwash 1
44#define  mflush 2
45
46TM1637 tm1637(pinLedClk, pinLedDio);
47
48// washing state
49int  w_cycle = 0;   // washing cycle varibale walking on below values
50#define w_start  0 // just started: wait for door to be closed, flush all remaining water for at  least 10 sec
51#define w_fill   1 // fill for washing
52#define w_wash   2 //  wash the dishes + heat to 40 Celsuis
53#define w_wflush 3 // flush washing water
54#define  r_fill   4 // fill for rinsing 
55#define r_rinse  5 // rinsing         + heat  to 30 Celsuis
56#define r_flush  6 // flush rinsing water
57#define r_finshed  7 // flush rinsing water
58
59// ========================================================================================================================
60void  showLed(uint8_t BitAddr, int8_t DispData)
61{
62  tm1637.start();          //start  signal sent to TM1637 from MCU
63  tm1637.writeByte(ADDR_FIXED);//
64  tm1637.stop();           //
65  tm1637.start();          //
66  tm1637.writeByte(BitAddr | 0xc0);  //
67  tm1637.writeByte(DispData);//
68  tm1637.stop();            //
69}
70
71//  the setup function runs once when you press reset or power the board ===================================================
72void  setup() {
73  Serial.begin(9600);
74  Serial.println();
75  Serial.println("start=============");
76
77  pinMode(pinPumpPow, OUTPUT);
78  pinMode(pinPumpDir, OUTPUT);
79  pinMode(pinWatInlet,  OUTPUT);
80  pinMode(pinHeater, OUTPUT);
81
82  pinMode(WaterSensorLow, INPUT);  // init water low sensor
83  pinMode(WaterSensorHig, INPUT);  // init water high  sensor
84  pinMode(pinDoor, INPUT);      // init door sensor
85
86  tm1637.init();                  // init lcd
87  tm1637.set(6);                  // set brightness
88  tm1637.display(0, 8);           // show 'booted'
89  tm1637.display(1, 8);
90  tm1637.display(2, 8);
91  tm1637.display(3, 8);
92  /*
93    for(int i=0;i<=8;i++)
94    {
95    showLed(0x02,1|2);delay(1000);
96    showLed(0x02,2|64);delay(1000);
97    showLed(0x02,64|32);delay(1000);
98    showLed(0x02,32|1);delay(1000);
99    }
100  */
101  digitalWrite(pinPumpPow, HIGH); // stop flush
102  digitalWrite(pinPumpDir,  HIGH); // stop pump
103  digitalWrite(pinWatInlet, HIGH); // stop water valve
104  digitalWrite(pinHeater, HIGH); // stop heater
105}
106// ========================================================================================================================
107void  setTemp(int level) {
108  if (getTemp() < level)  {
109    digitalWrite(pinHeater,  LOW); Serial.print(", pinHeater:LOW");
110  } else {
111    digitalWrite(pinHeater,  HIGH); Serial.print(", pinHeater:HIGH");
112  }
113}
114// ========================================================================================================================
115int  getTemp() {
116  int Vo;
117  float R1 = 10000;
118  float logR2, R2, T, Tc;
119  float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
120
121  Vo = analogRead(PinThermistor);
122  R2 = R1 * (1023.0 / (float)Vo - 1.0);
123  logR2 = log(R2);
124  T = (1.0 / (c1 + c2 * logR2 + c3 * logR2 * logR2 * logR2));
125  Tc = T - 273.15;
126  return (int)Tc;
127}
128// ========================================================================================================================
129void  manage()
130{
131  while (WaterHig == 1) {
132    tm1637.display(0, 10);  // A
133    pump(mflush);
134    delay(100);
135    WaterHig = digitalRead(WaterSensorHig);
136  }
137  while (doorState == 0) {
138    tm1637.display(0, 11);  // B
139    pump(mstop);
140    delay(100);
141    doorState = digitalRead(pinDoor);
142  }
143}
144// ========================================================================================================================
145void  readInput() {
146  temp = getTemp();
147  WaterLow = digitalRead(WaterSensorLow);
148  WaterHig = digitalRead(WaterSensorHig);
149  doorState = digitalRead(pinDoor);
150}
151
152#define  w_out     0 // 
153#define w_normal  1 // 
154
155// ========================================================================================================================
156void  setWaterLevel(int level)
157{
158  switch (level) {
159    case w_out:
160      digitalWrite(pinWatInlet,  HIGH);    // close water inlet valve
161      while (digitalRead(WaterSensorLow)  == 0) {
162        if (digitalRead(pinDoor) == 0)
163          pump(mstop);
164        else
165          pump(mflush);
166        showLed(0, SEG_C | SEG_D | SEG_E  | SEG_G);
167        showLed(1, SEG_C | SEG_D | SEG_E);
168        showLed(2, SEG_D  | SEG_E | SEG_F | SEG_G);
169        showLed(3, 0);
170        delay(100);
171      }
172      delay(10000);
173      pump(mstop);
174      break;
175
176    case w_normal:
177      while (digitalRead(WaterSensorLow) == 1) {
178        if (digitalRead(pinDoor)  == 0)
179          pump(mstop);
180        digitalWrite(pinWatInlet, LOW);     //  open water inlet valve
181        showLed(0, SEG_C);
182        showLed(1, SEG_E  | SEG_G | SEG_C);
183        showLed(2, 0);
184        showLed(3, 0);
185        delay(100);
186      }
187      digitalWrite(pinWatInlet, HIGH);    // close water inlet valve
188      break;
189  }
190}
191// ========================================================================================================================
192void  witeLCD()
193{
194  // Show the state of pushbutton on serial monitor
195  Serial.print(",  WaterLow:");
196  Serial.print(WaterLow);
197  Serial.print(", WaterHig:");
198  Serial.print(WaterHig);
199  Serial.print(", doorState:");
200  Serial.print(doorState);
201
202  Serial.print(", w_cycle:");
203  Serial.print(w_cycle);
204  witeLCDTemp(temp);
205}
206void  witeLCDTime(int data)
207{
208  Serial.print("LCDTime:");
209  Serial.print(data  / 60);
210  Serial.print(":");
211  Serial.println(data % 60);
212  if (data >  60) {
213    tm1637.display(0, data / 60 / 10);
214    tm1637.display(1, data /  60 % 10);
215  }
216  else {
217    tm1637.display(0, data / 10);
218    tm1637.display(1,  data % 10);
219  }
220}
221void witeLCDTemp(int data)
222{
223  Serial.print("LCDTemp:");
224  Serial.println(data);
225  tm1637.display(2, data / 10);
226  tm1637.display(3,  data % 10);
227}
228// the loop function runs over and over again forever =====================================================================
229void  loop() {
230  while (digitalRead(WaterSensorHig) == 1) {
231    tm1637.display(0,  10);  // A
232    pump(mflush);
233    delay(100);
234  }
235
236  readInput();
237  witeLCD();
238
239  switch (w_cycle) {
240    case w_start:                   //  0 - start
241      setTemp(0);                   // stop heater
242      // started  with door opened - let user change the washing parameters: time/temperature
243      if (digitalRead(pinDoor) == 0) {
244        while (digitalRead(pinDoor) ==  0) {
245          potMeter = analogRead(PinPotMeter) / 10 - 33;   //545 - 1020
246          if (digitalRead(pinModeSel)) {
247            w_temp = potMeter;                //  24..69 celsius
248            witeLCDTemp(w_temp);
249          }
250          else  {
251            w_time = (potMeter * 90) - 1600;  // 6..76 minutes
252            witeLCDTime(w_time);
253          }
254          delay(100);
255        }
256      } else {
257        if  (digitalRead(pinModeSel)) {
258          w_temp = 60;                // 24..69 celsius
259          w_time = 50 * 60;           // 6..76 minutes
260        }
261        else  {
262          w_temp = 40;                // 24..69 celsius
263          w_time  = 30 * 60;           // 6..76 minutes
264        }
265        witeLCDTemp(w_temp);
266        witeLCDTime(w_time);
267        delay(5000);
268      }
269      Serial.print("temp:");
270      Serial.print(w_temp);
271      Serial.print(", time:");
272      Serial.println(w_time);
273      setWaterLevel(w_out);         // flush all remaning water
274      w_cycle++;
275      time_cstart = millis();
276      break;
277
278    case r_fill:                    //  4 - fill for rinsing
279    case w_fill:                    // 1 - fill for washing
280      setWaterLevel(w_normal);
281      time_cstart = millis();
282      w_cycle++;
283      break;
284
285    case w_wash:                   // 2 - wash
286      setTemp(w_temp);
287      pump(mwash);
288      setWaterLevel(w_normal);     // check again water level
289      seconds = (millis() - time_cstart) / 1000;
290      witeLCDTime(w_time - seconds);
291      if (seconds >= w_time)
292        w_cycle++;
293      break;
294
295    case  r_rinse:                 // 5 - rinsing
296      setTemp(30);
297      pump(mwash);
298      setWaterLevel(w_normal);
299      seconds = (millis() - time_cstart) / 1000;
300      witeLCDTime(r_time - seconds);
301      if (seconds >= r_time)
302        w_cycle++;
303      break;
304
305    case w_wflush:                // 3 - flush washing water
306    case r_flush:                 // 6 - flush rinsing water
307      setTemp(0);                   // stop the heater
308      pump(mstop);                  //  stop the pump
309      delay(1000);                  // wait for pump to stop
310      setWaterLevel(w_out);
311      w_cycle++;
312      break;
313  }
314  Serial.println();
315  delay(1000);                       // wait for a second
316}
317
318void pump(int  mode)
319{
320  if (doorState == 0) {             // door is open
321    Serial.println("pump:door");
322    digitalWrite(pinPumpPow, HIGH);    // stop pump
323  }  else {
324    switch  (mode) {
325      case 0:
326        digitalWrite(pinPumpPow, HIGH); // stop pump
327        break;
328      case 1:                       // wash
329        digitalWrite(pinPumpDir,  LOW);   // set rotation to wash the dishes
330        digitalWrite(pinPumpPow, LOW);   // start pump
331        break;
332      case 2:                       // flush  to drain
333        digitalWrite(pinPumpDir, HIGH);   // set rotation to flush into  drain
334        digitalWrite(pinPumpPow, LOW);    // start pump
335        break;
336    }
337  }
338}
339

#include "TM1637.h"
#define SEG_A 1   //      -- A --
#define  SEG_B 2   //     |       |
#define SEG_C 4   //     F       B
#define SEG_D  8   //     |       |
#define SEG_E 16  //      -- G --
#define SEG_F 32  //     |       |
#define SEG_G 64  //     E       C
//                       |       |
//                        -- D --
// washing time
int w_time =  40 * 60; // washing time in minutes
int w_temp = 60;      // washing temperature
int  r_time = 10 * 60; // rinsing time in minutes

// pins
const int pinPumpDir  = 12;    // relay - pump direction : wash/flush
const int pinPumpPow = 11;    //  relay - pump power
const int pinHeater  = 10;    // relay - heater
const int  pinWatInlet = 9;    // relay - water inlet valve
const int pinDoor  = 8;    //  switch on door
const int pinModeSel  = 7;    // switch for mode select: temp/time  setting
const int WaterSensorHig = 6; // switch on floater
const int WaterSensorLow  = 5; // switch on floater
const int pinLedDio = 4;      // I2C pin for TM1637  LCD
const int pinLedClk = 3;      // I2C pin for TM1637 LCD
// analog pins
int  PinThermistor = 6;
int PinPotMeter = 5;

// variables
int temp;
int  potMeter;
int WaterLow = 0;
int WaterHig = 0;
int doorState = 0;           //  variable for reading the pushbutton status
unsigned long time_curr;    // current  timestamp
unsigned long seconds;
unsigned long time_cstart;  // cycle start  timestamp

// motor modes
#define mstop 0
#define mwash 1
#define  mflush 2

TM1637 tm1637(pinLedClk, pinLedDio);

// washing state
int  w_cycle = 0;   // washing cycle varibale walking on below values
#define w_start  0 // just started: wait for door to be closed, flush all remaining water for at  least 10 sec
#define w_fill   1 // fill for washing
#define w_wash   2 //  wash the dishes + heat to 40 Celsuis
#define w_wflush 3 // flush washing water
#define  r_fill   4 // fill for rinsing 
#define r_rinse  5 // rinsing         + heat  to 30 Celsuis
#define r_flush  6 // flush rinsing water
#define r_finshed  7 // flush rinsing water

// ========================================================================================================================
void  showLed(uint8_t BitAddr, int8_t DispData)
{
  tm1637.start();          //start  signal sent to TM1637 from MCU
  tm1637.writeByte(ADDR_FIXED);//
  tm1637.stop();           //
  tm1637.start();          //
  tm1637.writeByte(BitAddr | 0xc0);  //
  tm1637.writeByte(DispData);//
  tm1637.stop();            //
}

//  the setup function runs once when you press reset or power the board ===================================================
void  setup() {
  Serial.begin(9600);
  Serial.println();
  Serial.println("start=============");

  pinMode(pinPumpPow, OUTPUT);
  pinMode(pinPumpDir, OUTPUT);
  pinMode(pinWatInlet,  OUTPUT);
  pinMode(pinHeater, OUTPUT);

  pinMode(WaterSensorLow, INPUT);  // init water low sensor
  pinMode(WaterSensorHig, INPUT);  // init water high  sensor
  pinMode(pinDoor, INPUT);      // init door sensor

  tm1637.init();                  // init lcd
  tm1637.set(6);                  // set brightness
  tm1637.display(0, 8);           // show 'booted'
  tm1637.display(1, 8);
  tm1637.display(2, 8);
  tm1637.display(3, 8);
  /*
    for(int i=0;i<=8;i++)
    {
    showLed(0x02,1|2);delay(1000);
    showLed(0x02,2|64);delay(1000);
    showLed(0x02,64|32);delay(1000);
    showLed(0x02,32|1);delay(1000);
    }
  */
  digitalWrite(pinPumpPow, HIGH); // stop flush
  digitalWrite(pinPumpDir,  HIGH); // stop pump
  digitalWrite(pinWatInlet, HIGH); // stop water valve
  digitalWrite(pinHeater, HIGH); // stop heater
}
// ========================================================================================================================
void  setTemp(int level) {
  if (getTemp() < level)  {
    digitalWrite(pinHeater,  LOW); Serial.print(", pinHeater:LOW");
  } else {
    digitalWrite(pinHeater,  HIGH); Serial.print(", pinHeater:HIGH");
  }
}
// ========================================================================================================================
int  getTemp() {
  int Vo;
  float R1 = 10000;
  float logR2, R2, T, Tc;
  float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;

  Vo = analogRead(PinThermistor);
  R2 = R1 * (1023.0 / (float)Vo - 1.0);
  logR2 = log(R2);
  T = (1.0 / (c1 + c2 * logR2 + c3 * logR2 * logR2 * logR2));
  Tc = T - 273.15;
  return (int)Tc;
}
// ========================================================================================================================
void  manage()
{
  while (WaterHig == 1) {
    tm1637.display(0, 10);  // A
    pump(mflush);
    delay(100);
    WaterHig = digitalRead(WaterSensorHig);
  }
  while (doorState == 0) {
    tm1637.display(0, 11);  // B
    pump(mstop);
    delay(100);
    doorState = digitalRead(pinDoor);
  }
}
// ========================================================================================================================
void  readInput() {
  temp = getTemp();
  WaterLow = digitalRead(WaterSensorLow);
  WaterHig = digitalRead(WaterSensorHig);
  doorState = digitalRead(pinDoor);
}

#define  w_out     0 // 
#define w_normal  1 // 

// ========================================================================================================================
void  setWaterLevel(int level)
{
  switch (level) {
    case w_out:
      digitalWrite(pinWatInlet,  HIGH);    // close water inlet valve
      while (digitalRead(WaterSensorLow)  == 0) {
        if (digitalRead(pinDoor) == 0)
          pump(mstop);
        else
          pump(mflush);
        showLed(0, SEG_C | SEG_D | SEG_E  | SEG_G);
        showLed(1, SEG_C | SEG_D | SEG_E);
        showLed(2, SEG_D  | SEG_E | SEG_F | SEG_G);
        showLed(3, 0);
        delay(100);
      }
      delay(10000);
      pump(mstop);
      break;

    case w_normal:
      while (digitalRead(WaterSensorLow) == 1) {
        if (digitalRead(pinDoor)  == 0)
          pump(mstop);
        digitalWrite(pinWatInlet, LOW);     //  open water inlet valve
        showLed(0, SEG_C);
        showLed(1, SEG_E  | SEG_G | SEG_C);
        showLed(2, 0);
        showLed(3, 0);
        delay(100);
      }
      digitalWrite(pinWatInlet, HIGH);    // close water inlet valve
      break;
  }
}
// ========================================================================================================================
void  witeLCD()
{
  // Show the state of pushbutton on serial monitor
  Serial.print(",  WaterLow:");
  Serial.print(WaterLow);
  Serial.print(", WaterHig:");
  Serial.print(WaterHig);
  Serial.print(", doorState:");
  Serial.print(doorState);

  Serial.print(", w_cycle:");
  Serial.print(w_cycle);
  witeLCDTemp(temp);
}
void  witeLCDTime(int data)
{
  Serial.print("LCDTime:");
  Serial.print(data  / 60);
  Serial.print(":");
  Serial.println(data % 60);
  if (data >  60) {
    tm1637.display(0, data / 60 / 10);
    tm1637.display(1, data /  60 % 10);
  }
  else {
    tm1637.display(0, data / 10);
    tm1637.display(1,  data % 10);
  }
}
void witeLCDTemp(int data)
{
  Serial.print("LCDTemp:");
  Serial.println(data);
  tm1637.display(2, data / 10);
  tm1637.display(3,  data % 10);
}
// the loop function runs over and over again forever =====================================================================
void  loop() {
  while (digitalRead(WaterSensorHig) == 1) {
    tm1637.display(0,  10);  // A
    pump(mflush);
    delay(100);
  }

  readInput();
  witeLCD();

  switch (w_cycle) {
    case w_start:                   //  0 - start
      setTemp(0);                   // stop heater
      // started  with door opened - let user change the washing parameters: time/temperature
      if (digitalRead(pinDoor) == 0) {
        while (digitalRead(pinDoor) ==  0) {
          potMeter = analogRead(PinPotMeter) / 10 - 33;   //545 - 1020
          if (digitalRead(pinModeSel)) {
            w_temp = potMeter;                //  24..69 celsius
            witeLCDTemp(w_temp);
          }
          else  {
            w_time = (potMeter * 90) - 1600;  // 6..76 minutes
            witeLCDTime(w_time);
          }
          delay(100);
        }
      } else {
        if  (digitalRead(pinModeSel)) {
          w_temp = 60;                // 24..69 celsius
          w_time = 50 * 60;           // 6..76 minutes
        }
        else  {
          w_temp = 40;                // 24..69 celsius
          w_time  = 30 * 60;           // 6..76 minutes
        }
        witeLCDTemp(w_temp);
        witeLCDTime(w_time);
        delay(5000);
      }
      Serial.print("temp:");
      Serial.print(w_temp);
      Serial.print(", time:");
      Serial.println(w_time);
      setWaterLevel(w_out);         // flush all remaning water
      w_cycle++;
      time_cstart = millis();
      break;

    case r_fill:                    //  4 - fill for rinsing
    case w_fill:                    // 1 - fill for washing
      setWaterLevel(w_normal);
      time_cstart = millis();
      w_cycle++;
      break;

    case w_wash:                   // 2 - wash
      setTemp(w_temp);
      pump(mwash);
      setWaterLevel(w_normal);     // check again water level
      seconds = (millis() - time_cstart) / 1000;
      witeLCDTime(w_time - seconds);
      if (seconds >= w_time)
        w_cycle++;
      break;

    case  r_rinse:                 // 5 - rinsing
      setTemp(30);
      pump(mwash);
      setWaterLevel(w_normal);
      seconds = (millis() - time_cstart) / 1000;
      witeLCDTime(r_time - seconds);
      if (seconds >= r_time)
        w_cycle++;
      break;

    case w_wflush:                // 3 - flush washing water
    case r_flush:                 // 6 - flush rinsing water
      setTemp(0);                   // stop the heater
      pump(mstop);                  //  stop the pump
      delay(1000);                  // wait for pump to stop
      setWaterLevel(w_out);
      w_cycle++;
      break;
  }
  Serial.println();
  delay(1000);                       // wait for a second
}

void pump(int  mode)
{
  if (doorState == 0) {             // door is open
    Serial.println("pump:door");
    digitalWrite(pinPumpPow, HIGH);    // stop pump
  }  else {
    switch  (mode) {
      case 0:
        digitalWrite(pinPumpPow, HIGH); // stop pump
        break;
      case 1:                       // wash
        digitalWrite(pinPumpDir,  LOW);   // set rotation to wash the dishes
        digitalWrite(pinPumpPow, LOW);   // start pump
        break;
      case 2:                       // flush  to drain
        digitalWrite(pinPumpDir, HIGH);   // set rotation to flush into  drain
        digitalWrite(pinPumpPow, LOW);    // start pump
        break;
    }
  }
}

dishwasher

c_cpp

1#include "TM1637.h"
2#define SEG_A 1   //      -- A --
3#define
4  SEG_B 2   //     |       |
5#define SEG_C 4   //     F       B
6#define SEG_D
7  8   //     |       |
8#define SEG_E 16  //      -- G --
9#define SEG_F 32  //
10     |       |
11#define SEG_G 64  //     E       C
12//                       |
13       |
14//                        -- D --
15// washing time
16int w_time =
17  40 * 60; // washing time in minutes
18int w_temp = 60;      // washing temperature
19int
20  r_time = 10 * 60; // rinsing time in minutes
21
22// pins
23const int pinPumpDir
24  = 12;    // relay - pump direction : wash/flush
25const int pinPumpPow = 11;    //
26  relay - pump power
27const int pinHeater  = 10;    // relay - heater
28const int
29  pinWatInlet = 9;    // relay - water inlet valve
30const int pinDoor  = 8;    //
31  switch on door
32const int pinModeSel  = 7;    // switch for mode select: temp/time
33  setting
34const int WaterSensorHig = 6; // switch on floater
35const int WaterSensorLow
36  = 5; // switch on floater
37const int pinLedDio = 4;      // I2C pin for TM1637
38  LCD
39const int pinLedClk = 3;      // I2C pin for TM1637 LCD
40// analog pins
41int
42  PinThermistor = 6;
43int PinPotMeter = 5;
44
45// variables
46int temp;
47int
48  potMeter;
49int WaterLow = 0;
50int WaterHig = 0;
51int doorState = 0;           //
52  variable for reading the pushbutton status
53unsigned long time_curr;    // current
54  timestamp
55unsigned long seconds;
56unsigned long time_cstart;  // cycle start
57  timestamp
58
59// motor modes
60#define mstop 0
61#define mwash 1
62#define
63  mflush 2
64
65TM1637 tm1637(pinLedClk, pinLedDio);
66
67// washing state
68int
69  w_cycle = 0;   // washing cycle varibale walking on below values
70#define w_start
71  0 // just started: wait for door to be closed, flush all remaining water for at
72  least 10 sec
73#define w_fill   1 // fill for washing
74#define w_wash   2 //
75  wash the dishes + heat to 40 Celsuis
76#define w_wflush 3 // flush washing water
77#define
78  r_fill   4 // fill for rinsing 
79#define r_rinse  5 // rinsing         + heat
80  to 30 Celsuis
81#define r_flush  6 // flush rinsing water
82#define r_finshed
83  7 // flush rinsing water
84
85// ========================================================================================================================
86void
87  showLed(uint8_t BitAddr, int8_t DispData)
88{
89  tm1637.start();          //start
90  signal sent to TM1637 from MCU
91  tm1637.writeByte(ADDR_FIXED);//
92  tm1637.stop();
93           //
94  tm1637.start();          //
95  tm1637.writeByte(BitAddr | 0xc0);
96  //
97  tm1637.writeByte(DispData);//
98  tm1637.stop();            //
99}
100
101//
102  the setup function runs once when you press reset or power the board ===================================================
103void
104  setup() {
105  Serial.begin(9600);
106  Serial.println();
107  Serial.println("start=============");
108
109
110  pinMode(pinPumpPow, OUTPUT);
111  pinMode(pinPumpDir, OUTPUT);
112  pinMode(pinWatInlet,
113  OUTPUT);
114  pinMode(pinHeater, OUTPUT);
115
116  pinMode(WaterSensorLow, INPUT);
117  // init water low sensor
118  pinMode(WaterSensorHig, INPUT);  // init water high
119  sensor
120  pinMode(pinDoor, INPUT);      // init door sensor
121
122  tm1637.init();
123                  // init lcd
124  tm1637.set(6);                  // set brightness
125
126  tm1637.display(0, 8);           // show 'booted'
127  tm1637.display(1, 8);
128
129  tm1637.display(2, 8);
130  tm1637.display(3, 8);
131  /*
132    for(int i=0;i<=8;i++)
133
134    {
135    showLed(0x02,1|2);delay(1000);
136    showLed(0x02,2|64);delay(1000);
137
138    showLed(0x02,64|32);delay(1000);
139    showLed(0x02,32|1);delay(1000);
140
141    }
142  */
143  digitalWrite(pinPumpPow, HIGH); // stop flush
144  digitalWrite(pinPumpDir,
145  HIGH); // stop pump
146  digitalWrite(pinWatInlet, HIGH); // stop water valve
147
148  digitalWrite(pinHeater, HIGH); // stop heater
149}
150// ========================================================================================================================
151void
152  setTemp(int level) {
153  if (getTemp() < level)  {
154    digitalWrite(pinHeater,
155  LOW); Serial.print(", pinHeater:LOW");
156  } else {
157    digitalWrite(pinHeater,
158  HIGH); Serial.print(", pinHeater:HIGH");
159  }
160}
161// ========================================================================================================================
162int
163  getTemp() {
164  int Vo;
165  float R1 = 10000;
166  float logR2, R2, T, Tc;
167
168  float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
169
170
171  Vo = analogRead(PinThermistor);
172  R2 = R1 * (1023.0 / (float)Vo - 1.0);
173
174  logR2 = log(R2);
175  T = (1.0 / (c1 + c2 * logR2 + c3 * logR2 * logR2 * logR2));
176
177  Tc = T - 273.15;
178  return (int)Tc;
179}
180// ========================================================================================================================
181void
182  manage()
183{
184  while (WaterHig == 1) {
185    tm1637.display(0, 10);  // A
186
187    pump(mflush);
188    delay(100);
189    WaterHig = digitalRead(WaterSensorHig);
190
191  }
192  while (doorState == 0) {
193    tm1637.display(0, 11);  // B
194    pump(mstop);
195
196    delay(100);
197    doorState = digitalRead(pinDoor);
198  }
199}
200// ========================================================================================================================
201void
202  readInput() {
203  temp = getTemp();
204  WaterLow = digitalRead(WaterSensorLow);
205
206  WaterHig = digitalRead(WaterSensorHig);
207  doorState = digitalRead(pinDoor);
208}
209
210#define
211  w_out     0 // 
212#define w_normal  1 // 
213
214// ========================================================================================================================
215void
216  setWaterLevel(int level)
217{
218  switch (level) {
219    case w_out:
220      digitalWrite(pinWatInlet,
221  HIGH);    // close water inlet valve
222      while (digitalRead(WaterSensorLow)
223  == 0) {
224        if (digitalRead(pinDoor) == 0)
225          pump(mstop);
226
227        else
228          pump(mflush);
229        showLed(0, SEG_C | SEG_D | SEG_E
230  | SEG_G);
231        showLed(1, SEG_C | SEG_D | SEG_E);
232        showLed(2, SEG_D
233  | SEG_E | SEG_F | SEG_G);
234        showLed(3, 0);
235        delay(100);
236      }
237
238      delay(10000);
239      pump(mstop);
240      break;
241
242    case w_normal:
243
244      while (digitalRead(WaterSensorLow) == 1) {
245        if (digitalRead(pinDoor)
246  == 0)
247          pump(mstop);
248        digitalWrite(pinWatInlet, LOW);     //
249  open water inlet valve
250        showLed(0, SEG_C);
251        showLed(1, SEG_E
252  | SEG_G | SEG_C);
253        showLed(2, 0);
254        showLed(3, 0);
255        delay(100);
256
257      }
258      digitalWrite(pinWatInlet, HIGH);    // close water inlet valve
259
260      break;
261  }
262}
263// ========================================================================================================================
264void
265  witeLCD()
266{
267  // Show the state of pushbutton on serial monitor
268  Serial.print(",
269  WaterLow:");
270  Serial.print(WaterLow);
271  Serial.print(", WaterHig:");
272
273  Serial.print(WaterHig);
274  Serial.print(", doorState:");
275  Serial.print(doorState);
276
277
278  Serial.print(", w_cycle:");
279  Serial.print(w_cycle);
280  witeLCDTemp(temp);
281}
282void
283  witeLCDTime(int data)
284{
285  Serial.print("LCDTime:");
286  Serial.print(data
287  / 60);
288  Serial.print(":");
289  Serial.println(data % 60);
290  if (data >
291  60) {
292    tm1637.display(0, data / 60 / 10);
293    tm1637.display(1, data /
294  60 % 10);
295  }
296  else {
297    tm1637.display(0, data / 10);
298    tm1637.display(1,
299  data % 10);
300  }
301}
302void witeLCDTemp(int data)
303{
304  Serial.print("LCDTemp:");
305
306  Serial.println(data);
307  tm1637.display(2, data / 10);
308  tm1637.display(3,
309  data % 10);
310}
311// the loop function runs over and over again forever =====================================================================
312void
313  loop() {
314  while (digitalRead(WaterSensorHig) == 1) {
315    tm1637.display(0,
316  10);  // A
317    pump(mflush);
318    delay(100);
319  }
320
321  readInput();
322
323  witeLCD();
324
325  switch (w_cycle) {
326    case w_start:                   //
327  0 - start
328      setTemp(0);                   // stop heater
329      // started
330  with door opened - let user change the washing parameters: time/temperature
331
332      if (digitalRead(pinDoor) == 0) {
333        while (digitalRead(pinDoor) ==
334  0) {
335          potMeter = analogRead(PinPotMeter) / 10 - 33;   //545 - 1020
336
337          if (digitalRead(pinModeSel)) {
338            w_temp = potMeter;                //
339  24..69 celsius
340            witeLCDTemp(w_temp);
341          }
342          else
343  {
344            w_time = (potMeter * 90) - 1600;  // 6..76 minutes
345            witeLCDTime(w_time);
346
347          }
348          delay(100);
349        }
350      } else {
351        if
352  (digitalRead(pinModeSel)) {
353          w_temp = 60;                // 24..69 celsius
354
355          w_time = 50 * 60;           // 6..76 minutes
356        }
357        else
358  {
359          w_temp = 40;                // 24..69 celsius
360          w_time
361  = 30 * 60;           // 6..76 minutes
362        }
363        witeLCDTemp(w_temp);
364
365        witeLCDTime(w_time);
366        delay(5000);
367      }
368      Serial.print("temp:");
369
370      Serial.print(w_temp);
371      Serial.print(", time:");
372      Serial.println(w_time);
373
374      setWaterLevel(w_out);         // flush all remaning water
375      w_cycle++;
376
377      time_cstart = millis();
378      break;
379
380    case r_fill:                    //
381  4 - fill for rinsing
382    case w_fill:                    // 1 - fill for washing
383
384      setWaterLevel(w_normal);
385      time_cstart = millis();
386      w_cycle++;
387
388      break;
389
390    case w_wash:                   // 2 - wash
391      setTemp(w_temp);
392
393      pump(mwash);
394      setWaterLevel(w_normal);     // check again water level
395
396      seconds = (millis() - time_cstart) / 1000;
397      witeLCDTime(w_time - seconds);
398
399      if (seconds >= w_time)
400        w_cycle++;
401      break;
402
403    case
404  r_rinse:                 // 5 - rinsing
405      setTemp(30);
406      pump(mwash);
407
408      setWaterLevel(w_normal);
409      seconds = (millis() - time_cstart) / 1000;
410
411      witeLCDTime(r_time - seconds);
412      if (seconds >= r_time)
413        w_cycle++;
414
415      break;
416
417    case w_wflush:                // 3 - flush washing water
418
419    case r_flush:                 // 6 - flush rinsing water
420      setTemp(0);
421                   // stop the heater
422      pump(mstop);                  //
423  stop the pump
424      delay(1000);                  // wait for pump to stop
425
426      setWaterLevel(w_out);
427      w_cycle++;
428      break;
429  }
430  Serial.println();
431
432  delay(1000);                       // wait for a second
433}
434
435void pump(int
436  mode)
437{
438  if (doorState == 0) {             // door is open
439    Serial.println("pump:door");
440
441    digitalWrite(pinPumpPow, HIGH);    // stop pump
442  }  else {
443    switch
444  (mode) {
445      case 0:
446        digitalWrite(pinPumpPow, HIGH); // stop pump
447
448        break;
449      case 1:                       // wash
450        digitalWrite(pinPumpDir,
451  LOW);   // set rotation to wash the dishes
452        digitalWrite(pinPumpPow, LOW);
453   // start pump
454        break;
455      case 2:                       // flush
456  to drain
457        digitalWrite(pinPumpDir, HIGH);   // set rotation to flush into
458  drain
459        digitalWrite(pinPumpPow, LOW);    // start pump
460        break;
461
462    }
463  }
464}
465

#include "TM1637.h"
#define SEG_A 1   //      -- A --
#define
  SEG_B 2   //     |       |
#define SEG_C 4   //     F       B
#define SEG_D
  8   //     |       |
#define SEG_E 16  //      -- G --
#define SEG_F 32  //
     |       |
#define SEG_G 64  //     E       C
//                       |
       |
//                        -- D --
// washing time
int w_time =
  40 * 60; // washing time in minutes
int w_temp = 60;      // washing temperature
int
  r_time = 10 * 60; // rinsing time in minutes

// pins
const int pinPumpDir
  = 12;    // relay - pump direction : wash/flush
const int pinPumpPow = 11;    //
  relay - pump power
const int pinHeater  = 10;    // relay - heater
const int
  pinWatInlet = 9;    // relay - water inlet valve
const int pinDoor  = 8;    //
  switch on door
const int pinModeSel  = 7;    // switch for mode select: temp/time
  setting
const int WaterSensorHig = 6; // switch on floater
const int WaterSensorLow
  = 5; // switch on floater
const int pinLedDio = 4;      // I2C pin for TM1637
  LCD
const int pinLedClk = 3;      // I2C pin for TM1637 LCD
// analog pins
int
  PinThermistor = 6;
int PinPotMeter = 5;

// variables
int temp;
int
  potMeter;
int WaterLow = 0;
int WaterHig = 0;
int doorState = 0;           //
  variable for reading the pushbutton status
unsigned long time_curr;    // current
  timestamp
unsigned long seconds;
unsigned long time_cstart;  // cycle start
  timestamp

// motor modes
#define mstop 0
#define mwash 1
#define
  mflush 2

TM1637 tm1637(pinLedClk, pinLedDio);

// washing state
int
  w_cycle = 0;   // washing cycle varibale walking on below values
#define w_start
  0 // just started: wait for door to be closed, flush all remaining water for at
  least 10 sec
#define w_fill   1 // fill for washing
#define w_wash   2 //
  wash the dishes + heat to 40 Celsuis
#define w_wflush 3 // flush washing water
#define
  r_fill   4 // fill for rinsing 
#define r_rinse  5 // rinsing         + heat
  to 30 Celsuis
#define r_flush  6 // flush rinsing water
#define r_finshed
  7 // flush rinsing water

// ========================================================================================================================
void
  showLed(uint8_t BitAddr, int8_t DispData)
{
  tm1637.start();          //start
  signal sent to TM1637 from MCU
  tm1637.writeByte(ADDR_FIXED);//
  tm1637.stop();
           //
  tm1637.start();          //
  tm1637.writeByte(BitAddr | 0xc0);
  //
  tm1637.writeByte(DispData);//
  tm1637.stop();            //
}

//
  the setup function runs once when you press reset or power the board ===================================================
void
  setup() {
  Serial.begin(9600);
  Serial.println();
  Serial.println("start=============");


  pinMode(pinPumpPow, OUTPUT);
  pinMode(pinPumpDir, OUTPUT);
  pinMode(pinWatInlet,
  OUTPUT);
  pinMode(pinHeater, OUTPUT);

  pinMode(WaterSensorLow, INPUT);
  // init water low sensor
  pinMode(WaterSensorHig, INPUT);  // init water high
  sensor
  pinMode(pinDoor, INPUT);      // init door sensor

  tm1637.init();
                  // init lcd
  tm1637.set(6);                  // set brightness

  tm1637.display(0, 8);           // show 'booted'
  tm1637.display(1, 8);

  tm1637.display(2, 8);
  tm1637.display(3, 8);
  /*
    for(int i=0;i<=8;i++)

    {
    showLed(0x02,1|2);delay(1000);
    showLed(0x02,2|64);delay(1000);

    showLed(0x02,64|32);delay(1000);
    showLed(0x02,32|1);delay(1000);

    }
  */
  digitalWrite(pinPumpPow, HIGH); // stop flush
  digitalWrite(pinPumpDir,
  HIGH); // stop pump
  digitalWrite(pinWatInlet, HIGH); // stop water valve

  digitalWrite(pinHeater, HIGH); // stop heater
}
// ========================================================================================================================
void
  setTemp(int level) {
  if (getTemp() < level)  {
    digitalWrite(pinHeater,
  LOW); Serial.print(", pinHeater:LOW");
  } else {
    digitalWrite(pinHeater,
  HIGH); Serial.print(", pinHeater:HIGH");
  }
}
// ========================================================================================================================
int
  getTemp() {
  int Vo;
  float R1 = 10000;
  float logR2, R2, T, Tc;

  float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;


  Vo = analogRead(PinThermistor);
  R2 = R1 * (1023.0 / (float)Vo - 1.0);

  logR2 = log(R2);
  T = (1.0 / (c1 + c2 * logR2 + c3 * logR2 * logR2 * logR2));

  Tc = T - 273.15;
  return (int)Tc;
}
// ========================================================================================================================
void
  manage()
{
  while (WaterHig == 1) {
    tm1637.display(0, 10);  // A

    pump(mflush);
    delay(100);
    WaterHig = digitalRead(WaterSensorHig);

  }
  while (doorState == 0) {
    tm1637.display(0, 11);  // B
    pump(mstop);

    delay(100);
    doorState = digitalRead(pinDoor);
  }
}
// ========================================================================================================================
void
  readInput() {
  temp = getTemp();
  WaterLow = digitalRead(WaterSensorLow);

  WaterHig = digitalRead(WaterSensorHig);
  doorState = digitalRead(pinDoor);
}

#define
  w_out     0 // 
#define w_normal  1 // 

// ========================================================================================================================
void
  setWaterLevel(int level)
{
  switch (level) {
    case w_out:
      digitalWrite(pinWatInlet,
  HIGH);    // close water inlet valve
      while (digitalRead(WaterSensorLow)
  == 0) {
        if (digitalRead(pinDoor) == 0)
          pump(mstop);

        else
          pump(mflush);
        showLed(0, SEG_C | SEG_D | SEG_E
  | SEG_G);
        showLed(1, SEG_C | SEG_D | SEG_E);
        showLed(2, SEG_D
  | SEG_E | SEG_F | SEG_G);
        showLed(3, 0);
        delay(100);
      }

      delay(10000);
      pump(mstop);
      break;

    case w_normal:

      while (digitalRead(WaterSensorLow) == 1) {
        if (digitalRead(pinDoor)
  == 0)
          pump(mstop);
        digitalWrite(pinWatInlet, LOW);     //
  open water inlet valve
        showLed(0, SEG_C);
        showLed(1, SEG_E
  | SEG_G | SEG_C);
        showLed(2, 0);
        showLed(3, 0);
        delay(100);

      }
      digitalWrite(pinWatInlet, HIGH);    // close water inlet valve

      break;
  }
}
// ========================================================================================================================
void
  witeLCD()
{
  // Show the state of pushbutton on serial monitor
  Serial.print(",
  WaterLow:");
  Serial.print(WaterLow);
  Serial.print(", WaterHig:");

  Serial.print(WaterHig);
  Serial.print(", doorState:");
  Serial.print(doorState);


  Serial.print(", w_cycle:");
  Serial.print(w_cycle);
  witeLCDTemp(temp);
}
void
  witeLCDTime(int data)
{
  Serial.print("LCDTime:");
  Serial.print(data
  / 60);
  Serial.print(":");
  Serial.println(data % 60);
  if (data >
  60) {
    tm1637.display(0, data / 60 / 10);
    tm1637.display(1, data /
  60 % 10);
  }
  else {
    tm1637.display(0, data / 10);
    tm1637.display(1,
  data % 10);
  }
}
void witeLCDTemp(int data)
{
  Serial.print("LCDTemp:");

  Serial.println(data);
  tm1637.display(2, data / 10);
  tm1637.display(3,
  data % 10);
}
// the loop function runs over and over again forever =====================================================================
void
  loop() {
  while (digitalRead(WaterSensorHig) == 1) {
    tm1637.display(0,
  10);  // A
    pump(mflush);
    delay(100);
  }

  readInput();

  witeLCD();

  switch (w_cycle) {
    case w_start:                   //
  0 - start
      setTemp(0);                   // stop heater
      // started
  with door opened - let user change the washing parameters: time/temperature

      if (digitalRead(pinDoor) == 0) {
        while (digitalRead(pinDoor) ==
  0) {
          potMeter = analogRead(PinPotMeter) / 10 - 33;   //545 - 1020

          if (digitalRead(pinModeSel)) {
            w_temp = potMeter;                //
  24..69 celsius
            witeLCDTemp(w_temp);
          }
          else
  {
            w_time = (potMeter * 90) - 1600;  // 6..76 minutes
            witeLCDTime(w_time);

          }
          delay(100);
        }
      } else {
        if
  (digitalRead(pinModeSel)) {
          w_temp = 60;                // 24..69 celsius

          w_time = 50 * 60;           // 6..76 minutes
        }
        else
  {
          w_temp = 40;                // 24..69 celsius
          w_time
  = 30 * 60;           // 6..76 minutes
        }
        witeLCDTemp(w_temp);

        witeLCDTime(w_time);
        delay(5000);
      }
      Serial.print("temp:");

      Serial.print(w_temp);
      Serial.print(", time:");
      Serial.println(w_time);

      setWaterLevel(w_out);         // flush all remaning water
      w_cycle++;

      time_cstart = millis();
      break;

    case r_fill:                    //
  4 - fill for rinsing
    case w_fill:                    // 1 - fill for washing

      setWaterLevel(w_normal);
      time_cstart = millis();
      w_cycle++;

      break;

    case w_wash:                   // 2 - wash
      setTemp(w_temp);

      pump(mwash);
      setWaterLevel(w_normal);     // check again water level

      seconds = (millis() - time_cstart) / 1000;
      witeLCDTime(w_time - seconds);

      if (seconds >= w_time)
        w_cycle++;
      break;

    case
  r_rinse:                 // 5 - rinsing
      setTemp(30);
      pump(mwash);

      setWaterLevel(w_normal);
      seconds = (millis() - time_cstart) / 1000;

      witeLCDTime(r_time - seconds);
      if (seconds >= r_time)
        w_cycle++;

      break;

    case w_wflush:                // 3 - flush washing water

    case r_flush:                 // 6 - flush rinsing water
      setTemp(0);
                   // stop the heater
      pump(mstop);                  //
  stop the pump
      delay(1000);                  // wait for pump to stop

      setWaterLevel(w_out);
      w_cycle++;
      break;
  }
  Serial.println();

  delay(1000);                       // wait for a second
}

void pump(int
  mode)
{
  if (doorState == 0) {             // door is open
    Serial.println("pump:door");

    digitalWrite(pinPumpPow, HIGH);    // stop pump
  }  else {
    switch
  (mode) {
      case 0:
        digitalWrite(pinPumpPow, HIGH); // stop pump

        break;
      case 1:                       // wash
        digitalWrite(pinPumpDir,
  LOW);   // set rotation to wash the dishes
        digitalWrite(pinPumpPow, LOW);
   // start pump
        break;
      case 2:                       // flush
  to drain
        digitalWrite(pinPumpDir, HIGH);   // set rotation to flush into
  drain
        digitalWrite(pinPumpPow, LOW);    // start pump
        break;

    }
  }
}

Downloadable files

connection chart

Comments

Only logged in users can leave comments

Adam_Makkos

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content