Arduino Green House Code

SUBMITTED BY: spinka

DATE: June 26, 2021, 9:13 a.m.

FORMAT: Text only

SIZE: 13.9 kB

Raw Download

HITS: 23939

Report
  1. /*
  2. ############################################################
  3. # File: Arduino_GreenHouse_Controling_sustem.ino #
  4. # Processor: Arduino UNO, MEGA #
  5. # Language: Wiring / C / Arduino IDE #
  6. # Objectives: Heating - Aeration - Irrigation #
  7. # Behavior: Event when the temperature is low #
  8. # or high and the soil is dry #
  9. # Note: 1.8 TFT LCD 128160 #
  10. # DHT-22 Sensor of Temperature and Humitide #
  11. # Sensor Temperature and Humidity External #
  12. # Soil Moisture Sensor and Hygrometer Module #
  13. # Potentiometer1 change limit Moisture #
  14. # Potentiometer2 change limit Temperature #
  15. # Relay1_AirIn to Blower Fan IN #
  16. # Relay2_AirOut to Blower Fan OUT #
  17. # Relay3_Lamp to Hot Lamp #
  18. # Relay4_Water to Water Pump #
  19. # #
  20. # Author: Billy Gkekas #
  21. # Date: Saturday, 29-10-2018 #
  22. # place: Greece, Ptolemaida #
  23. # #
  24. # This project contains public domain code. #
  25. # The modification is allowed without notice. #
  26. ############################################################
  27. */
  28. // DHT22
  29. #include <DHT.h>
  30. #define DHTPIN 1
  31. #define DHTPIN21 3
  32. // #define DHTTYPE DHT11 // DHT 11)
  33. #define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
  34. #define DHTTYPE21 DHT21 // DHT 21 (AM2301)
  35. DHT dht(DHTPIN, DHTTYPE); // Initialize DHT sensor for normal 16mhz Arduino
  36. DHT dht21(DHTPIN21, DHTTYPE21); // Initialize DHT sensor for normal 16mhz Arduino
  37. // ****************************************
  39. // 1.8 TFT LCD 128X 160
  40. #include <Adafruit_GFX.h>
  41. #include <Adafruit_ST7735.h>
  42. #include <SPI.h>
  43. //#include "Adafruit_SHT31.h"
  44. //Adafruit_SHT31 sht31 = Adafruit_SHT31();
  46. #define BLACK 0x0000
  47. #define BLUE 0x001F
  48. #define RED 0xF800
  49. #define GREEN 0x07E0
  50. #define MAGENTA 0xF81F
  51. #define YELLOW 0xFFE0
  52. #define WHITE 0xFFFF
  53. #define GRAY 0x7BEF
  54. #define LIGHT_GRAY 0xC618
  55. #define LIME 0x87E0
  56. #define AQUA 0x5D1C
  57. #define CYAN 0x07FF
  58. #define DARK_CYAN 0x03EF
  59. #define ORANGE 0xFCA0
  60. #define PINK 0xF97F
  61. #define BROWN 0x8200
  62. #define VIOLET 0x9199
  63. #define SILVER 0xA510
  64. #define GOLD 0xA508
  65. #define NAVY 0x000F
  66. #define MAROON 0x7800
  67. #define PURPLE 0x780F
  68. #define OLIVE 0x7BE0
  70. #define TFT_SCLK 13
  71. #define TFT_MOSI 11
  72. #define TFT_CS 10
  73. #define TFT_RST 9
  74. #define TFT_DC 8
  76. Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
  78. // Variable Definitions
  79. float temp_internal; // Stores internal temperature value
  80. float hum_internal; // Stores internal humidity value
  81. float temp_external; // Stores external temperature value
  82. float hum_external; // Stores external humidity value
  83. int state; // Condition of pins
  84. int valMoisture = 0; // Stores Moisture value
  85. int kath = 5000; // Delay
  86. int LimM = 1023 ; // Stores value after edit
  87. int LimT = 25 ; // Stores value after edit
  88. int manytimes = 1;
  89. int total;
  91. //pin definitions
  92. int MoisturePin = A0; // Moisture Analog pin
  93. int potention1 = A2; // Potentiometer to change Temperature Limit
  94. int potention2 = A1; // Potentiometer to change Moisture Limit
  95. int Relay1_AirIn = 4; // airRelay1 Blower Air Fan IN
  96. int Relay2_AirOut = 5; // airRelay2 Blower Air Fan OUT
  97. int Relay3_Lamp = 6; // Relay3_Lamp Hot Lamp
  98. int Relay4_Water = 7; // Relay4_Water Pump
  99. int soilPower = 2; // Moisture Soil power
  100. // *******************************************************
  102. void setup() {
  104. Serial.begin(9600);
  106. dht.begin(); // DHT22 Starts
  107. dht21.begin(); // DHT21 Starts
  108. tft.initR(INITR_BLACKTAB); // Initialize 1.8 TFT LCD 128 X 160
  109. tft.fillScreen(BLACK);
  110. tft.setRotation(0);
  112. // Initialize Sensor Moisture
  113. pinMode(soilPower, OUTPUT); // Set D7 as an OUTPUT
  114. digitalWrite(soilPower, LOW); // Set to LOW, no power in the sensor
  116. // Initialize Relays
  117. pinMode(potention1, INPUT);
  118. pinMode(potention2, INPUT);
  119. pinMode(Relay1_AirIn, OUTPUT);
  120. pinMode(Relay2_AirOut, OUTPUT);
  121. pinMode(Relay3_Lamp, OUTPUT);
  122. pinMode(Relay4_Water, OUTPUT);
  124. digitalWrite(Relay1_AirIn, LOW);
  125. digitalWrite(Relay2_AirOut, LOW);
  126. digitalWrite(Relay3_Lamp, LOW);
  127. digitalWrite(Relay4_Water, LOW);
  128. }
  130. void loop() {
  131. // Read data from Sensors
  133. // 1. Read data from Internal Sensor and store it to variables temp_internal and hum_internal
  134. hum_internal = dht21.readHumidity();
  135. temp_internal = dht21.readTemperature();
  137. // 2. Read data from DHT22 and store it to variables hum and temp
  138. hum_internal = dht.readHumidity();
  139. temp_internal = dht.readTemperature();
  141. // This Function send power and then reads from Moisture Sensor
  142. int readSoil() ;
  143. digitalWrite(soilPower, HIGH); // turn D2 "On"
  144. delay(10); // wait 10 milliseconds giving time to Moisture Sensor
  145. // 3. Read the SIG value (data) from the sensor and counted percent degrees
  146. valMoisture = (analogRead(MoisturePin) - 23) / 10;
  147. digitalWrite(soilPower, LOW); // turn power on D2 "Off"
  149. // 4. Read from potentiometers limit of Temperature and Humidity
  150. LimT = (analogRead(potention1) - 23) / 10; // Read limit from Potentiometer
  151. LimM = (analogRead(potention2) - 21) / 10; // Read limit from Potentiometer
  153. // ***************************************************************************
  155. // Print readed values of External and Internal Temperature
  156. tft.fillRect(0, 0, 64, 20, RED);
  157. printText1(temp_external, WHITE, 2, 2, 2);
  158. tft.fillRect(64, 0, 64, 20, MAGENTA);
  159. printText1(temp_internal, WHITE, 66, 2, 2);
  160. tft.fillRect(43, 20, 45, 20, CYAN);
  161. printText("EXT", WHITE, 2, 23, 2);
  162. tft.setCursor(50, 23);
  163. tft.setTextColor(BLACK);
  164. tft.print(LimT);
  165. printText("INT", WHITE, 90, 23, 2);
  167. // ***************************************************************************
  169. // Print readed values of Internal and Internal Humidity
  170. tft.fillRect(0, 40, 64, 20, VIOLET);
  171. printText1(hum_external, WHITE, 2, 43, 2);
  172. tft.fillRect(64, 40, 64, 20, YELLOW);
  173. printText1(hum_internal, BLACK, 66, 43, 2);
  174. tft.fillRect(58, 60, 128, 20, CYAN);
  175. printText("LimM", WHITE, 2, 63, 2);
  176. tft.setCursor(65,63);
  177. tft.setTextColor(BLACK);
  178. tft.print(LimM);
  179. tft.print(" %");
  181. // ***************************************************************************
  182. // Print on Serial Window readed values
  183. Serial.print("Counter = ");
  184. Serial.println(manytimes);
  185. Serial.print("TOTAL = ");
  186. Serial.println(total);
  187. state = digitalRead(Relay1_AirIn);
  188. Serial.print("Air In = ");
  189. Serial.println(state);
  190. state = digitalRead(Relay2_AirOut);
  191. Serial.print("Air Out = ");
  192. Serial.println(state);
  193. state = digitalRead(Relay3_Lamp);
  194. Serial.print("Lamp = ");
  195. Serial.println(state);
  196. state = digitalRead(Relay4_Water);
  197. Serial.print("Water = ");
  198. Serial.println(state);
  199. Serial.println("");
  201. // ***************************************************************************
  202. // 1. Check limit value for Moisture Soil Sensor and control Relay4_Water
  203. Serial.print("Soil: ");
  204. Serial.println(valMoisture);
  205. printText("SOIL", WHITE, 2, 83, 2);
  206. printText("WATER", WHITE, 5, 143, 2);
  207. if (valMoisture >= LimM) {
  208. digitalWrite(Relay4_Water, HIGH);
  209. tft.fillRect(58, 80, 128, 20, AQUA);
  210. printText1(valMoisture, WHITE, 65, 83, 2);
  211. tft.fillRect(80, 140, 128, 20, AQUA);
  212. printText("ON", WHITE, 85, 143, 2);
  213. }
  214. else {
  215. digitalWrite(Relay4_Water, LOW);
  216. tft.fillRect(58, 80, 128, 20, BLUE);
  217. printText1(valMoisture, WHITE, 65, 83, 2);
  218. tft.fillRect(80, 140, 128, 20, RED);
  219. printText("OFF", WHITE, 85, 143, 2);
  220. }
  222. // ***************************************************************************
  223. printText("AIR ", WHITE, 2, 103, 2);
  224. printText("LAMP", WHITE, 5, 123, 2);
  226. // 2. Check greenhouse's Internal Condition and control Relays of Fans & Hot Lamp
  227. if (temp_internal >= LimT) {
  228. if (temp_internal > temp_external) {
  229. Serial.println("1. t_int >= LimT & t_int > t_ext");
  230. Serial.print(temp_internal);
  231. Serial.print(" >= ");
  232. Serial.print(LimT);
  233. Serial.print(" & > ");
  234. Serial.print(temp_external);
  235. Serial.println(" AirIn On - AirOut On - Lamp Off");
  237. tft.fillRect(40, 100, 42, 20, GREEN);
  238. printText("IN ", BLACK, 45, 103, 2);
  239. state = digitalRead(Relay1_AirIn);
  240. if (state == 1) {
  241. // do nothing
  242. }
  243. else {
  244. digitalWrite(Relay1_AirIn, HIGH);
  245. }
  247. tft.fillRect(80, 100, 128, 20, GREEN);
  248. printText("OUT", BLACK, 85, 103, 2);
  249. state = digitalRead(Relay2_AirOut);
  250. if (state == 1) {
  251. // do nothing
  252. }
  253. else {
  254. digitalWrite(Relay2_AirOut, HIGH);
  255. }
  257. tft.fillRect(80, 120, 128, 20, RED);
  258. printText("OFF", WHITE, 85, 123, 2);
  259. state = digitalRead(Relay3_Lamp);
  260. if (state == 0) {
  261. // do nothing
  262. }
  263. else {
  264. digitalWrite(Relay3_Lamp, LOW);
  265. }
  266. }
  267. else {
  268. Serial.println("else 1. t_int >= LimT & t_int < t_ext");
  269. Serial.print(temp_external);
  270. Serial.print(" > ");
  271. Serial.print(temp_internal);
  272. Serial.print(" >= ");
  273. Serial.print(LimT);
  274. Serial.println(" AirIn Off - AirOut On - Lamp Off");
  276. tft.fillRect(40, 100, 42, 20, RED);
  277. printText("IN ", WHITE, 45, 103, 2);
  278. state = digitalRead(Relay1_AirIn);
  279. if (state == 0) {
  280. // do nothing
  281. }
  282. else {
  283. digitalWrite(Relay1_AirIn, LOW);
  284. }
  285. tft.fillRect(80, 100, 128, 20, GREEN);
  286. printText("OUT", BLACK, 85, 103, 2);
  287. state = digitalRead(Relay2_AirOut);
  288. if (state == 1) {
  289. // do nothing
  290. }
  291. else {
  292. digitalWrite(Relay2_AirOut, HIGH);
  293. }
  295. tft.fillRect(80, 120, 128, 20, RED);
  296. printText("OFF", WHITE, 85, 123, 2);
  297. state = digitalRead(Relay3_Lamp);
  298. if (state == 0) {
  299. // do nothing
  300. }
  301. else {
  302. digitalWrite(Relay3_Lamp, LOW);
  303. }
  304. }
  305. }
  307. if (temp_internal < LimT) {
  308. if (temp_internal <= temp_external) {
  309. Serial.println("2. t_int < LimT & t_int >= t_ext");
  310. Serial.print(temp_external);
  311. Serial.print(" <= ");
  312. Serial.print(temp_internal);
  313. Serial.print(" < ");
  314. Serial.print(LimT);
  315. Serial.println(" AirIn ON - AirOut Off - Lamp On");
  317. tft.fillRect(40, 100, 42, 20, GREEN);
  318. printText("IN", BLACK, 50, 103, 2);
  319. if (state == 1) {
  320. // do nothing
  321. }
  322. else {
  323. digitalWrite(Relay1_AirIn, HIGH);
  324. }
  326. tft.fillRect(80, 100, 128, 20, RED);
  327. printText("OUT", WHITE, 85, 103, 2);
  328. state = digitalRead(Relay2_AirOut);
  329. if (state == 0) {
  330. // do nothing
  331. }
  332. else {
  333. digitalWrite(Relay2_AirOut, LOW);
  334. }
  336. tft.fillRect(80, 120, 128, 20, GREEN);
  337. printText("ON", BLACK, 85, 123, 2);
  338. state = digitalRead(Relay3_Lamp);
  339. if (state == 1) {
  340. // do nothing
  341. }
  342. else {
  343. digitalWrite(Relay3_Lamp, HIGH);
  344. }
  345. }
  346. else {
  347. Serial.println("else 2. t_int < LimT & t_int < t_ext");
  348. Serial.print(temp_internal);
  349. Serial.print(" < ");
  350. Serial.print(LimT);
  351. Serial.print(" & ");
  352. Serial.print(temp_external);
  353. Serial.println("AirIn OFF - AirOut Off - Lamp On");
  355. tft.fillRect(40, 100, 42, 20, RED);
  356. printText("IN", WHITE, 44, 103, 2);
  357. state = digitalRead(Relay1_AirIn);
  358. if (state == 0) {
  359. // do nothing
  360. }
  361. else {
  362. digitalWrite(Relay1_AirIn, LOW);
  363. }
  365. tft.fillRect(80, 100, 128, 20, RED);
  366. printText("OUT", WHITE, 85, 103, 2);
  367. state = digitalRead(Relay2_AirOut);
  368. if (state == 0) {
  369. // do nothing
  370. }
  371. else {
  372. digitalWrite(Relay2_AirOut, LOW);
  373. }
  375. tft.fillRect(80, 120, 128, 20, RED);
  376. printText("OFF", WHITE, 85, 123, 2);
  377. state = digitalRead(Relay3_Lamp);
  378. if (state == 1) {
  379. // do nothing
  380. }
  381. else {
  382. digitalWrite(Relay3_Lamp, HIGH);
  383. }
  384. }
  385. }
  387. // 3. Refresh screen after 50 times
  388. manytimes++;
  389. total++;
  391. if (manytimes == 50) {
  393. tft.fillScreen(BLACK);
  394. printText("Smart", LIME, 15, 20, 2);
  395. printText("GreenHouse", GREEN, 5, 50, 2);
  396. printText("v4.0", AQUA, 15, 80, 2);
  397. delay(3000);
  398. manytimes = 0;
  399. }
  401. delay(kath);
  402. tft.setTextSize(1);
  403. tft.fillRect(50, 80, 128, 40, BLACK);
  404. tft.setTextColor(WHITE);
  405. }
  407. // ***************************************************************************
  408. // Function Print Text
  409. void printText(char *text, uint16_t color, int x, int y, int textSize)
  410. {
  411. tft.setCursor(x, y);
  412. tft.setTextColor(color);
  413. tft.setTextSize(textSize);
  414. tft.setTextWrap(true);
  415. tft.print(text);
  416. // printText("MAX", RED,18,130,1);
  417. }
  419. // ***************************************************************************
  420. // Function Print float
  421. void printText1(float num, uint16_t color, int x, int y, int textSize)
  422. {
  423. tft.setCursor(x, y);
  424. tft.setTextColor(color);
  425. tft.setTextSize(textSize);
  426. tft.setTextWrap(true);
  427. tft.print(num);
  428. // printText1(value, RED,18,130,1);
  429. }
comments powered by Disqus