API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 22nd, 2019
115
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.05 KB | None | 0 0
raw download clone embed print report
  1. // hardware port definitions
  2. #include "SSBasicUtilities.h"
  3. #include "ASSP.h"
  4. #include "names.h"
  5. #define LED_RED 3
  6. #define LED_YELLOW 5
  7. #define LED_PINK 6
  8. #define LED_WHITE 9
  9. #define LED_GREEN 10
  10. #define LED_BLUE 11
  11. #define EMU A1
  12. #define SWITCH1 A4
  13. #define SWITCH2 A5
  14. #define POTENTIOMETER A0
  15. #define PORT1 1
  16. #define PORT2 2
  17. #define PORT3 3
  18. #define PORT4 4
  19.  
  20. void setup()
  21. {
  22. // initialize the digital pins as outputs.
  23. pinMode(LED_RED, OUTPUT);
  24. pinMode(LED_YELLOW, OUTPUT);
  25. pinMode(LED_PINK, OUTPUT);
  26. pinMode(LED_WHITE, OUTPUT);
  27. pinMode(LED_GREEN, OUTPUT);
  28. pinMode(LED_BLUE, OUTPUT);
  29.  
  30. // Open hardware serial communications and wait for port to open:
  31. Serial.begin(57600);
  32. Serial.println("Program Running.");
  33.  
  34. // now setup the switches
  35. pinMode(SWITCH1, INPUT_PULLUP);
  36. pinMode(SWITCH2, INPUT_PULLUP);
  37.  
  38. // now setup the POTENTIOMETER
  39. pinMode(POTENTIOMETER, INPUT);
  40.  
  41. //puts the Nano into testing mode for any port
  42. SerialShield.setEmuMode(6);
  43.  
  44. task2();
  45.  
  46. }
  47.  
  48. //Function to turn the LEDs on and off (boolean low and high)
  49. void setLeds(boolean state) {
  50. Serial.print("Set LEDS to ");
  51. Serial.println(state);
  52. digitalWrite(LED_PINK, state);
  53. digitalWrite(LED_WHITE, state);
  54. digitalWrite(LED_GREEN, state);
  55. digitalWrite(LED_BLUE, state);
  56. }
  57.  
  58. //Function to make the LEDs blink on and off with a 200ms delay
  59. void blinkLeds() {
  60. delay(200); //slow things down by waiting 0.5s
  61. setLeds(HIGH);
  62. delay(200); //slow things down
  63. setLeds(LOW);
  64. }
  65.  
  66. //Function to make the LEDs cycle from bottom to top of the Arduino with a 200ms delay (by pressing switch 2)
  67. void cycleLeds() {
  68. int sw2 = digitalRead(SWITCH2);
  69. if (sw2 == LOW) {
  70. setLeds(LOW);
  71. digitalWrite(LED_BLUE, HIGH);
  72. delay(200);
  73. digitalWrite(LED_BLUE, LOW);
  74. digitalWrite(LED_GREEN, HIGH);
  75. delay(200);
  76. digitalWrite(LED_GREEN, LOW);
  77. digitalWrite(LED_WHITE, HIGH);
  78. delay(200);
  79. digitalWrite(LED_WHITE, LOW);
  80. digitalWrite(LED_PINK, HIGH);
  81. delay(200);
  82. digitalWrite(LED_PINK, LOW);
  83. delay(200);;
  84. digitalWrite(LED_PINK, HIGH);
  85. delay(200);
  86. digitalWrite(LED_WHITE, HIGH);
  87. digitalWrite(LED_PINK, LOW);
  88. delay(200);
  89. digitalWrite(LED_GREEN, HIGH);
  90. digitalWrite(LED_WHITE, LOW);
  91. delay(200);
  92. digitalWrite(LED_BLUE, HIGH);
  93. digitalWrite(LED_GREEN, LOW);
  94. delay(200);
  95. }
  96. }
  97.  
  98. //Function to print the current value of the potentiometer
  99. void valuePrint()
  100. {
  101. int value = analogRead(POTENTIOMETER);
  102. Serial.println("The potentiometer value is : ");
  103. Serial.print(value);
  104. }
  105.  
  106. //Function to control the LEDs with the potentiometer
  107. void manualControl()
  108. {
  109. int v = analogRead(POTENTIOMETER);
  110. if (v < 256)
  111. {
  112. digitalWrite(LED_PINK, HIGH);
  113. digitalWrite(LED_WHITE, LOW);
  114. digitalWrite(LED_GREEN, LOW);
  115. digitalWrite(LED_BLUE, LOW);
  116. }
  117. else if (v > 768)
  118. {
  119. digitalWrite(LED_PINK, LOW);
  120. digitalWrite(LED_WHITE, LOW);
  121. digitalWrite(LED_GREEN, LOW);
  122. digitalWrite(LED_BLUE, HIGH);
  123. }
  124. else if ((v > 256) && (v < 512))
  125. {
  126. digitalWrite(LED_PINK, LOW);
  127. digitalWrite(LED_WHITE, HIGH);
  128. digitalWrite(LED_GREEN, LOW);
  129. digitalWrite(LED_BLUE, LOW);
  130. }
  131. else
  132. {
  133. digitalWrite(LED_PINK, LOW);
  134. digitalWrite(LED_WHITE, LOW);
  135. digitalWrite(LED_GREEN, HIGH);
  136. digitalWrite(LED_BLUE, LOW);
  137. }
  138. }
  139.  
  140. //Function to make LEDs cycle with a 200ms delay (without pressing switch 2)
  141. void cycleLedsWS2() {
  142. setLeds(LOW);
  143. digitalWrite(LED_BLUE, HIGH);
  144. delay(200);
  145. digitalWrite(LED_BLUE, LOW);
  146. digitalWrite(LED_GREEN, HIGH);
  147. delay(200);
  148. digitalWrite(LED_GREEN, LOW);
  149. digitalWrite(LED_WHITE, HIGH);
  150. delay(200);
  151. digitalWrite(LED_WHITE, LOW);
  152. digitalWrite(LED_PINK, HIGH);
  153. delay(200);
  154. digitalWrite(LED_PINK, LOW);
  155. delay(200);;
  156. digitalWrite(LED_PINK, HIGH);
  157. delay(200);
  158. digitalWrite(LED_WHITE, HIGH);
  159. digitalWrite(LED_PINK, LOW);
  160. delay(200);
  161. digitalWrite(LED_GREEN, HIGH);
  162. digitalWrite(LED_WHITE, LOW);
  163. delay(200);
  164. digitalWrite(LED_BLUE, HIGH);
  165. digitalWrite(LED_GREEN, LOW);
  166. delay(200);
  167. digitalWrite(LED_BLUE, LOW);
  168. delay(200);
  169. }
  170.  
  171. //Function to control LEDs using commands in the serial monitor
  172. void processMessageContent (char message[]) {
  173. if (strcmp(message, "cycle leds") == 0) {
  174. cycleLedsWS2();
  175. }
  176. if (strcmp(message, "blue on") == 0) {
  177. digitalWrite(LED_BLUE, HIGH);
  178. }
  179. if (strcmp(message, "green on") == 0) {
  180. digitalWrite(LED_GREEN, HIGH);
  181. }
  182. if (strcmp(message, "white on") == 0) {
  183. digitalWrite(LED_WHITE, HIGH);
  184. }
  185. if (strcmp(message, "pink on") == 0) {
  186. digitalWrite(LED_PINK, HIGH);
  187. }
  188. if (strcmp(message, "blue off") == 0) {
  189. digitalWrite(LED_BLUE, LOW);
  190. }
  191. if (strcmp(message, "green off") == 0) {
  192. digitalWrite(LED_GREEN, LOW);
  193. }
  194. if (strcmp(message, "white off") == 0) {
  195. digitalWrite(LED_WHITE, LOW);
  196. }
  197. if (strcmp(message, "pink off") == 0) {
  198. digitalWrite(LED_PINK, LOW);
  199. }
  200. if (strcmp(message, "blink leds") == 0) {
  201. blinkLeds();
  202. }
  203. }
  204.  
  205. //Function to control which port is active using the potentiometer, and send and recieve messages using the ASSP
  206. void emuControl()
  207. {
  208. int v = analogRead(POTENTIOMETER);
  209. if (v < 256)
  210. {
  211. digitalWrite(LED_PINK, HIGH);
  212. digitalWrite(LED_WHITE, LOW);
  213. digitalWrite(LED_GREEN, LOW);
  214. digitalWrite(LED_BLUE, LOW);
  215. if (checkSerial()) {
  216. Serial.print("Send message: ");
  217. Serial.println(serialBuffer);
  218. SerialShield.setMessageContent(serialBuffer); // set up a message to send
  219. SerialShield.setMessageSender("xyz89");
  220. SerialShield.setMessageDestination("abc12");
  221. SerialShield.sendASSPMessage(1);
  222. }
  223. while (SerialShield.fetchASSPMessage()) {
  224. Serial.print("Received message: ");
  225. Serial.println(SerialShield.getMessageContent());
  226. processMessageContent(SerialShield.getMessageContent());
  227. Serial.print("Message destination: ");
  228. Serial.println(SerialShield.getMessageDestination());
  229. Serial.print("Message sender: ");
  230. Serial.println(SerialShield.getMessageSender());
  231. Serial.print("The message was recieved on port ");
  232. Serial.println(SerialShield.getMessagePort());
  233. }
  234. }
  235. else if (v > 768)
  236. {
  237. digitalWrite(LED_PINK, LOW);
  238. digitalWrite(LED_WHITE, LOW);
  239. digitalWrite(LED_GREEN, LOW);
  240. digitalWrite(LED_BLUE, HIGH);
  241. if (checkSerial()) {
  242. Serial.print("Send message: ");
  243. Serial.println(serialBuffer);
  244. SerialShield.setMessageContent(serialBuffer); // set up a message to send
  245. SerialShield.setMessageSender("xyz89");
  246. SerialShield.setMessageDestination("abc12");
  247. SerialShield.sendASSPMessage(4);
  248. }
  249. while (SerialShield.fetchASSPMessage()) {
  250. Serial.print("Received message: ");
  251. Serial.println(SerialShield.getMessageContent());
  252. processMessageContent(SerialShield.getMessageContent());
  253. Serial.print("Message destination: ");
  254. Serial.println(SerialShield.getMessageDestination());
  255. Serial.print("Message sender: ");
  256. Serial.println(SerialShield.getMessageSender());
  257. Serial.print("The message was recieved on port ");
  258. Serial.println(SerialShield.getMessagePort());
  259. }
  260. }
  261. else if ((v > 256) && (v < 512))
  262. {
  263. digitalWrite(LED_PINK, LOW);
  264. digitalWrite(LED_WHITE, HIGH);
  265. digitalWrite(LED_GREEN, LOW);
  266. digitalWrite(LED_BLUE, LOW);
  267. if (checkSerial()) {
  268. Serial.print("Send message: ");
  269. Serial.println(serialBuffer);
  270. SerialShield.setMessageContent(serialBuffer); // set up a message to send
  271. SerialShield.setMessageSender("xyz89");
  272. SerialShield.setMessageDestination("abc12");
  273. SerialShield.sendASSPMessage(2);
  274. }
  275. while (SerialShield.fetchASSPMessage()) {
  276. Serial.print("Received message: ");
  277. Serial.println(SerialShield.getMessageContent());
  278. processMessageContent(SerialShield.getMessageContent());
  279. Serial.print("Message destination: ");
  280. Serial.println(SerialShield.getMessageDestination());
  281. Serial.print("Message sender: ");
  282. Serial.println(SerialShield.getMessageSender());
  283. Serial.print("The message was recieved on port ");
  284. Serial.println(SerialShield.getMessagePort());
  285. }
  286. }
  287. else
  288. {
  289. digitalWrite(LED_PINK, LOW);
  290. digitalWrite(LED_WHITE, LOW);
  291. digitalWrite(LED_GREEN, HIGH);
  292. digitalWrite(LED_BLUE, LOW);
  293. if (checkSerial()) {
  294. Serial.print("Send message: ");
  295. Serial.println(serialBuffer);
  296. SerialShield.setMessageContent(serialBuffer); // set up a message to send
  297. SerialShield.setMessageSender("xyz89");
  298. SerialShield.setMessageDestination("abc12");
  299. SerialShield.sendASSPMessage(3);
  300. }
  301. while (SerialShield.fetchASSPMessage()) {
  302. Serial.print("Received message: ");
  303. Serial.println(SerialShield.getMessageContent());
  304. processMessageContent(SerialShield.getMessageContent());
  305. Serial.print("Message destination: ");
  306. Serial.println(SerialShield.getMessageDestination());
  307. Serial.print("Message sender: ");
  308. Serial.println(SerialShield.getMessageSender());
  309. Serial.print("The message was recieved on port ");
  310. Serial.println(SerialShield.getMessagePort());
  311. }
  312. }
  313. }
  314. boolean isDeviceOnPort(const char name[], int port) {
  315. SerialShield.setMessageContent("ping");
  316. SerialShield.setMessageSender("SENDER");
  317. SerialShield.setMessageDestination(name);
  318. do
  319. ;
  320. while (!SerialShield.sendASSPMessage(port));
  321.  
  322. for (int i = 0; i < 50; i++) {
  323. if (SerialShield.fetchASSPMessage()) {
  324. return true;
  325. }
  326. }
  327. return false;
  328. }
  329.  
  330.  
  331. void task1() {
  332. Serial.println("Device PORT1");
  333. for (int i = 0; i < 29; i++) {
  334. bool idp = isDeviceOnPort(names[i], 4);
  335. Serial.print("is device ");
  336. Serial.print(names[i]);
  337. Serial.print(" on port ");
  338. Serial.print(4);
  339. Serial.print(" ");
  340. Serial.println(idp);
  341. if (idp == true) {
  342. Serial.print(names[i]);
  343. Serial.println(" YES");
  344. }
  345. else {
  346. Serial.print(names[i]);
  347. Serial.println(" NO");
  348. }
  349. }
  350. }
  351.  
  352. unsigned long getTimeToDevice(const char name[],int port) {
  353. unsigned long currentMillis = millis();
  354. SerialShield.setMessageContent("message123");
  355. SerialShield.setMessageSender("SENDER");
  356. SerialShield.setMessageDestination(name);
  357. SerialShield.sendASSPMessage(port);
  358. unsigned long a = millis();
  359. return a-currentMillis;
  360. }
  361.  
  362. void task2() {
  363. Serial.println("Device Port4Time");
  364. for (int i = 0; i < 29; i++) {
  365. bool idp = isDeviceOnPort(names[i], 4);
  366. Serial.print("is device ");
  367. Serial.print(names[i]);
  368. Serial.print(" on port ");
  369. Serial.print(4);
  370. Serial.print(" ");
  371. Serial.println(idp);
  372. if (idp == true) {
  373. Serial.print(names[i]);
  374. Serial.print(" ");
  375. Serial.println(getTimeToDevice(names[i], 4));
  376. }
  377. else {
  378. Serial.print(names[i]);
  379. Serial.println(" --(not connected)");
  380. }
  381. }
  382. }
  383.  
  384. void loop() // run over and over
  385. {
  386.  
  387. }
  388.  
  389.  
  390.  
  391.  
  392. //TESTCODE
  393. /*digitalWrite(LED_GREEN, HIGH);
  394.  
  395. // check the state of a switch
  396. emuControl();
  397. int sw1 = digitalRead(SWITCH1);
  398. if (sw1 == LOW){
  399. Serial.println("Switch 1 pressed");
  400. setLeds(HIGH);
  401. }
  402. else{
  403. setLeds(LOW);
  404. }
  405. cycleLeds();
  406. blinkLeds();
  407. cycleLEDS ();
  408. manualControl();
  409. delay(100);*/
  410. /*if (checkSerial ()) {
  411. Serial.print("Send message: ");
  412. Serial.println(serialBuffer);
  413. SerialShield.setMessageContent(serialBuffer);
  414. SerialShield.sendASSPMessage(portControl);
  415. }
  416. while (SerialShield.fetchASSPMessage(portControl)) {
  417. Serial.print("Recieved message: ");
  418. Serial.println(SerialShield.getMessageContent());
  419. processMessageContent(SerialShield.getMessageContent());
  420. }*/
  421. /*int sw2 = digitalRead(SWITCH2);
  422. if (sw2 == LOW) {
  423. SerialShield.setMessageContent("?");
  424. SerialShield.sendASSPMessage(3);
  425. }
  426.  
  427.  
  428.  
  429.  
  430. delay(500); //slow things down by waiting 0.5s
  431. digitalWrite(LED_GREEN, LOW);
  432. Serial.println("loop again!");
  433. delay(500); //slow things down*/
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!