API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 10th, 2014
191
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.14 KB | None | 0 0
raw download clone embed print report
  1.  
  2. // TRANSMITTER LOGIC FOR MAX2606 TRANSMITTER
  3. // UPLOAD USING ATtiny85, 8MHz Internal NO BOD Core!!!!
  4. // -------------------CREDITS-----------------------------------
  5. // Morse Code Converter By http://forum.singul4rity.com/thread-317.html
  6. // -------------------------------------------------------------
  7.  
  8. #include<pitches.h>
  9.  
  10. int TXLed = 0; //Define Led TX Indicator Pin
  11. int tonePin = 1; //Define Audio Pin
  12. int PTT = 4; //Define PTT Pin
  13. int toneFreq = 800; //Define Morse Tone Frequency in Hz
  14.  
  15. //1200000 = 15 MIN DELAY
  16. unsigned long pauseTime = 900000; //Define Program Repeat Time Delay - 60000 = 1 Minute - multiply by 60 to get 1 Hour
  17.  
  18. //Enter Morse String to be Sent MUST PUT DASHES BETWEEN LETTERS TO GET CHARACTER BREAK AND SPACES BETWEEN WORDS!!
  19. String morseInput = "F-O-X-H-U-N-T T-E-S-T";
  20.  
  21. void setup(){
  22. pinMode(tonePin,OUTPUT); //AUDIO
  23. pinMode(TXLed,OUTPUT); //INDICATOR LED
  24. pinMode(PTT,OUTPUT); //PTT
  25. }
  26.  
  27. void loop(){
  28. //BUILD LOGIC
  29. delay(1000); //Wait before doing anything
  30. digitalWrite(TXLed,HIGH); //Enable TX Led
  31. digitalWrite(PTT,HIGH); //Enable PTT
  32. delay(1000); //Wait for Radio to TX
  33. SendMorse(); //Send Morse String
  34. int i;
  35. for(i=0;i<1;i++)
  36. {
  37. delay(1000); //Wait a sec before playing melody(s)
  38. MelodyOne(); //Play Melody #1
  39. delay(1000); //Wait between melodies
  40. MelodyTwo(); //Play Melody #2
  41. //delay(1000); //Wait between melodies
  42. //MelodyThree(); //Play Melody #3
  43. }
  44. delay(1000); //Wait
  45. SendMorse(); //Send Final Morse String
  46. delay(500); //Wait
  47. digitalWrite(PTT,LOW); //Disable PTT
  48. digitalWrite(TXLed,LOW); //Disable TX Led
  49. delay(pauseTime); //Wait to start over - putting the final delay here allows the program to run at least once at power up. Shows logic is working.
  50. }
  51.  
  52. //Encode Morse String Function
  53. void SendMorse(){
  54. for(int i = 0;i<morseInput.length();i++){
  55. switch (morseInput[i]){
  56. case '0': lang(5); break;
  57. case '1': kurz(1);lang(4); break;
  58. case '2': kurz(2);lang(3); break;
  59. case '3': kurz(3);lang(2); break;
  60. case '4': kurz(4);lang(1); break;
  61. case '5': kurz(5); break;
  62. case '6': lang(1);kurz(4); break;
  63. case '7': lang(2);kurz(3); break;
  64. case '8': lang(3);kurz(2); break;
  65. case '9': lang(4);kurz(1); break;
  66. case 'a': case 'A': kurz(1);lang(1); break;
  67. case 'b': case 'B': lang(1);kurz(3); break;
  68. case 'c': case 'C': lang(1);kurz(1);lang(1);kurz(1); break;
  69. case 'd': case 'D': lang(1);kurz(2); break;
  70. case 'e': case 'E': kurz(1); break;
  71. case 'f': case 'F': kurz(2);lang(1);kurz(1); break;
  72. case 'g': case 'G': lang(2);kurz(1); break;
  73. case 'h': case 'H': kurz(4); break;
  74. case 'i': case 'I': kurz(2); break;
  75. case 'j': case 'J': kurz(1);lang(3); break;
  76. case 'k': case 'K': lang(1);kurz(1);lang(1); break;
  77. case 'l': case 'L': kurz(1);lang(1);kurz(2); break;
  78. case 'm': case 'M': lang(2); break;
  79. case 'n': case 'N': lang(1);kurz(1); break;
  80. case 'o': case 'O': lang(3); break;
  81. case 'p': case 'P': kurz(1);lang(2);kurz(1); break;
  82. case 'q': case 'Q': lang(2);kurz(1);lang(1); break;
  83. case 'r': case 'R': lang(1);kurz(1);lang(1); break;
  84. case 's': case 'S': kurz(3); break;
  85. case 't': case 'T': lang(1); break;
  86. case 'u': case 'U': kurz(2);lang(1); break;
  87. case 'v': case 'V': kurz(3);lang(1); break;
  88. case 'w': case 'W': kurz(1);lang(2); break;
  89. case 'x': case 'X': lang(1);kurz(2);lang(1); break;
  90. case 'y': case 'Y': lang(1);kurz(1);lang(2); break;
  91. case 'z': case 'Z': lang(2);kurz(2); break;
  92. case ' ': wordBreak(); break;
  93. case '.': kurz(1);lang(1);kurz(1);lang(1);kurz(1);lang(1); break;
  94. case '-': CharBreak(); break;
  95. default: continue;
  96. }
  97. }
  98. }//End SendMorse Function
  99.  
  100. //DAH Function
  101. void lang(int loops){
  102. for(int i = 0;i < loops; i++){
  103. tone(tonePin,toneFreq);
  104. delay(385);
  105. noTone(tonePin);
  106. delay(90);
  107. }
  108. }
  109.  
  110. //DIT Function
  111. void kurz(int loops){
  112. for(int i = 0; i<loops; i++){
  113. tone(tonePin,toneFreq);
  114. delay(125);
  115. noTone(tonePin);
  116. delay(100);
  117. }
  118. }
  119.  
  120. //WordBreak Function
  121. void wordBreak(){
  122. noTone(tonePin);
  123. delay(850);
  124. }
  125.  
  126. //CharBreak Function
  127. void CharBreak(){
  128. noTone(tonePin);
  129. delay(165);
  130. }
  131.  
  132. //Melody One Function - Twinkle
  133. void MelodyOne(){
  134. //Number of notes in the melody:
  135. int numberOfNotes = 14;
  136. int melody[] = {NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4};
  137. // note durations: 4 = quarter note, 8 = eighth note, etc.:
  138. int noteDurations[] = {
  139. 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
  140.  
  141. // iterate over the notes of the melody:
  142. for (int thisNote = 0; thisNote < numberOfNotes; thisNote++) {
  143. // to calculate the note duration, take one second
  144. // divided by the note type.
  145. //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
  146. int noteDuration = 1000/noteDurations[thisNote];
  147. tone(tonePin, melody[thisNote],noteDuration);
  148.  
  149. // to distinguish the notes, set a minimum time between them.
  150. // the note's duration + 30% seems to work well:
  151. int pauseBetweenNotes = noteDuration * 1.30;
  152. delay(pauseBetweenNotes);
  153. // stop the tone playing:
  154. noTone(tonePin);
  155. }
  156. }
  157.  
  158. //Melody Two Function - Zelda
  159. void MelodyTwo(){
  160. //Number of notes in the melody:
  161. int numberOfNotes = 32;
  162. int melody[] = { //Define the melody as being the notes following using those defined in pitches.h
  163. NOTE_E4, NOTE_G4, NOTE_D4, NOTE_C4, NOTE_D4,
  164. NOTE_E4, NOTE_G4, NOTE_D4, 0, NOTE_E4,
  165. NOTE_G4, NOTE_D5, NOTE_C5, NOTE_G4, NOTE_F4,
  166. NOTE_E4, NOTE_D4, 0, NOTE_E4, NOTE_G4,
  167. NOTE_D4, NOTE_C4, NOTE_D4, NOTE_E4, NOTE_G4,
  168. NOTE_D4, 0, NOTE_E4, NOTE_G4, NOTE_D5,
  169. NOTE_C5, NOTE_G4};
  170.  
  171. int noteDurations[] = { //Define the note durations, 1 to 1 with melody 1 = 8 beats
  172. 2,4,2,8,8, // 2 = 4 beats (whole note)
  173. 2,4,2,4,2, // 4 = 2 beats (half note)
  174. 4,2,4,2,8, // 8 = 1 beats (quarter note)
  175. 8,2,4,2,4,
  176. 2,8,8,2,4,
  177. 2,4,2,4,2,
  178. 4,1 };
  179.  
  180. // iterate over the notes of the melody:
  181. for (int thisNote = 0; thisNote < numberOfNotes; thisNote++) {
  182. // to calculate the note duration, take one second
  183. // divided by the note type.
  184. //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
  185. int noteDuration = 1000/noteDurations[thisNote];
  186. tone(tonePin, melody[thisNote],noteDuration);
  187.  
  188. // to distinguish the notes, set a minimum time between them.
  189. // the note's duration + 30% seems to work well:
  190. int pauseBetweenNotes = noteDuration * 1.30;
  191. delay(pauseBetweenNotes);
  192. // stop the tone playing:
  193. noTone(tonePin);
  194. }
  195. }
  196.  
  197.  
  198.  
  199. //Melody Three Function - Lullaby
  200. void MelodyThree(){
  201. //Number of notes in the melody:
  202. int numberOfNotes = 27;
  203. int melody[] = {
  204. NOTE_G6, NOTE_G6, NOTE_AS6, NOTE_G6, NOTE_G6,
  205. NOTE_AS6, NOTE_G6, NOTE_AS6, NOTE_DS7, NOTE_D7,
  206. NOTE_C7, NOTE_C7, NOTE_AS6, NOTE_F6, NOTE_G6,
  207. NOTE_GS6, NOTE_F6, NOTE_F6, NOTE_G6, NOTE_GS6,
  208. NOTE_F6, NOTE_GS6, NOTE_D7, NOTE_C7, NOTE_AS6,
  209. NOTE_D7, NOTE_DS7};
  210. int noteDurations[] = {
  211. 6,8,2.5,8,
  212. 4,2,6,10,
  213. 4,3,8,4,
  214. 4,6,8,4,
  215. 4,6,8,2.5,
  216. 6,8,8,8,
  217. 4,4,2};
  218.  
  219. // iterate over the notes of the melody:
  220. for (int thisNote = 0; thisNote < numberOfNotes; thisNote++) {
  221. // to calculate the note duration, take one second
  222. // divided by the note type.
  223. //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
  224. int noteDuration = 1000/noteDurations[thisNote];
  225. tone(tonePin, melody[thisNote],noteDuration);
  226.  
  227. // to distinguish the notes, set a minimum time between them.
  228. // the note's duration + 30% seems to work well:
  229. int pauseBetweenNotes = noteDuration * 1.30;
  230. delay(pauseBetweenNotes);
  231. // stop the tone playing:
  232. noTone(tonePin);
  233. }
  234. }
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!