Advertisement
Ruddog

NodeNCU_Motor_Driver

Aug 12th, 2018
864
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 5.78 KB | None | 0 0
  1. #include <dht.h>
  2. #define dht_dpin A0
  3. dht DHT;
  4. //———————–
  5. #include <LiquidCrystal.h>
  6. LiquidCrystal lcd (8, 9, 10, 11, 12, 13);
  7. //———————————-
  8. int plantPotMoisture[3] = {A1, A2, A3};
  9. //———————
  10. #include <GSM.h>
  11. #define PINNUMBER “”
  12. GSM gsmAccess; // include a ‘true’ parameter for debug enabled
  13. GSM_SMS sms;
  14. char remoteNumber[] =0899506304;
  15. String moistureMessage = “Moisture is Low on sensor:;
  16. String SMS_Alert = “Sending SMS!;
  17. String humidityMsg = “Humidity is High. Open All Solenoids”;
  18. String tempMsg = “Temperature is too HIGH!..Open ALl Solenoids “;
  19. String messageBuffer = “”;
  20. char senderNumber[20];
  21. String stringOne = “Opens1”;
  22. String stringTwo = “Opens2”;
  23. String stringThree = “Opens3”;
  24. String stringFour = “OpenAll”;
  25. //—————
  26. #define solenoidData 5
  27. #define solenoidClockster 4
  28. #define solenoidLatch 6
  29. //—————
  30. const int master = 0;
  31. const int slave1 = 1;
  32. const int slave2 = 2;
  33. const int slave3 = 3;
  34. boolean takeReadings = true;
  35. int serialSolenoidOutput = 0;
  36. void setup()
  37. {
  38. pinMode(solenoidData, OUTPUT);
  39. pinMode(solenoidClockster, OUTPUT);
  40. pinMode(solenoidLatch, OUTPUT);
  41. digitalWrite(solenoidLatch, HIGH);
  42. digitalWrite(solenoidLatch, LOW);
  43. shiftOut(solenoidData, solenoidClockster, MSBFIRST, 0);
  44. digitalWrite(solenoidLatch, HIGH);
  45. //————————-
  46. Serial.begin(9600);
  47. lcd.begin (16, 2);
  48. lcd.clear();
  49. lcd.setCursor(0, 0);
  50. lcd.print(“Wait Until”);
  51. lcd.setCursor(0, 1);
  52. lcd.print(“GSM Initialized!);
  53. boolean notConnected = true;
  54. while (notConnected)
  55. {
  56. if (gsmAccess.begin(PINNUMBER) == GSM_READY)
  57. notConnected = false;
  58. else
  59. {
  60. Serial.println(“Not connected”);
  61. delay(1000);
  62. }
  63. }
  64. }
  65. void loop()
  66. {
  67. if (takeReadings)
  68. {
  69. moistureSensor();
  70. TempAndHumidity ();
  71. if (DHT.humidity > 50 || DHT.temperature > 25 && takeReadings )
  72. {
  73. takeReadings = false;
  74. if (DHT.humidity > 50)
  75. {
  76. sendSMS(humidityMsg);
  77. }
  78. else if (DHT.temperature > 25)
  79. {
  80. sendSMS(tempMsg);
  81. }
  82. while (!takeReadings)
  83. recieveSMS();
  84. }
  85. if (plantPotMoisture[0] > 30 || plantPotMoisture[1] > 30 || plantPotMoisture[2] > 30 && takeReadings)
  86. {
  87. takeReadings = false;
  88. if (plantPotMoisture[0] > 30)
  89. {
  90. sendSMS(moistureMessage +1);
  91. }
  92. else if (plantPotMoisture[1] > 30)
  93. {
  94. sendSMS(moistureMessage +2);
  95. }
  96. else
  97. {
  98. sendSMS(moistureMessage +3);
  99. }
  100. while (!takeReadings)
  101. recieveSMS();
  102. }
  103. }
  104. }
  105. void moistureSensor()
  106. {
  107. for (int i = 0 ; i < 3; i++)
  108. {
  109. lcd.clear();
  110. plantPotMoisture[i] = analogRead(i);
  111. plantPotMoisture[i] = map(plantPotMoisture[i], 550, 0, 0, 100);
  112. Serial.print(“Mositure” + i );
  113. lcd.print(“Mositure” + i);
  114. Serial.print(plantPotMoisture[i]);
  115. lcd.print(plantPotMoisture[i]);
  116. Serial.println(%);
  117. lcd.print(%);
  118. delay(1000);
  119. }
  120. }
  121. void TempAndHumidity ()
  122. {
  123. DHT.read11(dht_dpin);
  124. lcd.setCursor(0, 0);
  125. lcd.print(“Humidity=);
  126. Serial.print(“Current humidity =);
  127. Serial.print(DHT.humidity);
  128. lcd.print(DHT.humidity);
  129. lcd.print(%);
  130. Serial.print(%);
  131. Serial.print(“temperature =);
  132. Serial.print(DHT.temperature);
  133. Serial.println(“C”);
  134. lcd.setCursor(0, 1);
  135. lcd.print(“temp=);
  136. lcd.print(DHT.temperature);
  137. lcd.print(“C “);
  138. delay(1000);
  139. lcd.clear();
  140. }
  141. void sendSMS(String messageToSend)
  142. {
  143. Serial.print(“Sending a message to mobile number:);
  144. Serial.println(remoteNumber);
  145. Serial.println(“SENDING”);
  146. lcd.print(SMS_Alert);
  147. Serial.println();
  148. Serial.println(“Message:);
  149. Serial.println(messageToSend);
  150. sms.beginSMS(remoteNumber);
  151. sms.print(messageToSend);
  152. sms.endSMS();
  153. Serial.println(“\nCOMPLETE!\n”);
  154. lcd.clear();
  155. lcd.print(“Completed!!!);
  156. }
  157. void recieveSMS()
  158. {
  159. char c;
  160. if (sms.available())
  161. {
  162. lcd.clear();
  163. lcd.print(“Message received from:);
  164. delay(800);
  165. lcd.clear();
  166. sms.remoteNumber(senderNumber, 20);
  167. lcd.print(senderNumber);
  168. while (c = sms.read())
  169. {
  170. Serial.println(c);
  171. messageBuffer += c;
  172. }
  173. Serial.println(messageBuffer);
  174. if (messageBuffer == stringOne)
  175. {
  176. toggleSolenoid1();
  177. takeReadings = true;
  178. }
  179. else if (messageBuffer == stringTwo)
  180. {
  181. toggleSolenoid2();
  182. takeReadings = true;
  183. }
  184. else if (messageBuffer == stringThree)
  185. {
  186. toggleSolenoid3();
  187. takeReadings = true;
  188. }
  189. else if (messageBuffer == stringFour)
  190. {
  191. toggleAll();
  192. takeReadings = true;
  193. }
  194. else
  195. {
  196. takeReadings = true;
  197. }
  198. messageBuffer = “”;
  199. Serial.println(“\nEND OF MESSAGE”);
  200. // Delete message from modem memory
  201. sms.flush();
  202. Serial.println(“MESSAGE DELETED”);
  203. }
  204. delay(1000);
  205. }
  206. void toggleSolenoid1()
  207. {
  208. solenoidWrite(master, HIGH);
  209. delay(1000);
  210. solenoidWrite(slave1, HIGH);
  211. delay(1000);
  212. solenoidWrite(slave1, LOW);
  213. delay(1000);
  214. solenoidWrite(master, LOW);
  215. delay(1000);
  216. }
  217. void toggleSolenoid2()
  218. {
  219. solenoidWrite(master, HIGH);
  220. delay(1000);
  221. solenoidWrite(slave2, HIGH);
  222. delay(1000);
  223. solenoidWrite(slave2, LOW);
  224. delay(1000);
  225. solenoidWrite(master, LOW);
  226. delay(1000);
  227. }
  228. void toggleSolenoid3()
  229. {
  230. solenoidWrite(master, HIGH);
  231. delay(1000);
  232. solenoidWrite(slave3, HIGH);
  233. delay(1000);
  234. solenoidWrite(slave3, LOW);
  235. delay(1000);
  236. solenoidWrite(master, LOW);
  237. delay(1000);
  238. }
  239. void toggleAll()
  240. {
  241. solenoidWrite(master, HIGH);
  242. delay(1000);
  243. solenoidWrite(slave1, HIGH);
  244. delay(1000);
  245. solenoidWrite(slave2, HIGH);
  246. delay(1000);
  247. solenoidWrite(slave3, HIGH);
  248. delay(1000);
  249. solenoidWrite(slave1, LOW);
  250. delay(1000);
  251. solenoidWrite(slave2, LOW);
  252. delay(1000);
  253. solenoidWrite(slave3, LOW);
  254. delay(1000);
  255. solenoidWrite(master, LOW);
  256. delay(1000);
  257. }
  258. void solenoidWrite(int pin, bool state)
  259. {
  260. if ( pin >= 0 && pin < 8)
  261. {
  262. if (state)
  263. serialSolenoidOutput |= (1 << pin);
  264. else
  265. serialSolenoidOutput &= ~(1 << pin);
  266. }
  267. digitalWrite(solenoidLatch, LOW);
  268. shiftOut(solenoidData, solenoidClockster, MSBFIRST, serialSolenoidOutput);
  269. digitalWrite(solenoidLatch, HIGH);
  270. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement