RC Sound Modul (Arduino + SD-Karte) Eigenbau

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Danke ! jetzt funktioniert es

      interessante Alternative , vor Allem wenn man bedenkt, dass das Ganze keine 5 euro an Material kostet
      fahrbereit :
      SAR Hecht
      Hafendienstboot Silke
      Potofino auf Hydrospeed
      Portofino auf Kehrer Jet
      Robbe Lostenboot Maris 2
      Zerstörer Arleigh Burke
      Eco Bingo 2 Race
      Kehrer Jet Sprint

      in der Werft:
      Fregatte 123 Brandenburg
      Sievers Lumme
      Sievers Narwal
      Küstenwache Thor
    • Hey Frank, danke für deinen EMail-Hilfe, jetzt hats geklappt mit der RAR-Datei.

      Hätte zu deiner "Version 2" noch eine Idee:

      Weißt was ne geile Sache wäre, wenn man neben START und STOPP auch eine "STANDGERÄUSCH"
      WAV-Datei neben dem LOOP einbauen könnte... hätte da beim Standgeräusch eines geschnitten
      mit mehreren Fasetten, sprich wo kurz das Gas angetippt wird etc. ... wenn das dann quasi in Kreis
      läuft solange bis man Gas gibt, dann sollte der drehzahlabhängige LOOP starten... hoffe ich kriegs
      verständlich rüber...

      Gibts nen Shop außer amazon wo man die Teile bestellen kann?

      LG Roland
    • Hallo
      teste mal das:
      Standloop.wav ist dann das Standgeräusch

      C-Quellcode

      1. #include <SD.h> // need to include the SD library
      2. #define SD_ChipSelectPin 10 // using digital pin 10 on arduino nano 328, can use other pins
      3. #include "TMRpcmSpeed.h" // also need to include this library...
      4. #include <SPI.h>
      5. TMRpcm tmrpcm; // create an object for use in this sketch
      6. //#define DEBUG // Serial output on
      7. //#define Serial_in // Serial input on (change throttle with keyboard)
      8. unsigned long time = 0;
      9. int numLoop = 0;
      10. int prevThrottle = 0;
      11. int currThrottle = 0;
      12. int playingSound = 0;
      13. bool bPlayStart = true;
      14. bool bPlayNormal = false;
      15. bool bPlaySound1 = false;
      16. bool bPlaySound2 = false;
      17. bool bPlaySound3 = false;
      18. bool bPlaySound4 = false;
      19. bool bPlayEngine = false;
      20. int shutdowndelay = 15; // Number of seconds to wait before shutdown sound is played.
      21. boolean shutdowndelay_file = false; // is there a delay_.txt file
      22. unsigned int sampleSpeed = 8000; // Loop samplerate
      23. unsigned int sampleSpeed_max = 32000; // Loop samplerate max
      24. boolean sampleSpeed_max_file = false; // is there a Speed_.txt file
      25. //Pinout
      26. int rc_pin = 2; // Throttle RC PPM channel
      27. int rc_engine = 3; // Engine on = pin to ground
      28. int rc_sound1 = 4; // Sound l on = pin to ground
      29. int rc_sound2 = 5; // Sound 2 on = pin to ground
      30. int rc_sound3 = 6; // Sound 3 on = pin to ground
      31. int rc_sound4 = 7; // Sound 4 on = pin to ground
      32. unsigned long duration = 1500;
      33. unsigned long timer1;
      34. // Setup
      35. void setup() {
      36. pinMode(rc_engine, INPUT_PULLUP);
      37. pinMode(rc_sound1, INPUT_PULLUP);
      38. pinMode(rc_sound2, INPUT_PULLUP);
      39. pinMode(rc_sound3, INPUT_PULLUP);
      40. pinMode(rc_sound4, INPUT_PULLUP);
      41. tmrpcm.speakerPin = 9; // Sound out PIN
      42. Serial.begin(115200);
      43. if (!SD.begin(SD_ChipSelectPin)) { // see if the card is present and can be initialized
      44. #ifdef DEBUG // Serial output on
      45. Serial.println("SD fail");
      46. #endif
      47. return; // don't do anything more if not
      48. }
      49. else
      50. {
      51. #ifdef DEBUG // Serial output on
      52. Serial.println("SD ok");
      53. #endif
      54. }
      55. // check for config files
      56. if(SD.exists("/Delay.txt")) shutdowndelay_file = true;
      57. if(SD.exists("/Speed.txt")) sampleSpeed_max_file = true;
      58. if(shutdowndelay_file) shutdowndelay = readIntFromFile("Delay.txt");
      59. else shutdowndelay = 0; // Default off
      60. if(sampleSpeed_max_file) sampleSpeed_max = readIntFromFile("Speed.txt");
      61. else sampleSpeed_max = 32000; // Default max
      62. #ifdef DEBUG // Serial output on
      63. Serial.print("Shutdowndelay : ");
      64. Serial.println(shutdowndelay);
      65. Serial.print("SampleSpeed : ");
      66. Serial.println(sampleSpeed_max);
      67. Serial.println("setup end");
      68. #endif
      69. tmrpcm.volume(1);
      70. }
      71. void loop() {
      72. if (numLoop == 10000) {
      73. if (not digitalRead(rc_sound1))
      74. {
      75. if (!bPlaySound1)
      76. {
      77. bPlaySound1 = true;
      78. tmrpcm.play("sound1.wav");
      79. tmrpcm.speed(tmrpcm.orgsamplerate);
      80. #ifdef DEBUG // Serial output on
      81. Serial.println("sound1.wav");
      82. #endif
      83. tmrpcm.loop(0);
      84. while (tmrpcm.isPlaying()) {}
      85. tmrpcm.disable(); // disables the timer on output pin and stops the music
      86. }
      87. }
      88. else
      89. {
      90. bPlaySound1 = false;
      91. }
      92. if (not digitalRead(rc_sound2))
      93. {
      94. if (!bPlaySound2)
      95. {
      96. bPlaySound2 = true;
      97. tmrpcm.play("sound2.wav");
      98. tmrpcm.speed(tmrpcm.orgsamplerate);
      99. #ifdef DEBUG // Serial output on
      100. Serial.println("sound2.wav");
      101. #endif
      102. tmrpcm.loop(0);
      103. while (tmrpcm.isPlaying()) {}
      104. tmrpcm.disable(); // disables the timer on output pin and stops the music
      105. }
      106. }
      107. else
      108. {
      109. bPlaySound2 = false;
      110. }
      111. if (not digitalRead(rc_sound3))
      112. {
      113. if (!bPlaySound3)
      114. {
      115. bPlaySound3 = true;
      116. tmrpcm.play("sound3.wav");
      117. tmrpcm.speed(tmrpcm.orgsamplerate);
      118. #ifdef DEBUG // Serial output on
      119. Serial.println("sound3.wav");
      120. #endif
      121. tmrpcm.loop(0);
      122. while (tmrpcm.isPlaying()) {}
      123. tmrpcm.disable(); // disables the timer on output pin and stops the music
      124. }
      125. }
      126. else
      127. {
      128. bPlaySound3 = false;
      129. }
      130. if (not digitalRead(rc_sound4))
      131. {
      132. if (!bPlaySound4)
      133. {
      134. bPlaySound4 = true;
      135. tmrpcm.play("sound4.wav");
      136. tmrpcm.speed(tmrpcm.orgsamplerate);
      137. #ifdef DEBUG // Serial output on
      138. Serial.println("sound4.wav");
      139. #endif
      140. tmrpcm.loop(0);
      141. while (tmrpcm.isPlaying()) {}
      142. tmrpcm.disable(); // disables the timer on output pin and stops the music
      143. }
      144. }
      145. else
      146. {
      147. bPlaySound4 = false;
      148. }
      149. if (not digitalRead(rc_engine))
      150. {
      151. if (!bPlayEngine)
      152. {
      153. bPlayEngine = true;
      154. bPlayStart = false;
      155. }
      156. }
      157. else
      158. {
      159. bPlayEngine = false;
      160. currThrottle = 0;
      161. bPlayNormal = false;
      162. }
      163. }
      164. ++numLoop;
      165. if (numLoop == 30000) {
      166. #ifndef Serial_in // Serial input off (change throttle with keyboard)
      167. noInterrupts();
      168. duration = pulseIn(rc_pin, HIGH); //Read throttel value
      169. interrupts();
      170. #endif
      171. if (digitalRead(rc_engine))
      172. {
      173. duration = 1500;
      174. }
      175. #ifdef Serial_in // Serial input on (change throttle with keyboard)
      176. if(Serial.available()) { //Send commands over serial to play
      177. switch(Serial.read()){;
      178. case '0': duration = 950; break;
      179. case '1': duration = 1050; break;
      180. case '2': duration = 1150; break;
      181. case '3': duration = 1250; break;
      182. case '4': duration = 1450; break;
      183. case '5': duration = 1500; break;
      184. case '6': duration = 1550; break;
      185. case '7': duration = 1750; break;
      186. case '8': duration = 1850; break;
      187. case '9': duration = 1950; break;
      188. case ',': duration = 2050; break;
      189. }}
      190. #endif
      191. numLoop = 0;
      192. #ifdef DEBUG // Serial output on
      193. Serial.print("Pulse in : ");
      194. Serial.print(duration);
      195. Serial.print(" | SampleSpeed : ");
      196. Serial.print(sampleSpeed);
      197. Serial.print(" | currThrottle : ");
      198. Serial.print(currThrottle);
      199. Serial.print(" | Playing : ");
      200. #endif
      201. // Code to handle statup and //
      202. if ( ! bPlayStart ) {
      203. currThrottle = 1; // Play statup sound
      204. bPlayStart = true;
      205. }
      206. // Shutdowndelay 0 = off
      207. if ( (millis() - timer1) > (shutdowndelay * 1000) && currThrottle == 2 && (shutdowndelay > 0)) {
      208. currThrottle = 0;
      209. bPlayNormal = false;
      210. }
      211. /* Reverse throttle */
      212. if (duration <= 1480)
      213. {
      214. if (bPlayNormal)
      215. {
      216. currThrottle = 3;
      217. sampleSpeed = map(duration,1480,1000,tmrpcm.orgsamplerate,sampleSpeed_max);
      218. tmrpcm.speed(sampleSpeed);
      219. }
      220. else
      221. {
      222. bPlayStart = false;
      223. }
      224. };
      225. /* Throttle stick center - Play sound orignal samplerate */
      226. if ((duration > 1480) && (duration <= 1520) && bPlayNormal)
      227. {
      228. currThrottle = 2;
      229. };
      230. /* Forard throttle */
      231. if (duration > 1520)
      232. {
      233. if (bPlayNormal)
      234. {
      235. currThrottle = 3;
      236. sampleSpeed = map(duration,1520,2000,tmrpcm.orgsamplerate,sampleSpeed_max);
      237. tmrpcm.speed(sampleSpeed);
      238. }
      239. else
      240. {
      241. bPlayStart = false;
      242. }
      243. };
      244. if ((currThrottle != prevThrottle) or (tmrpcm.isPlaying() == 0)) {
      245. timer1 = millis();
      246. tmrpcm.loop(1);
      247. if ((currThrottle == 0) && (prevThrottle > 0)) {
      248. tmrpcm.play("shut.wav");
      249. tmrpcm.speed(tmrpcm.orgsamplerate);
      250. #ifdef DEBUG // Serial output on
      251. Serial.println("shut.wav");
      252. #endif
      253. tmrpcm.loop(0);
      254. while (tmrpcm.isPlaying()) {}
      255. tmrpcm.disable(); // disables the timer on output pin and stops the music
      256. prevThrottle = currThrottle;
      257. bPlayNormal = false;
      258. }
      259. if (currThrottle == 1) {
      260. if (currThrottle > prevThrottle) {
      261. tmrpcm.play("start.wav");
      262. tmrpcm.speed(tmrpcm.orgsamplerate);
      263. #ifdef DEBUG // Serial output on
      264. Serial.println("start.wav");
      265. #endif
      266. tmrpcm.loop(0);
      267. while (tmrpcm.isPlaying()) {}
      268. }
      269. bPlayNormal = true;
      270. playingSound = 1;
      271. prevThrottle = currThrottle;
      272. }
      273. if ((currThrottle == 2) && ((prevThrottle == 1) || (tmrpcm.isPlaying() == 0))) {
      274. tmrpcm.play("Standloop.wav");
      275. #ifdef DEBUG // Serial output on
      276. Serial.println("Standloop.wav");
      277. #endif
      278. prevThrottle = currThrottle;
      279. playingSound = 1;
      280. }
      281. if ((currThrottle == 3) && ((prevThrottle == 2) || (tmrpcm.isPlaying() == 0))) {
      282. tmrpcm.play("loop.wav");
      283. #ifdef DEBUG // Serial output on
      284. Serial.println("loop.wav");
      285. #endif
      286. prevThrottle = currThrottle;
      287. playingSound = 2;
      288. }
      289. if (currThrottle == 2) {
      290. prevThrottle = currThrottle;
      291. playingSound = 1;
      292. }
      293. if (currThrottle == 3) {
      294. prevThrottle = currThrottle;
      295. playingSound = 2;
      296. }
      297. }
      298. #ifdef DEBUG // Serial output on
      299. Serial.println(tmrpcm.isPlaying());
      300. #endif
      301. }
      302. }
      303. // read Int from textfile via SD-card
      304. int readIntFromFile(const char filename[])
      305. {
      306. uint8_t pos=0;
      307. uint8_t BUFSIZE=20;
      308. char buffer[BUFSIZE];
      309. File dataFile = SD.open (filename, FILE_READ);
      310. if(!dataFile) return 0;
      311. while ((buffer[pos] = dataFile.read()) >= 0 && pos < (BUFSIZE-1)) pos++;
      312. dataFile.close();
      313. return (atoi(buffer));
      314. }
      Alles anzeigen

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Ziege-One ()

    • Danke Frank mal vorerst...
      das selbe wäre ganz oben interessant, wenn man der höchsten Fahrstufe auch noch eine eigene WAV geben
      könnte, das ist vielleicht ein bisschen tricky da es ja in Abstimmung mit dem PWM Signal sein soll... wobei
      es durchaus Sinn macht, einfach das z.B. obere Gas Drittel als "Vollgaszone" anzusehen... um hier dann das
      Endgeräusch zu machen... manche Motoren klingen auf Vollgas einfach anders als der hochmodelierte Ton
      für meinen Geschmack... is kein Stress, muss mir eh erst die Komponenten für den Aufbau besorgen...
      könnte aber vielleicht für den ein oder anderen interessant sein...

      Viele Grüße
      Roland