Fórum témák

» Több friss téma
Fórum » Arduino
A klónok CH340 Soros-USB illesztőjének drivere (Letöltés)
Lapozás: OK   255 / 863
(#) Daszkalosz válasza kapu48 hozzászólására (») Aug 21, 2016 /
 
Belátom hiba volt ilyen gyenge tudással belekezdenem ebbe a projektbe!
Az Rtc-azért alakítottam át mert az időt nem akratam állítani,de utóvégről már bánom. Vissza is állítom.
(#) asasin hozzászólása Aug 21, 2016 /
 
Üdv mindenkinek! Segítséget szeretnék kérni tőletek nemrég kezdtem el foglalkozni valamelyest a robotikával és eléggé kezdő szinten vagyok még. Sikerült megépítenem egy 4 motoros arduino robotot és csak annyit tud hogy kikerüli az akadályokat. És szeretném én is irányítani a robotom egész pontosan Bluetooth-on keresztül. Van két kódom az egyik olyan ami az akadályokat kerüli ki (ez van most a robotba kódolva) és van egy olyan kódom ami bluetooth-os. Nos ezt a két kódot szeretném egyesíteni egy felületen és a kérdés az hogy a két kód közé milyen parancsot írjak hogy egy gombbal tudjam változtatni a két funkciót? Kivitelezhető egyáltalán az hogy két kódot egyesítsek vagy ide teljesen más kódolás kell?
(#) kapu48 válasza asasin hozzászólására (») Aug 21, 2016 / 1
 
Talán kezdjed ezzel a tanfolyammal!:
60 nap alatt Arduino ingyenes tanfolyam
(#) asasin válasza kapu48 hozzászólására (») Aug 21, 2016 /
 
Ez nem is rossz köszi szépen
(#) Vacok hozzászólása Aug 22, 2016 /
 
Sziasztok!
Egy kis segítséget szeretnék kérni. Van egy Atmega328-ra épülő órám és szeretném minimálisan módosítani a programot. A program legelején van egy ilyen részlet:

include <EEPROM.h>

#define CLOCK 2
#define LATCH 3


#define DATA 4
#define COLON 13
#define MIN_BUTTON 0
#define HOUR_BUTTON 1
#define DET_BUTTON 2
#define ALARM_BUTTON 3
#define MIN_BUTTON_PIN 9
#define HOUR_BUTTON_PIN 10
#define DET_BUTTON_PIN 12
#define ALARM_BUTTON_PIN 15
#define LED_PM 16
#define LED_ALARM 17
#define LED_TOP 18
#define LED_DET 19
#define BUZZER 11
#define TRIGGER 14
#define WIRE_1 5
#define WIRE_2 6
#define WIRE_3 7
#define WIRE_4 8
#define TIMER1_SECOND_START 49910
#define DEFAULT_COUNTDOWN_DURATION 10
#define TRIGGER_DURATION_MS 3000
#define SNOOZE_MINUTES 9
#define ALARM_OFF 0
#define ALARM_ON 1
#define ALARM_DET 2

Ahol vastagon szedtem ott értem, hogy a digital pin-hez rendeli az egyes funkciókat, de mondjuk a MIN, HOUR, DET, ALARM_BUTTON 0,1,2,3 és az ALARM_OFF, ON és DET is 0,1,2, ezek mit jelentenek? Aztán megint elkezdi taglalni, hogy MIN, DET, ALARM_BUTTON_PIN.
A ledek pedig analóg lábakon vannak, mint ahogy az ALARM_BUTTON_PIN is, tehát azt sem teljesen értem, hogy a számok ott mit jelentenek.
A digital pin 1-hez szeretnék hozzárendelni egy a olyan funkciót, hogy a hálózati áram meglétét figyelje a processzor, nagyjából stimmel is a dolog:
#define AC_ON 1
pinMode(AC_ON, INPUT);
digitalWrite(AC_ON, LOW);
viszont az AC_ON itt is 1.
Előre is köszönöm a segítséget.
A hozzászólás módosítva: Aug 22, 2016
(#) (Felhasználó 120038) válasza Vacok hozzászólására (») Aug 22, 2016 /
 
Szerintem változók, kezdeti értékkel. Nem lábakat jelölnek majd a későbbiekben a kódban, hanem azok értékei változnak, ha pl a digital read(ALARM_BUTTON_PIN )==High akkor ALARM_ON =1, vagy ilyesmi.

Mennie kellene szerintem amit írtál. Az, hogy a #define AC_ON 1, az csak azt jelenti, hogy felveszi az 1 értéket az AC_ON változód. Ha írsz majd a digitalWrite(AC_ON, LOW); -sorral, az írni is fog az 1-es lábra, mert az AC_ON értéke 1.
csinálhatnád íygy is:
digitalWrite(1, LOW);

illetve:
digitalread(MIN_BUTTON_PIN) helyett:
digitalread(9)

mindkettő egyforma, csak sokkal 'olvashatóbb' a kód, ha 'beszélő' változónévvel csinálod. Az, hogy definiálva van 'MIN_BUTTON_PIN' nem jelenti azt, hogy lefoglalja a lábat, nem állít be semmit, egyszerűen ad egy értéket neki, jelen esetben 9-et.
setupban meg pinMode(MIN_BUTTON_PIN, INPUT); csak annyit jelent, hogy a 9-es láb input lesz. (Mert a MIN_BUTTON_PIN értéke 9)

Meg kell nézned, hogy a program többi részében melyik lábakra ír/olvas a program. Ha semelyik változó sem 1-es (DE CSAK azok közül, ami tényleg azonosítja a lábat ) akkor simán használhatod azt a lábat.

Szóval:
Attól, hogy van egy változód pl MIN_BUTTON_PIN ami 9, attól még lehet egy másik változód, aminek kezdeti értéke szintén ennyi. Mindkettőt másra használod.

Reggel van, ha nem ok amit írtam elnézést!
(#) (Felhasználó 120038) válasza (Felhasználó 120038) hozzászólására (») Aug 22, 2016 /
 
Idézet:
„Ahol vastagon szedtem ott értem, hogy a digital pin-hez rendeli az egyes funkciókat, de mondjuk a MIN...”


Ott még nem rendel lábhoz semmit sem, ne tévesszen meg, hogy _pin a változó neve. Később, majd a setupban belövi a lábat. (Szerintem)

Az, hogy a keresett változóid miért is vannak, azt nem tudhatom pontosan, mert a program többi részét nem látom.
(#) kissi válasza Vacok hozzászólására (») Aug 22, 2016 /
 
Szia!
Ezek csak "helyettesítők"( a fordítóprogramnak szól, nem programutasítás !), azaz, ha valahol később azt írja, hogy "ALARM_OFF", akkor helyette '0'-t kellene írni ( akár lehet is!), csak így olvashatóbb !
(#) szilva válasza (Felhasználó 120038) hozzászólására (») Aug 22, 2016 /
 
Annyival helyesbítenék, hogy ezeket nevezzük inkább makróknak, ezek nem változók. A #define-nal makrókat definiálsz, amit a fordító még fordítási időben kifejt, és a szövegbe helyettesít. A lenti kódrészlet után tehát például mindenhol, ahol a forrásszövegben MIN_BUTTON_PIN szerepel, oda behelyettesít egy 9-est, és a fordításkor ennek megfelelő kód fog készülni.

Egyébként valóban a kód olvashatóságát, illetve könnyű módosíthatóságát célozza az ilyen makrók használata.
(#) (Felhasználó 120038) válasza szilva hozzászólására (») Aug 22, 2016 /
 
Igen, köszi!

Nem értettem pontosan az Angol leírást, ezért nem mertem másképp fogalmazni! Gondolom ez akkor jó, ha ezen értékek nem nagyon változnak a futáskor, így memória takarékosabb lesz a program, mert nem kell const-ként, int-ként lefoglalni ezeket, a fordító majd beírja az értéket és cső. (gondolom én, simán tévedhetek is. Tévedés joga fenntartva! )

Köszi az infót!
(#) kapu48 válasza Vacok hozzászólására (») Aug 22, 2016 /
 
Két hsz.-szel feljebb ajánlottam a tanfolyamot.
Ez rád is vonatkozik!
Vegyél részt rajta!

Utána már nem teszel fel ilyen kezdő kérdéseket.
(#) erdeidominik1999 hozzászólása Aug 22, 2016 /
 
Sziasztok!
Egy időkapcsolót szeretnék csinálni arduból.
A kapcsolást megoldom egyszerűen if(hour()==bekapcsolasora&&minute()==bekapcsolasperc... stb, de azt hogyan tudnám megoldani, hogy ha az arduinó bekapcsolásakor már mennie kéne, akkor induljon? Előre is köszi!
(#) (Felhasználó 120038) válasza erdeidominik1999 hozzászólására (») Aug 22, 2016 /
 
Szia!

Egymásba ágyazott if szerkezetekkel szerintem megoldható.

VAGY:

Ha minden nap kell, akkor elég lehet másodpercekkel operálni. A bekapcsolási időponot megkapod: hour*3600+minute*60 + sec. Úgyanígy átalakítod a bekapcsolás idejét is, majd:
1 nap 86400 sec. szerintem egy long-ba belefér.
if ido_sec_ben>=bekapcsol_ido_secben ......

Ha így csinálod, akkor intevallumot megani is könnyebb lesz!
(#) erdeidominik1999 válasza (Felhasználó 120038) hozzászólására (») Aug 22, 2016 /
 
Igen, erre én is gondoltam, de az a gond, hogy olyat tudnia kéne, hogy este bekapcsol, és másnap reggel kikapcsol...
(#) (Felhasználó 120038) válasza erdeidominik1999 hozzászólására (») Aug 22, 2016 /
 
RTC-t hasznász? Ha igen melyiket?

Arra gondolok, hogy ha azt használsz akkor ott lennie kell DateTime típusnak is! Ekkor csinálhatsz olyat, hogy:
(persze, miután mindegyik DateTime változónak megadtad az évet, hónapot, napot, órát, percet, másodpercet.)
DateTime kezdet;
DateTime vege;
DateTime most;

azután if most>=kezdet && most <vege ...
A hozzászólás módosítva: Aug 22, 2016
(#) erdeidominik1999 válasza (Felhasználó 120038) hozzászólására (») Aug 22, 2016 /
 
Igen, ds3231.
(#) (Felhasználó 120038) válasza erdeidominik1999 hozzászólására (») Aug 22, 2016 /
 
Mennie kellene ahogy írtam.

Bővebben: Link

ott van:
DateTime now = rtc.now();


Include rtc lib az elejére, utána a DateTime objektum simán meglesz szerintem, beállítod az értékeket, majd kipróbálod a >= ill <= operátorokat rá. Ha minden igaz ezt a műveletet megteheted, mert Linux időben mér mindent.
(#) erdeidominik1999 válasza (Felhasználó 120038) hozzászólására (») Aug 22, 2016 /
 
Jó, köszi megnézem.
(#) Vacok válasza (Felhasználó 120038) hozzászólására (») Aug 22, 2016 1 /
 
Szia!
Itt van a teljes program és az a helyzet, hogy setupban sem ír semmit a lábakat illetően.

  1. #include <EEPROM.h>
  2.  
  3. #define CLOCK 2
  4. #define LATCH 3
  5.  
  6.  
  7. #define AC_ON 1
  8. #define DATA 4
  9. #define COLON 13
  10. #define MIN_BUTTON 0
  11. #define HOUR_BUTTON 1
  12. #define DET_BUTTON 2
  13. #define ALARM_BUTTON 3
  14. #define MIN_BUTTON_PIN 9
  15. #define HOUR_BUTTON_PIN 10
  16. #define DET_BUTTON_PIN 12
  17. #define ALARM_BUTTON_PIN 15
  18. #define LED_PM 16
  19. #define LED_ALARM 17
  20. #define LED_TOP 18
  21. #define LED_DET 19
  22. #define BUZZER 11
  23. #define TRIGGER 14
  24. #define WIRE_1 5
  25. #define WIRE_2 6
  26. #define WIRE_3 7
  27. #define WIRE_4 8
  28. #define TIMER1_SECOND_START 65280
  29. #define DEFAULT_COUNTDOWN_DURATION 10
  30. #define TRIGGER_DURATION_MS 3000
  31. #define SNOOZE_MINUTES 9
  32. #define ALARM_OFF 0
  33. #define ALARM_ON 1
  34. #define ALARM_DET 2
  35. #define EEPROM_MAGIC_NUMBER 0xbad0
  36.  
  37. volatile byte hours = 12;
  38. volatile byte minutes = 0;
  39. volatile byte seconds = 0;
  40. volatile boolean pm = false;
  41. volatile unsigned int countdownDuration = DEFAULT_COUNTDOWN_DURATION;
  42. volatile unsigned int countdownSeconds = DEFAULT_COUNTDOWN_DURATION;
  43. unsigned int defaultCountdownSeconds;
  44. boolean detPressed = false;
  45. boolean displayZeros = false;
  46. volatile boolean ticked = false;
  47. boolean displayCountdown = false;
  48. boolean countdownRunning = false;
  49. boolean isDefused = false;
  50. boolean silent = false;
  51.  
  52. byte buttonPins[4] = {MIN_BUTTON_PIN, HOUR_BUTTON_PIN, DET_BUTTON_PIN, ALARM_BUTTON_PIN};
  53. byte buttonState[4] = {HIGH, HIGH, HIGH, HIGH};
  54. unsigned long buttonChange[4] = {0L, 0L, 0L, 0L};
  55.  
  56. byte alarmHours = 12;
  57. byte alarmMinutes = 0;
  58. boolean alarmpm = false;
  59. byte alarmMode = ALARM_OFF;
  60. volatile boolean alarmRinging = false;
  61. boolean displayAlarmTime = false;
  62. // Set to true if you want the PM LED on during PM hours.  I think it's too bright and
  63. // annoying, so I'm setting this to false by default.
  64. boolean usePMIndicator = false;
  65.  
  66. byte snoozeHours = 12;
  67. byte snoozeMinutes = 0;
  68. byte snoozepm = false;
  69. boolean snoozeActivated = false;
  70.  
  71. boolean blank = false;
  72.  
  73. volatile byte currentDigit = 0;
  74.  
  75. void setup() {
  76.  
  77.   pinMode(CLOCK, OUTPUT);
  78.   pinMode(LATCH, OUTPUT);
  79.   pinMode(DATA, OUTPUT);
  80.   pinMode(COLON, OUTPUT);
  81.   digitalWrite(COLON, LOW);
  82.  
  83.   pinMode(AC_ON, INPUT);
  84.   pinMode(LED_PM, OUTPUT);      
  85.   pinMode(LED_ALARM, OUTPUT);      
  86.   pinMode(LED_TOP, OUTPUT);      
  87.   pinMode(LED_DET, OUTPUT);      
  88.   pinMode(BUZZER, OUTPUT);
  89.   pinMode(TRIGGER, OUTPUT);
  90.  
  91.   pinMode(HOUR_BUTTON_PIN, INPUT);    
  92.   pinMode(MIN_BUTTON_PIN, INPUT);    
  93.   pinMode(ALARM_BUTTON_PIN, INPUT);    
  94.   pinMode(DET_BUTTON_PIN, INPUT);    
  95.   pinMode(WIRE_1, INPUT);    
  96.   pinMode(WIRE_2, INPUT);    
  97.   pinMode(WIRE_3, INPUT);    
  98.   pinMode(WIRE_4, INPUT);    
  99.  
  100.   digitalWrite(AC_ON, LOW);
  101.   digitalWrite(HOUR_BUTTON_PIN, HIGH);
  102.   digitalWrite(MIN_BUTTON_PIN, HIGH);
  103.   digitalWrite(ALARM_BUTTON_PIN, HIGH);
  104.   digitalWrite(DET_BUTTON_PIN, HIGH);
  105.   digitalWrite(WIRE_1, HIGH);
  106.   digitalWrite(WIRE_2, HIGH);
  107.   digitalWrite(WIRE_3, HIGH);
  108.   digitalWrite(WIRE_4, HIGH);
  109.  
  110.   // Read data from EEPROM
  111.   // User can hold HOUR and MIN buttons to skip EEPROM read (factory reset procedure).
  112.   if (EEPROMValid() && (!((buttonPressed(HOUR_BUTTON)) && (buttonPressed(MIN_BUTTON))))) {
  113.     hours = EEPROM.read(2);
  114.     minutes = EEPROM.read(3);
  115.     seconds = EEPROM.read(4);
  116.     pm = EEPROM.read(5);
  117.     alarmHours = EEPROM.read(6);
  118.     alarmMinutes = EEPROM.read(7);
  119.     alarmpm = EEPROM.read(8);
  120.     alarmMode = EEPROM.read(9);
  121.     defaultCountdownSeconds = EEPROM.read(10);
  122.     defaultCountdownSeconds = defaultCountdownSeconds << 8;
  123.     defaultCountdownSeconds |= EEPROM.read(11);
  124.     if (defaultCountdownSeconds > 5999) {
  125.       // guard against bad data
  126.       defaultCountdownSeconds = DEFAULT_COUNTDOWN_DURATION;
  127.     }
  128.   } else {
  129.     hours = 12;
  130.     minutes = 0;
  131.     seconds = 0;
  132.     alarmHours = 12;
  133.     alarmMinutes = 0;
  134.     pm = false;
  135.     alarmpm = false;
  136.     alarmMode = ALARM_OFF;
  137.     defaultCountdownSeconds = DEFAULT_COUNTDOWN_DURATION;
  138.     writeEEPROM();
  139.   }
  140.  
  141.  
  142.  
  143.   // Initialize timers.
  144.   // Timer2 is used to keep the clock time
  145.   // Timer1 is used for the display multiplexing
  146.  
  147.   // Disable the timer overflow interrupt
  148.   TIMSK1 &= ~(1 << TOIE1);
  149.  
  150.   // Set timer1 to normal mode
  151.   TCCR1A &= ~((1 << WGM11) | (1 << WGM10));
  152.   TCCR1B &= ~((1 << WGM12) | (1 << WGM13));
  153.  
  154.   // Use internal I/O clock
  155.   ASSR &= ~(1 << AS2);
  156.  
  157.   // Disable compare match interrupt
  158.   TIMSK1 &= ~(1 << OCIE1A);
  159.  
  160.   // Prescalar is clock divided by 128
  161.   TCCR1B = (1 << CS10) | (1 << CS11);
  162.  
  163.   // Start the counting at 0
  164.   TCNT1 = TIMER1_SECOND_START;
  165.  
  166.   // Enable the timer1 overflow interrupt
  167.   TIMSK1 |= (1 << TOIE1);  
  168.  
  169.  
  170.   // init timer2
  171.   // set prescaler to 256
  172.   TIMSK2 &= ~(1 << TOIE2);
  173.  
  174.   // Use crystal clock
  175.   ASSR = (1 << AS2);
  176.  
  177.   TCCR2A = 0;
  178.   TCCR2B = (1 << CS21) | (1 << CS20);
  179.   TIMSK2 |= (1 << TOIE2);
  180.   // With prescalar of 128, TCNT1 increments 256 times per second
  181.   TCNT2 = 0;
  182.  
  183.   randomSeed(analogRead(0));
  184.  
  185.   if (buttonPressed(DET_BUTTON)) {
  186.     // enable silent mode for testing
  187.     beep(3500, 50);
  188.     silent = true;
  189.     while (buttonPressed(DET_BUTTON)); // wait for release
  190.   }
  191.  
  192.   while ((buttonPressed(HOUR_BUTTON)) || (buttonPressed(MIN_BUTTON))); // wait for release of factory reset procedure
  193.  
  194. }
  195.  
  196. void loop() {
  197.  
  198.   delay(10); // this helps with button debouncing
  199.  
  200.   if (ticked) {
  201.     ticked = false;
  202.     writeEEPROM();
  203.   }
  204.  
  205.   if (alarmRinging) {
  206.     if (alarmMode == ALARM_ON) {
  207.       ringAlarm();
  208.     }
  209.     if (alarmMode == ALARM_DET) {
  210.       for(int i=0;i<4;i++) {
  211.         beep(3900, 250, false);
  212.         delay(250);
  213.       }
  214.       displayCountdown = true;
  215.       countdownSeconds = defaultCountdownSeconds;
  216.       countdown();
  217.       alarmRinging = false;
  218.     }
  219.   }
  220.  
  221.   // check input
  222.   if ((buttonPressed(ALARM_BUTTON)) && (!displayCountdown)) {
  223.     displayAlarmTime = true;
  224.     if (alarmpm) {
  225.       digitalWrite(LED_PM, HIGH);
  226.     } else {
  227.       digitalWrite(LED_PM, LOW);
  228.     }
  229.     if (alarmMode == ALARM_OFF) {
  230.       digitalWrite(LED_ALARM, LOW);
  231.       digitalWrite(LED_DET, LOW);
  232.     } else {
  233.       digitalWrite(LED_ALARM, HIGH);
  234.       if (alarmMode == ALARM_DET) {
  235.         digitalWrite(LED_DET, HIGH);
  236.       } else {
  237.         digitalWrite(LED_DET, LOW);
  238.       }
  239.     }
  240.   } else {
  241.     displayAlarmTime = false;
  242.   }
  243.    
  244.   if (buttonPressedNew(HOUR_BUTTON) || buttonHeld(HOUR_BUTTON, 150)) {
  245.     if ((!displayAlarmTime) && (!displayCountdown)) {
  246.       hours++;
  247.       if (hours == 12) {
  248.         pm = !pm;
  249.       }
  250.       if (hours == 13) {
  251.         hours = 1;
  252.       }
  253.       if (pm) {
  254.         digitalWrite(LED_PM, HIGH);
  255.       } else {
  256.         digitalWrite(LED_PM, LOW);
  257.       }
  258.     }
  259.     if (displayAlarmTime) {
  260.       // setting the alarm
  261.       alarmHours++;
  262.       if (alarmHours == 12) {
  263.         alarmpm = !alarmpm;
  264.       }
  265.       if (alarmHours == 13) {
  266.         alarmHours = 1;
  267.       }
  268.       if (alarmpm) {
  269.         digitalWrite(LED_PM, HIGH);
  270.       } else {
  271.         digitalWrite(LED_PM, LOW);
  272.       }
  273.       snoozeHours = alarmHours;
  274.       snoozeMinutes = alarmMinutes;
  275.       snoozepm = alarmpm;
  276.     }
  277.     if (displayCountdown) {
  278.       if (!buttonPressed(ALARM_BUTTON)) {
  279.         if (countdownSeconds < 5940) {
  280.           countdownSeconds += 60;
  281.           countdownDuration += 60;
  282.         }
  283.       } else {
  284.         if (countdownSeconds >= 60 ) {
  285.           countdownSeconds -= 60;
  286.           countdownDuration -= 60;
  287.         }
  288.       }
  289.     }
  290.   } else {
  291.     if ((!displayAlarmTime) && (!buttonPressed(HOUR_BUTTON))) {
  292.       if ((pm) && (usePMIndicator)) {
  293.         digitalWrite(LED_PM, HIGH);
  294.       } else {
  295.         digitalWrite(LED_PM, LOW);
  296.       }
  297.     }
  298.   }
  299.  
  300.   if (buttonPressedNew(MIN_BUTTON) || buttonHeld(MIN_BUTTON, 150)) {
  301.     if ((!displayAlarmTime) && (!displayCountdown)) {
  302.       minutes++;
  303.       if (minutes == 60) {
  304.         minutes = 0;
  305.       }
  306.       seconds = 0;
  307.       TCNT2 = 0;
  308.     }
  309.     if (displayAlarmTime) {
  310.       // setting the alarm
  311.       alarmMinutes++;
  312.       if (alarmMinutes == 60) {
  313.         alarmMinutes = 0;
  314.       }
  315.       snoozeHours = alarmHours;
  316.       snoozeMinutes = alarmMinutes;
  317.       snoozepm = alarmpm;
  318.     }
  319.     if (displayCountdown) {
  320.       if (!buttonPressed(ALARM_BUTTON)) {
  321.         if (countdownSeconds < 5999) {
  322.           countdownSeconds++;
  323.           countdownDuration++;
  324.         }
  325.       } else {
  326.         if (countdownSeconds > 0) {
  327.           countdownSeconds--;
  328.           countdownDuration--;
  329.         }
  330.       }
  331.     }
  332.   }
  333.  
  334.   if (buttonPressedNew(DET_BUTTON)) {
  335.     if (displayAlarmTime) {
  336.       alarmMode++;
  337.       if (alarmMode > ALARM_DET) {
  338.         alarmMode = ALARM_OFF;
  339.       }
  340.       if (alarmMode == ALARM_OFF) {
  341.         snoozeActivated = false;
  342.       }
  343.       return;
  344.     }
  345.     if ((displayZeros) || (isDefused)) {
  346.       isDefused = false;
  347.       displayZeros = false;
  348.       displayCountdown = false;
  349.       return;
  350.     }
  351.     // The DET button has been pressed but not released yet.
  352.     detPressed = true;
  353.     countdownSeconds = defaultCountdownSeconds;
  354.     displayCountdown = true;
  355.   }
  356.  
  357.   if (!buttonPressed(DET_BUTTON)) {
  358.     if (detPressed) {
  359.       detPressed = false;
  360.       defaultCountdownSeconds = countdownSeconds;
  361.       writeEEPROM();
  362.       countdown();
  363.     }
  364.   }
  365.  
  366. }
  367.  
  368. void ringAlarm() {
  369.   int frequency = 3900;
  370.   int duration = 250;  // each beep is .25s
  371.   int us = 1000000 / frequency / 2;
  372.   int toneLoopCount = (duration * ((float)frequency/1000.0));
  373.   int pauseLoopCount = 20000;
  374.  
  375.   while (alarmRinging) {
  376.     for(int i=0;i<toneLoopCount;i++) {
  377.       PORTB |= (1 << 3);
  378.       if (buttonPressed(ALARM_BUTTON)) {
  379.         alarmRinging = false;
  380.         snoozeActivated = false;
  381.         break;
  382.       }
  383.       delayMicroseconds(us);
  384.       PORTB &= ~(1 << 3);
  385.       if (buttonPressed(DET_BUTTON)) {
  386.         alarmRinging = false;
  387.         snooze();
  388.         break;
  389.       }
  390.       delayMicroseconds(us);
  391.     }
  392.    
  393.     for(int i=0;i<pauseLoopCount;i++) {
  394.       if (buttonPressed(ALARM_BUTTON)) {
  395.         alarmRinging = false;
  396.         snoozeActivated = false;
  397.         break;
  398.       }
  399.       if (buttonPressed(DET_BUTTON)) {
  400.         alarmRinging = false;
  401.         snooze();
  402.         break;
  403.       }
  404.     }
  405.   } // while (alarmRinging)
  406. }
  407.  
  408. void snooze() {
  409.   snoozeActivated = true;
  410.  
  411.   // set the snooze time to current time plus 9 minutes
  412.   snoozeHours = hours;
  413.   snoozepm = pm;
  414.   snoozeMinutes = minutes + SNOOZE_MINUTES;
  415.   if (snoozeMinutes >= 60) {
  416.     snoozeMinutes -= 60;
  417.     snoozeHours++;
  418.     if (snoozeHours == 12) {
  419.       snoozepm = !snoozepm;
  420.     }
  421.     if (snoozeHours == 13) {
  422.       snoozeHours = 1;
  423.     }
  424.   }
  425. }
  426.  
  427. void countdown() {
  428.   int ledCounter = 0;
  429.   int ledCounterThreshold = 100000;
  430.   byte ledCurrentState = HIGH;
  431.   byte defusePin;
  432.   byte detPin;
  433.   boolean defused = false;
  434.   countdownRunning = true;
  435.   int fractionalSecond;
  436.  
  437.  
  438.   // assign random pins
  439.   defusePin = random(WIRE_1, (WIRE_4+1));
  440.   detPin = defusePin;
  441.   while (detPin == defusePin) {
  442.     detPin = random(WIRE_1, (WIRE_4+1));
  443.   }
  444.  
  445.   digitalWrite(LED_PM, LOW); // turn off the PM LED
  446.  
  447.   // Keep track of how far we are into the current
  448.   // second so we can correct later.
  449.   fractionalSecond = TCNT2 - 0;
  450.  
  451.   // Reset back to the last second boundary so we can start the countdown
  452.   // immediately and so that the first second isn't truncated
  453.   TCNT2 = 0;
  454.  
  455.   beep(3800, 30);
  456.   digitalWrite(LED_DET, ledCurrentState);
  457.   while ((countdownSeconds > 0) && (!defused)) {
  458.     for(int i=0;i<10000;i++) {
  459.       // get input
  460.       if (digitalRead(detPin) == HIGH) {
  461.         countdownSeconds = 0;
  462.         break;
  463.       }
  464.       if (digitalRead(defusePin) == HIGH) {
  465.         defused = true;
  466.         break;
  467.       }
  468.     }
  469.     delay(20);
  470.     if (ledCounter++ > ledCounterThreshold) {
  471.       ledCounter = 0;
  472.       if (ledCurrentState == HIGH) {
  473.         ledCurrentState = LOW;
  474.       } else {
  475.         ledCurrentState = HIGH;
  476.       }
  477.       digitalWrite(LED_DET, ledCurrentState);
  478.     }
  479.   }
  480.   digitalWrite(LED_DET, LOW);
  481.   countdownRunning = false;
  482.   if (!defused) {
  483.     detonate();
  484.   } else {
  485.     beep(4500, 80);
  486.     isDefused = true;
  487.     delay(2000);
  488.   }
  489.  
  490.   // Now to keep the time accurate, add back in the fractional
  491.   // second that we took off when we started the countdown sequence.
  492.   // Wait until we can add it back to TCNT1 without overflowing.
  493.   while (TCNT2 >= (255 - fractionalSecond));
  494.   TCNT2 += fractionalSecond;
  495. }
  496.  
  497. void detonate() {
  498.   for(int i=0;i<8;i++) {
  499.     digitalWrite(LED_DET, HIGH);
  500.     beep(5000, 50, false);
  501.     delay(25);
  502.     digitalWrite(LED_DET, LOW);
  503.     delay(25);
  504.   }
  505.  
  506.   blank = true;
  507.  
  508.   unsigned long triggerStart = millis();
  509.   unsigned long triggerStop = triggerStart + TRIGGER_DURATION_MS;
  510.   digitalWrite(TRIGGER, HIGH);
  511.  
  512.   for(int i=0;i<50;i++) {
  513.     if (millis() >= triggerStop) {
  514.       digitalWrite(TRIGGER, LOW);
  515.     }
  516.     digitalWrite(random(LED_PM, LED_DET+1), HIGH);
  517.     digitalWrite(random(LED_PM, LED_DET+1), HIGH);
  518.     for(int j=0;j<5;j++) {
  519.       beep(random(100, 300), 10);
  520.     }
  521.     for(int led=LED_PM;led<=LED_DET;led++) {
  522.       digitalWrite(led, LOW);
  523.     }
  524.   }
  525.  
  526.   displayCountdown = false;
  527.   blank = false;
  528.   displayZeros = true;
  529.  
  530.   while (millis() < triggerStop) {
  531.     if (buttonPressedNew(DET_BUTTON)) {
  532.       displayZeros = false;
  533.       break;
  534.     }
  535.   }
  536.  
  537.   digitalWrite(TRIGGER, LOW);
  538. }
  539.  
  540. // return true if the button is pressed.
  541. boolean buttonPressed(byte button) {
  542.   if (digitalRead(buttonPins[button]) == LOW) {
  543.     // the button is currently pressed
  544.     if (buttonState[button] == HIGH) {
  545.       // if the button was not pressed before, update the state.
  546.       buttonChange[button] = millis();
  547.       buttonState[button] = LOW;
  548.     }
  549.     return true;
  550.   } else {
  551.     // The button is currently not pressed
  552.     if (buttonState[button] == LOW) {
  553.       // if the button was pressed before, update the state.
  554.       buttonChange[button] = millis();
  555.       buttonState[button] = HIGH;
  556.     }
  557.     return false;
  558.   }
  559. }
  560.  
  561. // return true if the button is pressed and it is a new press (not held)
  562. boolean buttonPressedNew(byte button) {
  563.   if (digitalRead(buttonPins[button]) == LOW) {
  564.     // The button is currently pressed
  565.     if (buttonState[button] == HIGH) {
  566.       // This is a new press.
  567.       buttonChange[button] = millis();
  568.       buttonState[button] = LOW;
  569.       return true;
  570.     }
  571.     // This is not a new press.
  572.     return false;
  573.   } else {
  574.     // The button is currently not pressed
  575.     if (buttonState[button] == LOW) {
  576.       buttonChange[button] = millis();
  577.       buttonState[button] = HIGH;
  578.     }
  579.     return false;
  580.   }
  581. }
  582.  
  583. // return true if the button is pressed and has been held for at least n milliseconds
  584. boolean buttonHeld(byte button, int n) {
  585.   if (digitalRead(buttonPins[button]) == LOW) {
  586.     // the button is currently pressed
  587.     if (buttonState[button] == HIGH) {
  588.       // if the button was not pressed before, update the state and return false.
  589.       buttonChange[button] = millis();
  590.       buttonState[button] = LOW;
  591.       return false;
  592.     }
  593.     if ((millis() - buttonChange[button]) >= n) {
  594.       // the button has been pressed for over n milliseconds.
  595.       // update the state change time even though the state hasn't changed.
  596.       // we update the state change time so we can start the counting over
  597.       buttonChange[button] = millis();
  598.       return true;
  599.     }
  600.     // The button is being held, but has not been held for longer than n milliseconds.
  601.     return false;
  602.   } else {
  603.     // The button is currently not pressed
  604.     if (buttonState[button] == LOW) {
  605.       // if the button was pressed before, update the state.
  606.       buttonChange[button] = millis();
  607.       buttonState[button] = HIGH;
  608.     }
  609.     return false;
  610.   }
  611. }
  612.  
  613. void beep(int frequency, int duration) {
  614.   beep(frequency, duration, true);
  615. }
  616.  
  617. void beep(int frequency, int duration, boolean disableDisplayInterrupt) {
  618.   int us = 1000000 / frequency / 2;
  619.   int loopCount = (duration * ((float)frequency/1000.0));
  620.   if (disableDisplayInterrupt) {
  621.     TIMSK1 &= ~(1 << TOIE1);
  622.   }
  623.   for(int i=0;i<loopCount;i++) {
  624.     if (!silent) PORTB |= (1 << 3);
  625.     delayMicroseconds(us);
  626.     if (!silent) PORTB &= ~(1 << 3);
  627.     delayMicroseconds(us);
  628.   }
  629.   TIMSK1 |= (1 << TOIE1);
  630. }
  631.  
  632. void writeEEPROM() {
  633.   setEEPROMValid();
  634.   EEPROM.write(2, hours);
  635.   EEPROM.write(3, minutes);
  636.   EEPROM.write(4, seconds);
  637.   EEPROM.write(5, pm);
  638.   EEPROM.write(6, alarmHours);
  639.   EEPROM.write(7, alarmMinutes);
  640.   EEPROM.write(8, alarmpm);
  641.   EEPROM.write(9, alarmMode);
  642.   EEPROM.write(10, (defaultCountdownSeconds >> 8));
  643.   EEPROM.write(11, (defaultCountdownSeconds & 0xFF));
  644. }
  645.  
  646. boolean EEPROMValid() {
  647.   // determine if the EEPROM has ever been written by this firmware
  648.   // so we can determine if the values can be trusted
  649.   unsigned int magic = EEPROM.read(0);
  650.   magic = magic << 8;
  651.   magic |= EEPROM.read(1);
  652.   return (magic == EEPROM_MAGIC_NUMBER);
  653. }
  654.  
  655. void setEEPROMValid() {
  656.   EEPROM.write(0, EEPROM_MAGIC_NUMBER >> 8);
  657.   EEPROM.write(1, (EEPROM_MAGIC_NUMBER & 0xFF));
  658. }
  659.  
  660. // This is the display interrupt to implement multiplexing of the digits.
  661. ISR(TIMER1_OVF_vect) {
  662.   byte nDigits = 4;
  663.   byte data;
  664.   byte digitValue;
  665.   byte displayHours, displayMinutes;
  666.  
  667.   TCNT1 = TIMER1_SECOND_START;
  668.  
  669.   displayHours = hours;
  670.   displayMinutes = minutes;
  671.   if (displayAlarmTime) {
  672.     displayHours = alarmHours;
  673.     displayMinutes = alarmMinutes;
  674.   }
  675.   if (displayCountdown) {
  676.     displayHours = countdownSeconds / 60;
  677.     displayMinutes = countdownSeconds % 60;
  678.   }
  679.   if (displayZeros) {
  680.     displayHours = 0;
  681.     displayMinutes = 0;
  682.   }
  683.  
  684.   if ((displayHours < 10) && (!displayCountdown) && (!displayZeros)) {
  685.     nDigits = 3;
  686.   }
  687.  
  688.  
  689.   if (++currentDigit > (nDigits-1)) {
  690.     currentDigit = 0;
  691.   }
  692.  
  693.   switch (currentDigit) {
  694.   case 0:
  695.     digitValue = displayMinutes % 10;
  696.     break;
  697.   case 1:
  698.       digitValue = displayMinutes / 10;
  699.     break;
  700.   case 2:
  701.     digitValue = displayHours % 10;
  702.     break;
  703.   case 3:
  704.     digitValue = displayHours / 10;
  705.     break;
  706.   }
  707.  
  708.   // Upper 4 bits of data are the value for the current digit.
  709.   // They are loaded into shift register outputs QA-QD
  710.   data = (digitValue << 4);
  711.  
  712.   // Lower 4 bits 3-0 represent which digit to turn on.
  713.   // 3 is most significant digit, 0 is least
  714.   // They are loaded into shift register outputs QE-QH
  715.   // Digit transistors are active low, so set them all high
  716.   data |= 0x0F;
  717.  
  718.   if (!blank) {
  719.     // now turn off the bit for digit we want illuminated.
  720.     data &= ~(1 << currentDigit);
  721.   }
  722.  
  723.   digitalWrite(LATCH, LOW);
  724.   shiftOut(DATA, CLOCK, LSBFIRST, data);
  725.   digitalWrite(LATCH, HIGH);
  726. }
  727.  
  728.  
  729. // Timer 2 interrupt.  This executes every second.
  730. ISR(TIMER2_OVF_vect) {
  731.   TCNT2 = 0;
  732.  
  733.   ticked = true;
  734.   seconds++;
  735.   if (seconds == 60) {
  736.     seconds = 0;
  737.     minutes++;
  738.     if (minutes == 60) {
  739.       minutes = 0;
  740.       hours++;
  741.       if (hours == 12) {
  742.         pm = !pm;
  743.       }
  744.       if (hours == 13) {
  745.         hours = 1;
  746.       }
  747.     }
  748.   }
  749.  
  750.   if ((!countdownRunning) && (alarmMode != ALARM_OFF)) {
  751.     if ((alarmHours == hours) && (alarmMinutes == minutes) && (seconds == 0) && (alarmpm == pm)) {
  752.       alarmRinging = true;
  753.     }
  754.     if ((snoozeActivated) && (snoozeHours == hours) && (snoozeMinutes == minutes) && (seconds == 0) && (snoozepm == pm)) {
  755.       alarmRinging = true;
  756.     }
  757.   }
  758.  
  759.   if ((countdownRunning) && (countdownSeconds > 0)) {
  760.     beep(3800, 30);
  761.     countdownSeconds--;
  762.   }
  763. }
A hozzászólás módosítva: Aug 22, 2016
(#) (Felhasználó 120038) válasza Vacok hozzászólására (») Aug 22, 2016 / 1
 
Szia!

Dehogynem. Ott adja meg a kontrollernek, hogy az adott számú láb input, vagy output lesz.
pinMode(MIN_BUTTON_PIN, INPUT); azaz a 9-es láb input.

azután az 52.sorban ezeket az értékeket simán átadja egy tömbnek (mármint a button-okat.). A tömb elemeivel pl 542 és 562. sorban operál.

Airsoft bomba? Nekem is kellene egyet összeraknom, de ennél egyszerűbbet. 700+ sor most kicsit sok.
(#) Vacok válasza (Felhasználó 120038) hozzászólására (») Aug 22, 2016 /
 
Az bizony, a programot nem én írtam, én csak egy picit a magam szájíze szerint módosítom. Kezdő AVResként egyenlőre csak töröm a dolgot.
Ami a korábbi kérdésem volt az végül is működik, csak kíváncsiságképpen tettem fel a kérdést, hogy ez így hogyan működik, mert amit arduino-s programozással kapcsolatban olvasgattam ott nem így volt leírva, de akkor jól gondoltam.
Ami jelenleg problémát jelen, hogy ha ébresztőt állítok be (ALARM_ON) akkor ha megnyomom az (ALARM_BUTTON)-t akkor le kell állnia a csörgésnek és ez működik is, viszont random módon a leállás után elkezd sípolni, a program nem fagy le, mert minden más funkció működik.
Eredetileg a idő mérés Timer1-ről ment egy 16MHz kvarcról, Timer2-ről pedig a kijelzés. Én a kettőt megcseréltem és a Timer2-t aszinkron módba állítottam egy órakvarccal, így jóval pontosabb lett az óra, minden más megy Timer1-ről belső 8MHz órajelről. Nem tudom, hogy vajon itt rontottam el valamit, vagy az óracsörgés programrésznél van valami gond? Én nem találtam semmi erre utaló hibát, de ez nem jelent semmit. Vagy hardware hiba?
A hozzászólás módosítva: Aug 22, 2016
(#) Vacok válasza Vacok hozzászólására (») Aug 22, 2016 /
 
Valami miatt a 17-es láb, amire a BUZZER van kötve random H szintre mászik és a zümmer a saját frekvenciáján elkezd sípolni.
(#) (Felhasználó 120038) válasza Vacok hozzászólására (») Aug 22, 2016 /
 
Jól, vagy rosszul megírt program azt nem tudom, viszont nem annyira egyszerű első ránézésre. A #define részeket azért írta, hogy könnyen változtatni tudjon a program futásának módján.

Nézegettem a kódot, de nem láttam hibát, miért kezd el dalolászás után még zümmögni is.
Elvileg nem kellene neki, mert a dalolászó rutin után -mivel abban belövi a szükséges változókat false-ra - nem ír 17 es lábra 1-t.

De persze tévedhetek ekkora kódnál.

A 17-es láb le van húzva földre ellenálláson keresztül?
(#) Vacok válasza (Felhasználó 120038) hozzászólására (») Aug 23, 2016 /
 
Nincs, tulajdonképpen lóg a levegőben, csak a zümmer van rákövtve.
(#) Vacok válasza Vacok hozzászólására (») Aug 23, 2016 /
 
Még arra gondoltam, hogy nem lehet-e gond, hogy a kontroller be volt ültetve a helyére és úgy próbáltam meg programozni ISP-n keresztül, az ISP lábai meg használatban vannak az órában is. Az égető program nem tudott vele kommunikálni és lehet hogy a kontrollernek ez a lába megkergült.
(#) (Felhasználó 120038) válasza Vacok hozzászólására (») Aug 23, 2016 /
 
Sajnos nem tudom mi lehet a gond. Majd még ránézek a kódra, (ami nem kicsi azért!) de az is lehet a probléma, hogy zaj terhelődik a zümmert kapcsoló lábára. Pl ír a mellette lévőkre, stb, hiába lesz 0 logikailag a kódból (Mondjuk rá is mérhetsz mikor zümmög, hogy a 17-es lábon mekkora a fesz), attól még fizikailag 3.1-3.2 akármennyi fesz megjelenhet, ami bekapcsoja a zümmert.

Még valami, de ne sértődj meg a kérdésen: A zümmer bekapcsolásához mekkora logikai 1 hez tartozó feszültség kell? 3.3V vagy 5V nem mindegy, én már futottam ilyenbe bele... (Ok az is lehet, hogy másképpen van megoldva, pl relén keresztül kapcsolod, de akkor annak mekkora a logikai 1 hez tartozó feszültsége).

Minden logikai kapcsolást igénylő ezköz (LED display,LCD, Relé stb.) ,input lábai közös GND-n vannak? (Gondolom igen, csak kérdezem)
Arra gondolok, hogy minden logikai 1 hez tartozó 5V ugyanahhoz a földhöz viszonyított?
A hozzászólás módosítva: Aug 23, 2016
(#) kapu48 válasza Vacok hozzászólására (») Aug 23, 2016 /
 
Ilyen hosszú interuptok meg szaggatják a Beep-et, azért cincog!

Amíg zenélsz, addig mást nem tud csinálni a procid, tilsd le előtte a megszakítást!
Csak az meg az időzítéseket késlelteti.

Megszakításban egyébként sem illik muzsikálgatni!
Mert addig a másik timer megszakítás nem tud érvényesülni, megint csak csúszik az ídőzítés!

Szóval használj inkább valami HW.-s hangkeltő eszközt, ami nem foglal proci időt!
(Csipogót, MP3 lejátszót)

Bővebben: Link
A hozzászólás módosítva: Aug 23, 2016
(#) Vacok válasza (Felhasználó 120038) hozzászólására (») Aug 23, 2016 /
 
Egyáltalán nem sértődöm meg, sőt, így kapok ötletet, hogy hol kereshessem a hibát, viszont sajnos itt nincs. A kapcsoláson belül egy föld van, így ez nem jön számításba. A 17-es lábat pedig teljesen kikötöttem, így valós értékeket tudtam rajta mérni, és így is random húz H szintre, a feszültség pedig 5V rajta.
(#) Vacok válasza kapu48 hozzászólására (») Aug 23, 2016 /
 
Az az érdekes, hogy ebből az órából már hármat készítettem és eddig mind gond nélkül működik. Most apró változtatásokat végeztem a hardware-en, soros programozó portot tettem a panelre (nem használható), egy analóg kimenetet megszüntettem, és egy tápfeszfigyelő digitális bemenetet kötöttem és programoztam be.
Most az a tervem, hogy a korábban megépített órák valamelyikébe beleteszem ezt a procit, amivel a gond van a korábbi hex fájlt beletöltve, akkor kiderül, hogy a proci rossz-e vagy a hardware.
(#) Eregyenlouperi hozzászólása Aug 23, 2016 /
 
Sziasztok !

Van egy arduiono unom amelyben ATMEGA328P dolgozik. Fut rajta egy alkalmazás pl egy LED villogtató progi. Ha ezt a felprogramozott procit kiemelem az alaplapi foglalatból és felépítek neki egy panelt osszcival , megfelelő helyre bekötött LED-ekkel (maradva a fenti példánál) stb.. akkor fog az működni ? Tehát a másik kontrollerre ami még megtalálható az alaplapon van e szüksége a 328P-nek a program futtatása közben? Ha ez működik akkor volna még egy kérdésem . a 16Mhz-től eltérő kvarc-al lehet e járatni a kütyüt ? Van egy csomó 4 és 6Megás kristályom minek vegyek 16-ost ha ráadásul a sebesség nem is lényeges jesetemben...

Üdv.
Következő: »»   255 / 863
Bejelentkezés

Belépés

Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem