API tools faq
paste
Advertisement
Guest User

Frecce

a guest
Nov 15th, 2018
132
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.20 KB | None | 0 0
raw download clone embed print report
  1. #include "FastLED.h"
  2. #define FASTLED_ALLOW_INTERRUPTS 0
  3.  
  4. #define LED_TYPE WS2812
  5. #define COLOR_ORDER GRB
  6.  
  7. #define NUM_LEDS 8
  8. #define NUM_STRIPS 4
  9. #define Front_SX controllers[0]
  10. #define Rear_SX controllers[1]
  11. #define Front_DX controllers[2]
  12. #define Rear_DX controllers[3]
  13. //#define giallo CRGB(48,235,0)
  14. #define giallo CRGB::Orange
  15. #define rosso CRGB::Red
  16. #define bianco CRGB::White
  17. #define viola CRGB::Purple
  18. #define blu CRGB::CadetBlue
  19. #define spenti CRGB::Black
  20. #define blu CRGB(0,0,255)
  21. #define A spenti
  22. #define B rosso
  23. #define C bianco
  24. #define D viola
  25.  
  26. CRGBPalette16 currentPalette;
  27. CRGBPalette16 currentPalette2;
  28. CRGBPalette16 PaletteFreccia;
  29.  
  30. CRGB leds[NUM_LEDS];
  31. CRGB ledsFSX[NUM_LEDS];
  32. CRGB ledsRSX[NUM_LEDS];
  33. CRGB ledsFDX[NUM_LEDS];
  34. CRGB ledsRDX[NUM_LEDS];
  35.  
  36. CLEDController *controllers[NUM_STRIPS];
  37.  
  38. void setupStripedPalette()
  39. {
  40. //currentPalette = CRGBPalette16(B, B, B, B, A, A, A, A, A, B, B, A, A, A, A, A);
  41. currentPalette = CRGBPalette16(C, C, C, C, A, A, A, A, A, B, B, A, A, A, A, A);
  42. currentPalette2 = CRGBPalette16(B, B, B, B, A, A, A, A, A, C, C, A, A, A, A, A);
  43. PaletteFreccia = CRGBPalette16(D, D, D, D, D, D, D, D, D, D, A, A, A, A, A, A);
  44. //currentPalette2 = CRGBPalette16(C, C, C, C, C, C, C, C, A, A, A, A, A, A, A, A);
  45. }
  46.  
  47. // varibili di test
  48. int zz = 0;
  49. int kk = 0;
  50. // fine variabili di test
  51.  
  52. int const INPUT_SX = 2; //ingresso freccia destra
  53. int const INPUT_DX = 3; //ingresso freccia sinistra
  54. int const INPUT_STOP = 4; //ingresso stop
  55.  
  56. int const INPUT_NO_FLOW = 5; //ingresso dipswitch (se "on" le frecce lampeggiano tutte insieme)
  57. int const INPUT_NO_STOP = 6; //ingresso dipswitch (se "on" le frecce non funzionano da stop)
  58. int const INPUT_NO_POS = 7; //ingresso dipswitch (se "on) le frecce non funzionano da luci di posizione)
  59. int const INPUT_STROBO = 8; //ingresso dipswitch (se "on" viene abilitato l'effetto strobo sull'emergenza)
  60. int const INPUT_ANIMAZIONE = 9; //ingresso dipswitch (se "on" viene abilitata l'animazione all'avvio)
  61. int const INPUT_DRL = 10; //ingresso dipswitch (se "on" aumenta del doppio la luminosità delle luci di posizione)
  62. int const INPUT_FADE = 11; //ingresso dipswitch (se "on" abilita l'effetto fade delle frecce solo tutte insieme)
  63. int const INPUT_RES = 12; //ingresso di riserva
  64. int const Freccia_FDX = 14;
  65. int const Freccia_RDX = 15;
  66. int const Freccia_FSX = 16;
  67. int const Freccia_RSX = 17;
  68.  
  69. int STATO_SX = 0;
  70. int STATO_DX = 0;
  71. int STATO_STOP = 0;
  72.  
  73. int STATO_NO_FLOW = 0;
  74. int STATO_NO_STOP = 0;
  75. int STATO_NO_POS = 0;
  76. int STATO_STROBO = 0;
  77. int STATO_ANIMAZIONE = 0;
  78. int STATO_DRL = 0;
  79. int STATO_FADE = 0;
  80. int STATO_RES = 0;
  81. int LUM_POS = 30;
  82. int const LUM_MAX = 255;
  83. int LUM_TEMP = 0;
  84. int LUM_POS_F = LUM_POS;
  85. int LUM_FADE = 0;
  86.  
  87. int LAMP = 200;
  88. int LampON = 250;
  89. int LampOFF = 250;
  90. int Speed20 = 20;
  91. int Speed16 = 16;
  92. int adj = 150;
  93. int SX = 0;
  94. int DX = 0;
  95. int STATO_POS = 1;
  96. int strb = 0;
  97. int flw = 1;
  98. int brk = 0;
  99. int fade = 0;
  100. int lum = 0;
  101. int startIndex = 210;
  102.  
  103. String CondizioniStringa = "0000";
  104. String CondizioniStringaTEMP = "0000";
  105.  
  106. int i_DX = 0;
  107. int i_SX = 0;
  108. float ValRitardo = 0;
  109. int ValRitardoSpeed = 16;
  110. int ValRitardoLampON = LampON;
  111. int ValRitardoLampOFF = LampOFF;
  112. int BreakFor = 0;
  113.  
  114. void setup() {
  115. Serial.begin(9600);
  116. pinMode(INPUT_SX, INPUT); //aziona freccia sinistra
  117. pinMode(INPUT_DX, INPUT); //aziona freccia destra
  118. pinMode(INPUT_STOP, INPUT); //aziona le luci posteriori in alta luminosità (stop)
  119. pinMode(INPUT_NO_FLOW, INPUT); //disabilita l'effetto flow delle frecce
  120. pinMode(INPUT_NO_STOP, INPUT); //disabilita lo stop
  121. pinMode(INPUT_NO_POS, INPUT); //disabilita le luci di posizione
  122. pinMode(INPUT_STROBO, INPUT); //abilita l'effetto strobo nelle luci di emergenza
  123. pinMode(INPUT_ANIMAZIONE, INPUT); //abilita l'animazione all'accensione
  124. pinMode(INPUT_DRL, INPUT); //aumenta la luminosità delle luci di posizione anteriori
  125. pinMode(INPUT_FADE, INPUT); //abilita l'effetto "incandescenza" delle frecce (no sulle flow)
  126. pinMode(Freccia_FDX, OUTPUT); //pin uscita freccia anteriore destra
  127. pinMode(Freccia_RDX, OUTPUT); //pin uscita freccia posteriore destra
  128. pinMode(Freccia_FSX, OUTPUT); //pin uscita freccia anteriore sinistra
  129. pinMode(Freccia_RSX, OUTPUT);//pin uscita freccia posteriore sinistra
  130. Front_DX = &FastLED.addLeds<LED_TYPE, Freccia_FDX, COLOR_ORDER>(ledsFDX, NUM_LEDS).setCorrection(TypicalLEDStrip);
  131. Rear_DX = &FastLED.addLeds<LED_TYPE, Freccia_RDX, COLOR_ORDER>(ledsRDX, NUM_LEDS).setCorrection(TypicalLEDStrip);
  132. Front_SX = &FastLED.addLeds<LED_TYPE, Freccia_FSX, COLOR_ORDER>(ledsFSX, NUM_LEDS).setCorrection(TypicalLEDStrip);
  133. Rear_SX = &FastLED.addLeds<LED_TYPE, Freccia_RSX, COLOR_ORDER>(ledsRSX, NUM_LEDS).setCorrection(TypicalLEDStrip);
  134. STATO_NO_FLOW = digitalRead(INPUT_NO_FLOW);
  135. STATO_NO_STOP = digitalRead(INPUT_NO_STOP);
  136. STATO_NO_POS = digitalRead(INPUT_NO_POS);
  137. STATO_STROBO = digitalRead(INPUT_STROBO);
  138. STATO_ANIMAZIONE = digitalRead(INPUT_ANIMAZIONE);
  139. STATO_DRL = digitalRead(INPUT_DRL);
  140. STATO_FADE = digitalRead(INPUT_FADE);
  141. STATO_RES = digitalRead(INPUT_RES);
  142. if (STATO_STROBO == HIGH) { //attivazione effetto strobo su emergenza
  143. strb = 1;
  144. }
  145. setupStripedPalette();
  146. static uint8_t startIndex = 0;
  147. if (STATO_NO_POS == HIGH) { //luci di posizione non attive
  148. STATO_POS = 0;
  149. LUM_POS = 0;
  150. LUM_POS_F = 0;
  151. }
  152. if (STATO_DRL == HIGH && STATO_NO_POS == LOW) { //luci posizione anteriore più intense (DRL)
  153. LUM_POS_F = 150;
  154. }
  155. if (STATO_ANIMAZIONE == HIGH) { //animazione iniziale
  156. LUM_TEMP = LUM_MAX;
  157. animazione();
  158. }
  159. if (STATO_NO_FLOW == HIGH) { //animazione flowing delle frecce non attiva
  160. flw = 0;
  161. }
  162. if (STATO_FADE == HIGH) { //effetto "incandescenza" attivo
  163. fade = 1;
  164. }
  165. }
  166.  
  167.  
  168. void posizione_no_fade() { //accende le luci di posizione senza effetto fading o le tiene spente
  169. //se STATO_NO_POS == HIGH spegnere i led
  170. if (STATO_NO_POS == HIGH) {
  171. spento();
  172. }
  173. else {
  174. FRONT(LUM_POS_F, bianco);
  175. REAR(LUM_POS, rosso);
  176. }
  177. }
  178. void posizione_fade() { //accende le luci di posizione con effetto fading
  179. if (lum <= LUM_POS_F && STATO_NO_POS == LOW) {
  180. lum++;
  181. if (lum > LUM_POS) {
  182. REAR(LUM_POS, rosso);
  183. } else {
  184. REAR(lum, rosso);
  185. }
  186. FRONT(lum, bianco);
  187. delay(2);
  188. } else {
  189. posizione_no_fade();
  190. //spento();
  191. }
  192. }
  193. void animazione() {
  194. // noInterrupts();
  195. for (startIndex; startIndex > 0; startIndex = startIndex - 2) {
  196. //startIndex = startIndex + 4; /* higher = faster motion */
  197. delay(15);
  198. fill_palette( ledsFSX, NUM_LEDS,
  199. startIndex, 4, /* higher = narrower stripes */
  200. currentPalette, LUM_MAX, LINEARBLEND);
  201. fill_palette( ledsFDX, NUM_LEDS,
  202. startIndex, 4, /* higher = narrower stripes */
  203. currentPalette, LUM_MAX, LINEARBLEND);
  204. fill_palette( ledsRSX, NUM_LEDS,
  205. startIndex, 4, /* higher = narrower stripes */
  206. currentPalette2, LUM_MAX, LINEARBLEND);
  207. fill_palette( ledsRDX, NUM_LEDS,
  208. startIndex, 4, /* higher = narrower stripes */
  209. currentPalette2, LUM_MAX, LINEARBLEND);
  210. FastLED.show();
  211. }
  212. static uint8_t startIndex = 0;
  213.  
  214. //// Animazione base di fading
  215.  
  216. // if (LUM_TEMP > LUM_POS && STATO_NO_POS == LOW) {
  217. // LUM_TEMP--;
  218. // if (LUM_TEMP > LUM_POS_F) {
  219. // FRONT(LUM_TEMP, bianco);
  220. // } else {
  221. // FRONT(LUM_POS_F, bianco);
  222. // }
  223. // REAR(LUM_TEMP, rosso);
  224. // delay(20);
  225. // }
  226.  
  227. //// Fine animazione base di fading
  228.  
  229. for (LUM_TEMP; LUM_TEMP >= LUM_POS; LUM_TEMP = LUM_TEMP - 1) {
  230. REAR(LUM_TEMP, rosso);
  231. if (LUM_TEMP > LUM_POS_F) {
  232. FRONT(LUM_TEMP, bianco);
  233. } else {
  234. FRONT(LUM_POS_F, bianco);
  235. }
  236. delay(1);
  237. }
  238.  
  239. // for (LUM_TEMP; LUM_TEMP < LUM_POS; LUM_TEMP = LUM_TEMP + 1) {
  240. // REAR(LUM_TEMP, rosso);
  241. // FRONT(LUM_TEMP, bianco);
  242. // delay(10);
  243. // }
  244. }
  245. void FRONT (int LUM_F, CRGB(COLOR)) {
  246. fill_solid( ledsFSX, NUM_LEDS, COLOR);
  247. fill_solid( ledsFDX, NUM_LEDS, COLOR);
  248. Front_SX->showLeds(LUM_F);
  249. Front_DX->showLeds(LUM_F);
  250. }
  251. void REAR (int LUM_R, CRGB(COLOR)) {
  252. fill_solid( ledsRSX, NUM_LEDS, COLOR);
  253. fill_solid( ledsRDX, NUM_LEDS, COLOR);
  254. Rear_DX->showLeds(LUM_R);
  255. Rear_SX->showLeds(LUM_R);
  256. }
  257.  
  258. void SINISTRA (int LUM_SX, CRGB(COLOR)) {
  259. fill_solid( ledsFSX, NUM_LEDS, COLOR);
  260. fill_solid( ledsRSX, NUM_LEDS, COLOR);
  261. Front_SX->showLeds(LUM_SX);
  262. Rear_SX->showLeds(LUM_SX);
  263. }
  264.  
  265. void DESTRA (int LUM_DX, CRGB(COLOR)) {
  266. fill_solid( ledsFDX, NUM_LEDS, COLOR);
  267. fill_solid( ledsRDX, NUM_LEDS, COLOR);
  268. Front_DX->showLeds(LUM_DX);
  269. Rear_DX->showLeds(LUM_DX);
  270. }
  271.  
  272. void spento() { //tutti i led spenti
  273. FRONT(0, spenti);
  274. REAR(0, spenti);
  275. Front_SX->showLeds(0);
  276. Front_DX->showLeds(0);
  277. Rear_DX->showLeds(0);
  278. Rear_SX->showLeds(0);
  279. }
  280.  
  281. void STOP() {
  282. if (brk < NUM_LEDS) {
  283. fill_solid( &(ledsRSX[brk]), NUM_LEDS - brk, spenti);
  284. fill_solid( &(ledsRSX[0]), brk + 1, rosso);
  285. Rear_SX->showLeds(LUM_MAX);
  286. fill_solid( &(ledsRDX[brk]), NUM_LEDS - brk, spenti);
  287. fill_solid( &(ledsRDX[0]), brk + 1, rosso);
  288. Rear_DX->showLeds(LUM_MAX);
  289. delay(1);
  290. brk++;
  291. }
  292. }
  293.  
  294. void Emergenza(int StrobeCount, int FlashDelay, int EndPause) {
  295. StrobeCount = StrobeCount * strb;
  296. FlashDelay = FlashDelay * strb;
  297. for (int j = 0; j < StrobeCount; j++) {
  298. FRONT(LUM_MAX, giallo);
  299. REAR(LUM_MAX, giallo);
  300. delay(FlashDelay);
  301. FRONT(0, spenti);
  302. REAR(0, spenti);
  303. delay(FlashDelay);
  304. }
  305. FRONT(LUM_MAX, giallo);
  306. REAR(LUM_MAX, giallo);
  307. delay((EndPause * 2) - (StrobeCount * FlashDelay));
  308. FRONT(0, spenti);
  309. REAR(0, spenti);
  310. delay(EndPause * 2);
  311. }
  312.  
  313. void freccia_DX() {
  314. if (fade == 0) {
  315. LUM_FADE = LUM_MAX;
  316. }
  317. CondizioniStringaTEMP = CondizioniStringa;
  318. if (LUM_FADE < LUM_MAX) {
  319. DESTRA(LUM_FADE, giallo);
  320. LUM_FADE += 5;
  321. delay(2);
  322. if (CondizioniStringa.charAt(3) == char('1')) {
  323. fill_solid( &(ledsRSX[0]), NUM_LEDS, rosso);
  324. Rear_SX->showLeds(LUM_MAX);
  325. }
  326. } else if (LUM_FADE == LUM_MAX) {
  327. LeggiInput();
  328. DESTRA(LUM_MAX, giallo);
  329. LUM_FADE = 0;
  330. LeggiInput();
  331. for (ValRitardoLampON; ValRitardoLampON > 0; ValRitardoLampON--) {
  332. LeggiInput();
  333. if (CondizioniStringa.charAt(3) == char('1')) {
  334. fill_solid( &(ledsRSX[0]), NUM_LEDS, rosso);
  335. Rear_SX->showLeds(LUM_MAX);
  336. }
  337. if (CondizioniStringa.charAt(3) == char('0')) {
  338. Rear_SX->showLeds(LUM_POS);
  339. }
  340. if (CondizioniStringa.charAt(1) == char('0')) {
  341. break;
  342. }
  343. delay(1);
  344. } ValRitardoLampON = LampON;
  345. DESTRA(0, giallo);
  346. LeggiInput();
  347. for (ValRitardoLampOFF; ValRitardoLampOFF > 0; ValRitardoLampOFF--) {
  348. LeggiInput();
  349. if (CondizioniStringa.charAt(3) == char('1')) {
  350. fill_solid( &(ledsRSX[0]), NUM_LEDS, rosso);
  351. Rear_SX->showLeds(LUM_MAX);
  352. }
  353. if (CondizioniStringa.charAt(3) == char('0')) {
  354. Rear_SX->showLeds(LUM_POS);
  355. }
  356. if (CondizioniStringa.charAt(1) == char('0')) {
  357. break;
  358. }
  359. delay(1);
  360. } ValRitardoLampOFF = LampOFF;
  361. }
  362. }
  363. void freccia_SX() {
  364.  
  365. }
  366.  
  367. void freccia_SX_flow() {
  368. Serial.print(i_SX);
  369. fill_solid( &(ledsFSX[0]), NUM_LEDS, spenti);
  370. fill_solid( &(ledsRSX[0]), NUM_LEDS, spenti);
  371. CondizioniStringaTEMP = CondizioniStringa;
  372. if (i_SX < NUM_LEDS) {
  373. fill_solid( &(ledsFSX[0]), 1 + i_SX, giallo);
  374. fill_solid( &(ledsRSX[0]), 1 + i_SX, giallo);
  375. Front_SX->showLeds(LUM_MAX);
  376. Rear_SX->showLeds(LUM_MAX);
  377. i_SX++;
  378. for (ValRitardoSpeed; ValRitardoSpeed > 0; ValRitardoSpeed--) {
  379. Serial.print(CondizioniStringa);
  380. Serial.print(ValRitardoSpeed);
  381. LeggiInput();
  382. if (CondizioniStringa.charAt(3) == char('1')) {
  383. fill_solid( &(ledsRDX[0]), NUM_LEDS, rosso);
  384. Rear_DX->showLeds(LUM_MAX);
  385. }
  386. if (CondizioniStringa.charAt(3) == char('0')) {
  387. Rear_DX->showLeds(LUM_POS);
  388. }
  389. if (CondizioniStringa.charAt(1) == char('0')) {
  390. break;
  391. }
  392. delay(1);
  393. } ValRitardoSpeed = Speed16;
  394. }
  395. else if (i_SX == NUM_LEDS)
  396. {
  397. LeggiInput();
  398. for (ValRitardoLampON; ValRitardoLampON > 0; ValRitardoLampON--) {
  399. LeggiInput();
  400. if (CondizioniStringa.charAt(3) == char('1')) {
  401. fill_solid( &(ledsRDX[0]), NUM_LEDS, rosso);
  402. Rear_DX->showLeds(LUM_MAX);
  403. }
  404. if (CondizioniStringa.charAt(3) == char('0')) {
  405. Rear_DX->showLeds(LUM_POS);
  406. }
  407. if (CondizioniStringa.charAt(1) == char('0')) {
  408. break;
  409. }
  410. delay(1);
  411. } ValRitardoLampON = LampON;
  412. Front_SX->showLeds(0);
  413. Rear_SX->showLeds(0);
  414. LeggiInput();
  415. for (ValRitardoLampOFF; ValRitardoLampOFF > 0; ValRitardoLampOFF--) {
  416. LeggiInput();
  417. if (CondizioniStringa.charAt(3) == char('1')) {
  418. fill_solid( &(ledsRDX[0]), NUM_LEDS, rosso);
  419. Rear_DX->showLeds(LUM_MAX);
  420. }
  421. if (CondizioniStringa.charAt(3) == char('0')) {
  422. Rear_DX->showLeds(LUM_POS);
  423. }
  424. if (CondizioniStringa.charAt(1) == char('0')) {
  425. break;
  426. }
  427. delay(1);
  428. } ValRitardoLampOFF = LampOFF;
  429. i_SX = 0;
  430. Serial.print(CondizioniStringa);
  431. }
  432. }
  433.  
  434. void freccia_DX_flow() {
  435. fill_solid( &(ledsFDX[0]), NUM_LEDS, spenti);
  436. fill_solid( &(ledsRDX[0]), NUM_LEDS, spenti);
  437. CondizioniStringaTEMP = CondizioniStringa;
  438. if (i_DX < NUM_LEDS) {
  439. fill_solid( &(ledsFDX[0]), 1 + i_DX, giallo);
  440. fill_solid( &(ledsRDX[0]), 1 + i_DX, giallo);
  441. Front_DX->showLeds(LUM_MAX);
  442. Rear_DX->showLeds(LUM_MAX);
  443. i_DX++;
  444. for (ValRitardoSpeed; ValRitardoSpeed > 0; ValRitardoSpeed--) {
  445. LeggiInput();
  446. if (CondizioniStringa.charAt(3) == char('1')) {
  447. fill_solid( &(ledsRSX[0]), NUM_LEDS, rosso);
  448. Rear_SX->showLeds(LUM_MAX);
  449. }
  450. if (CondizioniStringa.charAt(3) == char('0')) {
  451. Rear_SX->showLeds(LUM_POS);
  452. }
  453. if (CondizioniStringa.charAt(1) == char('0')) {
  454. break;
  455. }
  456. delay(1);
  457. } ValRitardoSpeed = Speed16;
  458. }
  459. else if (i_DX == NUM_LEDS)
  460. {
  461. LeggiInput();
  462. for (ValRitardoLampON; ValRitardoLampON > 0; ValRitardoLampON--) {
  463. LeggiInput();
  464. if (CondizioniStringa.charAt(3) == char('1')) {
  465. fill_solid( &(ledsRSX[0]), NUM_LEDS, rosso);
  466. Rear_SX->showLeds(LUM_MAX);
  467. }
  468. if (CondizioniStringa.charAt(3) == char('0')) {
  469. Rear_SX->showLeds(LUM_POS);
  470. }
  471. if (CondizioniStringa.charAt(1) == char('0')) {
  472. break;
  473. }
  474. delay(1);
  475. } ValRitardoLampON = LampON;
  476. Front_DX->showLeds(0);
  477. Rear_DX->showLeds(0);
  478. LeggiInput();
  479. for (ValRitardoLampOFF; ValRitardoLampOFF > 0; ValRitardoLampOFF--) {
  480. LeggiInput();
  481. if (CondizioniStringa.charAt(3) == char('1')) {
  482. fill_solid( &(ledsRSX[0]), NUM_LEDS, rosso);
  483. Rear_SX->showLeds(LUM_MAX);
  484. }
  485. if (CondizioniStringa.charAt(3) == char('0')) {
  486. Rear_SX->showLeds(LUM_POS);
  487. }
  488. if (CondizioniStringa.charAt(1) == char('0')) {
  489. break;
  490. }
  491. delay(1);
  492. } ValRitardoLampOFF = LampOFF;
  493. i_DX = 0;
  494. }
  495. }
  496.  
  497. void loop() {
  498. LeggiInput();
  499. //TABELLA CONDIZIONI
  500.  
  501. if (CondizioniStringa == String("0110") ||
  502. CondizioniStringa == String("0111") ||
  503. CondizioniStringa == String("1110") ||
  504. CondizioniStringa == String("1111")) { //EMERGENZA
  505. i_DX = 0;
  506. i_SX = 0;
  507. ValRitardo = 0;
  508. lum = 0;
  509. FRONT(0, spenti);
  510. REAR(0, spenti);
  511. delay(5);
  512. Emergenza(5, 20, LAMP);
  513. }
  514.  
  515. if (CondizioniStringa == String("1000")) { //LUCI POSIZIONE ATTIVE
  516. ResetVariabili();
  517. posizione_fade();
  518. }
  519.  
  520. if (CondizioniStringa == String("1001")) { //STOP con LUCI DI POSIZIONE
  521. FRONT(LUM_POS_F, bianco);
  522. REAR(LUM_MAX, rosso);
  523. //STOP();
  524. fill_solid( ledsFSX, NUM_LEDS, bianco);
  525. Front_SX->showLeds(LUM_POS_F);
  526. fill_solid( ledsRSX, NUM_LEDS, rosso);
  527. Rear_SX->showLeds(LUM_MAX);
  528. lum = LUM_POS_F;
  529. }
  530.  
  531. if (CondizioniStringa == String("1100")) { //FRECCIA DESTRA con LUCI DI POSIZIONE
  532. lum = LUM_POS_F;
  533. if (flw == 0) {
  534. freccia_DX();
  535. } else {
  536. freccia_DX_flow();
  537. }
  538. fill_solid( ledsFSX, NUM_LEDS, bianco);
  539. Front_SX->showLeds(LUM_POS_F);
  540. fill_solid( ledsRSX, NUM_LEDS, rosso);
  541. Rear_SX->showLeds(LUM_POS);
  542. }
  543.  
  544. if (CondizioniStringa == String("1010")) { //FRECCIA SINISTRA con LUCI DI POSIZIONE
  545. lum = LUM_POS_F;
  546. if (flw == 0) {
  547. freccia_SX();
  548. } else {
  549. freccia_SX_flow();
  550. }
  551. fill_solid( ledsFDX, NUM_LEDS, bianco);
  552. Front_DX->showLeds(LUM_POS_F);
  553. fill_solid( ledsRDX, NUM_LEDS, rosso);
  554. Rear_DX->showLeds(LUM_POS);
  555. }
  556.  
  557. if (CondizioniStringa == String("1101")) { //FRECCIA DESTRA e STOP con LUCI DI POSIZIONE
  558. lum = LUM_POS_F;
  559. if (flw == 0) {
  560. freccia_DX();
  561. } else {
  562. freccia_DX_flow();
  563. }
  564. fill_solid( ledsFSX, NUM_LEDS, bianco);
  565. Front_SX->showLeds(LUM_POS_F);
  566. fill_solid( ledsRSX, NUM_LEDS, rosso);
  567. Rear_SX->showLeds(LUM_MAX);
  568. }
  569.  
  570. if (CondizioniStringa == String("1011")) { //FRECCIA SINISTRA e STOP con LUCI DI POSIZIONE
  571. lum = LUM_POS_F;
  572. if (flw == 0) {
  573. freccia_SX();
  574. } else {
  575. freccia_SX_flow();
  576. }
  577. fill_solid( ledsFDX, NUM_LEDS, bianco);
  578. Front_DX->showLeds(LUM_POS_F);
  579. fill_solid( ledsRDX, NUM_LEDS, rosso);
  580. Rear_DX->showLeds(LUM_MAX);
  581. }
  582.  
  583. if (CondizioniStringa == String("0000")) { //TUTTO SPENTO
  584. ResetVariabili();
  585. spento();
  586. }
  587.  
  588. if (CondizioniStringa == String("0001")) { //STOP
  589. i_SX = 0;
  590. i_DX = 0;
  591. FRONT(0, bianco);
  592. REAR(LUM_MAX, rosso);
  593. //STOP();
  594. }
  595.  
  596. if (CondizioniStringa == String("0100")) { //FRECCIA DESTRA
  597. Rear_SX->showLeds(LUM_POS);
  598. if (flw == 0) {
  599. freccia_DX();
  600. } else {
  601. freccia_DX_flow();
  602. }
  603. }
  604.  
  605. if (CondizioniStringa == String("0010")) { //FRECCIA SINISTRA
  606. Rear_DX->showLeds(LUM_POS);
  607. if (flw == 0) {
  608. freccia_SX();
  609. } else {
  610. freccia_SX_flow();
  611. }
  612. }
  613.  
  614. if (CondizioniStringa == String("0101")) { //FRECCIA DESTRA e STOP
  615. if (flw == 0) {
  616. freccia_DX();
  617. } else {
  618. freccia_DX_flow();
  619. }
  620. }
  621.  
  622. if (CondizioniStringa == String("0011")) { //FRECCIA SINISTRA e STOP
  623. if (flw == 0) {
  624. freccia_SX();
  625. } else {
  626. freccia_SX_flow();
  627. }
  628. }
  629.  
  630. //FINE TABELLA CONDIZIONI
  631. }
  632.  
  633. void LeggiInput() {
  634. if (digitalRead(INPUT_SX) == HIGH) {
  635. STATO_SX = 1;
  636. } else if (digitalRead(INPUT_SX) == LOW) {
  637. STATO_SX = 0;
  638. }
  639. if (digitalRead(INPUT_DX) == HIGH) {
  640. STATO_DX = 1;
  641. } else if (digitalRead(INPUT_DX) == LOW) {
  642. STATO_DX = 0;
  643. }
  644. if (digitalRead(INPUT_STOP) == HIGH) {
  645. STATO_STOP = 1;
  646. } else if (digitalRead(INPUT_STOP) == LOW) {
  647. STATO_STOP = 0;
  648. }
  649. CondizioniStringa = String(String(STATO_POS) + String(STATO_DX) + String(STATO_SX) + String(STATO_STOP));
  650. }
  651.  
  652. void ResetVariabili() {
  653. brk = 0;
  654. i_DX = 0;
  655. i_SX = 0;
  656. ValRitardo = 0;
  657. ValRitardoSpeed = 16;
  658. ValRitardoLampON = LampON;
  659. ValRitardoLampOFF = LampOFF;
  660. LUM_FADE = 0;
  661. }
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!