From e19b0f373591b5d367d6e5846b1083e49e9588c5 Mon Sep 17 00:00:00 2001 From: Ralf Engels Date: Tue, 22 Aug 2023 19:57:23 +0200 Subject: [PATCH 1/6] Fix processor load issue Testing showed that the timer interrupts use each 25us and have a period (at idle) of 50us. That means a processor load at more than 100% at idle with pwm inputs. Turns out the DAC write is using a spin lock for port access which we don't need. See https://forum.arduino.cc/t/esp32-dacwrite-ersetzen/653954/5 Now we are down to 10us for the variable and fixed timer interrupts each. --- src/src.ino | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/src.ino b/src/src.ino index 124bfa5..79cdefc 100644 --- a/src/src.ino +++ b/src/src.ino @@ -875,9 +875,8 @@ void IRAM_ATTR variablePlaybackTimer() // DAC output (groups a, b, c mixed together) ************************************************************************ - dacWrite(DAC1, constrain(((a * 8 / 10) + (b / 2) + (c / 5) + (d / 5) + (e / 5) + f + g) * masterVolume / 100 + dacOffset, 0, 255)); // Mix signals, add 128 offset, write to DAC - // dacWrite(DAC1, constrain(a * masterVolume / 100 + dacOffset, 0, 255)); - // dacWrite(DAC1, constrain(a + 128, 0, 255)); + uint8_t value = constrain(((a * 8 / 10) + (b / 2) + (c / 5) + (d / 5) + (e / 5) + f + g) * masterVolume / 100 + dacOffset, 0, 255); + SET_PERI_REG_BITS(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_DAC, value, RTC_IO_PDAC1_DAC_S); // portEXIT_CRITICAL_ISR(&variableTimerMux); } @@ -1338,10 +1337,8 @@ void IRAM_ATTR fixedPlaybackTimer() // DAC output (groups mixed together) **************************************************************************** - // dacDebug = constrain(((a * 8 / 10) + (b * 2 / 10) + c + d) * masterVolume / 100 + dacOffset, 0, 255); // Mix signals, add 128 offset, write result to DAC - dacWrite(DAC2, constrain(((a * 8 / 10) + (b * 2 / 10) + c + d) * masterVolume / 100 + dacOffset, 0, 255)); // Mix signals, add 128 offset, write result to DAC - // dacWrite(DAC2, constrain( a2 * masterVolume / 100 + dacOffset, 0, 255)); // Mix signals, add 128 offset, write result to DAC - // dacWrite(DAC2, 0); + uint8_t value = constrain(((a * 8 / 10) + (b * 2 / 10) + c + d) * masterVolume / 100 + dacOffset, 0, 255); + SET_PERI_REG_BITS(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_DAC, value, RTC_IO_PDAC2_DAC_S); // portEXIT_CRITICAL_ISR(&fixedTimerMux); } @@ -1942,6 +1939,12 @@ void setup() &Task1, // Task handle to keep track of created task 0); // pin task to core 0 + // once write with the "normal" way. + // all further writes are done directly in the register since + // it's much faster + dacWrite(DAC1, 0); + dacWrite(DAC2, 0); + // Interrupt timer for variable sample rate playback variableTimer = timerBegin(0, 20, true); // timer 0, MWDT clock period = 12.5 ns * TIMGn_Tx_WDT_CLK_PRESCALE -> 12.5 ns * 20 -> 250 ns = 0.25 us, countUp timerAttachInterrupt(variableTimer, &variablePlaybackTimer, true); // edge (not level) triggered From 4a0b2fe38dcddc6f789033e92a53f6bb5973c8a8 Mon Sep 17 00:00:00 2001 From: Ralf Engels Date: Fri, 25 Aug 2023 14:16:17 +0200 Subject: [PATCH 2/6] Remove resetting the sample rate for the fixed timer Resetting the timer frequency takes around 3us. This is unnecessary for the fixed timer. We just need to tell the users to keep the same sample rate for every additional sound (which we kind of already do.) Else you would have issues anyways, when playing e.g. a horn and indicator light ticks at the same time. --- src/src.ino | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/src/src.ino b/src/src.ino index 79cdefc..70548da 100644 --- a/src/src.ino +++ b/src/src.ino @@ -923,9 +923,6 @@ void IRAM_ATTR fixedPlaybackTimer() if (hornTrigger || hornLatch) { - fixedTimerTicks = 4000000 / hornSampleRate; // our fixed sampling rate - timerAlarmWrite(fixedTimer, fixedTimerTicks, true); // // change timer ticks, autoreload true - if (curHornSample < hornSampleCount - 1) { a1 = (hornSamples[curHornSample] * hornVolumePercentage / 100); @@ -945,8 +942,6 @@ void IRAM_ATTR fixedPlaybackTimer() if (sirenTrigger || sirenLatch) { - fixedTimerTicks = 4000000 / sirenSampleRate; // our fixed sampling rate - timerAlarmWrite(fixedTimer, fixedTimerTicks, true); // // change timer ticks, autoreload true #if defined SIREN_STOP if (!sirenTrigger) @@ -983,9 +978,6 @@ void IRAM_ATTR fixedPlaybackTimer() // Sound 1 "b0" ---- if (sound1trigger) { - fixedTimerTicks = 4000000 / sound1SampleRate; // our fixed sampling rate - timerAlarmWrite(fixedTimer, fixedTimerTicks, true); // // change timer ticks, autoreload true - if (curSound1Sample < sound1SampleCount - 1) { b0 = (sound1Samples[curSound1Sample] * sound1VolumePercentage / 100); @@ -1005,9 +997,6 @@ void IRAM_ATTR fixedPlaybackTimer() // Reversing beep sound "b1" ---- if (engineRunning && escInReverse) { - fixedTimerTicks = 4000000 / reversingSampleRate; // our fixed sampling rate - timerAlarmWrite(fixedTimer, fixedTimerTicks, true); // // change timer ticks, autoreload true - if (curReversingSample < reversingSampleCount - 1) { b1 = (reversingSamples[curReversingSample] * reversingVolumePercentage / 100); @@ -1028,9 +1017,6 @@ void IRAM_ATTR fixedPlaybackTimer() #if not defined NO_INDICATOR_SOUND if (indicatorSoundOn) { - fixedTimerTicks = 4000000 / indicatorSampleRate; // our fixed sampling rate - timerAlarmWrite(fixedTimer, fixedTimerTicks, true); // // change timer ticks, autoreload true - if (curIndicatorSample < indicatorSampleCount - 1) { b2 = (indicatorSamples[curIndicatorSample] * indicatorVolumePercentage / 100); From f6c95132a96b14de64001af031b6647aff6caf0b Mon Sep 17 00:00:00 2001 From: Ralf Engels Date: Fri, 25 Aug 2023 15:58:15 +0200 Subject: [PATCH 3/6] Fix sound volume calculation Three issues are fixed: 1. in a lot of cases the last sample is not handled. if (sampleCount < sampleLength-1) will omit the last sample. 2. Multiplying the volumes at the end for samples that are not even outputted makes no sense. Actually, since all the sounds have a sound volume it is unnecessary. 3. Adding the samples directly to a buffer is faster than first adding it to variables. --- src/src.ino | 436 ++++++++++++++++++++++------------------------------ 1 file changed, 182 insertions(+), 254 deletions(-) diff --git a/src/src.ino b/src/src.ino index 70548da..4cd3d7e 100644 --- a/src/src.ino +++ b/src/src.ino @@ -627,12 +627,9 @@ void IRAM_ATTR variablePlaybackTimer() static uint32_t lastDieselKnockSample = 0; // Index of last Diesel knock sample static uint16_t attenuator = 0; // Used for volume adjustment during engine switch off static uint16_t speedPercentage = 0; // slows the engine down during shutdown - static int32_t a, a1, a2, a3, b, c, d, e = 0; // Input signals for mixer: a = engine, b = additional sound, c = turbo sound, d = fan sound, e = supercharger sound - static int32_t f = 0; // Input signals for mixer: f = hydraulic pump - static int32_t g = 0; // Input signals for mixer: g = train track rattle - uint8_t a1Multi = 0; // Volume multipliers // portENTER_CRITICAL_ISR(&variableTimerMux); // disables C callable interrupts (on the current core) and locks the mutex by the current core. + int32_t soundVal = 0; switch (engineState) { @@ -641,7 +638,6 @@ void IRAM_ATTR variablePlaybackTimer() variableTimerTicks = 4000000 / startSampleRate; // our fixed sampling rate timerAlarmWrite(variableTimer, variableTimerTicks, true); // // change timer ticks, autoreload true - a = 0; // volume = zero if (engineOn) { engineState = STARTING; @@ -656,9 +652,9 @@ void IRAM_ATTR variablePlaybackTimer() if (curStartSample < startSampleCount - 1) { #if defined STEAM_LOCOMOTIVE_MODE - a = (startSamples[curStartSample] * startVolumePercentage / 100); + soundVal += (startSamples[curStartSample] * startVolumePercentage / 100); #else - a = (startSamples[curStartSample] * throttleDependentVolume / 100 * startVolumePercentage / 100); + soundVal += (startSamples[curStartSample] * throttleDependentVolume / 100 * startVolumePercentage / 100); #endif curStartSample++; } @@ -673,6 +669,12 @@ void IRAM_ATTR variablePlaybackTimer() break; case RUNNING: // Engine running ------------------------------------------------------------------ + { + + // different sounds that are mixed together + int32_t idleVal = 0; + int32_t revVal = 0; + int32_t brakeVal = 0; // Engine idle & revving sounds (mixed together according to engine rpm, new in v5.0) variableTimerTicks = engineSampleRate; // our variable idle sampling rate! @@ -682,15 +684,14 @@ void IRAM_ATTR variablePlaybackTimer() { if (curEngineSample < sampleCount - 1) { - a1 = (samples[curEngineSample] * throttleDependentVolume / 100 * idleVolumePercentage / 100); // Idle sound - a3 = 0; + idleVal = (samples[curEngineSample] * throttleDependentVolume / 100 * idleVolumePercentage / 100); // Idle sound curEngineSample++; // Optional rev sound, recorded at medium rpm. Note, that it needs to represent the same number of ignition cycles as the // idle sound. For example 4 or 8 for a V8 engine. It also needs to have about the same length. In order to adjust the length // or "revSampleCount", change the "Rate" setting in Audacity until it is about the same. #ifdef REV_SOUND - a2 = (revSamples[curRevSample] * throttleDependentRevVolume / 100 * revVolumePercentage / 100); // Rev sound + revVal = (revSamples[curRevSample] * throttleDependentRevVolume / 100 * revVolumePercentage / 100); // Rev sound if (curRevSample < revSampleCount) curRevSample++; #endif @@ -720,9 +721,7 @@ void IRAM_ATTR variablePlaybackTimer() else { // Jake brake sound ---- #ifdef JAKE_BRAKE_SOUND - a3 = (jakeBrakeSamples[curJakeBrakeSample] * rpmDependentJakeBrakeVolume / 100 * jakeBrakeVolumePercentage / 100); // Jake brake sound - a2 = 0; - a1 = 0; + brakeVal = (jakeBrakeSamples[curJakeBrakeSample] * rpmDependentJakeBrakeVolume / 100 * jakeBrakeVolumePercentage / 100); // Jake brake sound if (curJakeBrakeSample < jakeBrakeSampleCount - 1) curJakeBrakeSample++; else @@ -743,82 +742,70 @@ void IRAM_ATTR variablePlaybackTimer() // Below the "revSwitchPoint" target, the idle volume precentage is 90%, then falling to 0% @ max. rpm. // The total of idle and rev volume percentage is always 100% + int32_t mixer; if (currentRpm > revSwitchPoint) - a1Multi = map(currentRpm, idleEndPoint, revSwitchPoint, 0, idleVolumeProportionPercentage); + mixer = map(currentRpm, idleEndPoint, revSwitchPoint, 0, idleVolumeProportionPercentage); else - a1Multi = idleVolumeProportionPercentage; // 90 - 100% proportion + mixer = idleVolumeProportionPercentage; // 90 - 100% proportion if (currentRpm > idleEndPoint) - a1Multi = 0; - - a1 = a1 * a1Multi / 100; // Idle volume - a2 = a2 * (100 - a1Multi) / 100; // Rev volume + mixer = 0; - a = a1 + a2 + a3; // Idle and rev sounds mixed together -#else - a = a1 + a3; // Idle sound only + idleVal = (idleVal * mixer) / 100; // Idle volume + revVal = (revVal * (100 - mixer)) / 100; // Rev volume #endif + soundVal += idleVal + revVal + brakeVal; + // Turbo sound ---------------------------------- - if (curTurboSample < turboSampleCount - 1) - { - c = (turboSamples[curTurboSample] * throttleDependentTurboVolume / 100 * turboVolumePercentage / 100); - curTurboSample++; - } - else + if (curTurboSample >= turboSampleCount) { curTurboSample = 0; } + soundVal += (turboSamples[curTurboSample] * throttleDependentTurboVolume / 100 * turboVolumePercentage / 100); + curTurboSample++; - // Fan sound ----------------------------------- - if (curFanSample < fanSampleCount - 1) + // Fan sound / gearbox whining -------------------- +#if defined GEARBOX_WHINING + // used for gearbox whining simulation, so not active in gearbox neutral + if (!neutralGear) { - d = (fanSamples[curFanSample] * throttleDependentFanVolume / 100 * fanVolumePercentage / 100); - curFanSample++; - } - else +#endif + if (curFanSample >= fanSampleCount) { curFanSample = 0; } + soundVal += (fanSamples[curFanSample] * throttleDependentFanVolume / 100 * fanVolumePercentage / 100); + curFanSample++; #if defined GEARBOX_WHINING - if (neutralGear) - d = 0; // used for gearbox whining simulation, so not active in gearbox neutral + } #endif // Supercharger sound -------------------------- - if (curChargerSample < chargerSampleCount - 1) - { - e = (chargerSamples[curChargerSample] * throttleDependentChargerVolume / 100 * chargerVolumePercentage / 100); - curChargerSample++; - } - else + if (curChargerSample >= chargerSampleCount) { curChargerSample = 0; } + soundVal += (chargerSamples[curChargerSample] * throttleDependentChargerVolume / 100 * chargerVolumePercentage / 100); + curChargerSample++; // Hydraulic pump sound ----------------------- #if defined EXCAVATOR_MODE - if (curHydraulicPumpSample < hydraulicPumpSampleCount - 1) - { - f = (hydraulicPumpSamples[curHydraulicPumpSample] * hydraulicPumpVolumePercentage / 100 * hydraulicPumpVolume / 100); - curHydraulicPumpSample++; - } - else + if (curHydraulicPumpSample >= hydraulicPumpSampleCount) { curHydraulicPumpSample = 0; } + soundVal += (hydraulicPumpSamples[curHydraulicPumpSample] * hydraulicPumpVolumePercentage / 100 * hydraulicPumpVolume / 100); + curHydraulicPumpSample++; #endif #if defined STEAM_LOCOMOTIVE_MODE // Track rattle sound ----------------------- if (curTrackRattleSample < trackRattleSampleCount - 1) - { - g = (trackRattleSamples[curTrackRattleSample] * trackRattleVolumePercentage / 100 * trackRattleVolume / 100); - curTrackRattleSample++; - } - else { curTrackRattleSample = 0; } + soundVal += (trackRattleSamples[curTrackRattleSample] * trackRattleVolumePercentage / 100 * trackRattleVolume / 100); + curTrackRattleSample++; #endif if (!engineOn) @@ -831,19 +818,17 @@ void IRAM_ATTR variablePlaybackTimer() } break; + } case STOPPING: // Engine stop -------------------------------------------------------------------- variableTimerTicks = 4000000 / sampleRate * speedPercentage / 100; // our fixed sampling rate timerAlarmWrite(variableTimer, variableTimerTicks, true); // // change timer ticks, autoreload true - if (curEngineSample < sampleCount - 1) - { - a = (samples[curEngineSample] * throttleDependentVolume / 100 * idleVolumePercentage / 100 / attenuator); - curEngineSample++; - } - else + if (curEngineSample >= sampleCount - 1) { curEngineSample = 0; } + soundVal += (samples[curEngineSample] * throttleDependentVolume / 100 * idleVolumePercentage / 100 / attenuator); + curEngineSample++; // fade engine sound out if (millis() - attenuatorMillis > 100) @@ -855,7 +840,6 @@ void IRAM_ATTR variablePlaybackTimer() if (attenuator >= 50 || speedPercentage >= 500) { // 50 & 500 - a = 0; speedPercentage = 100; parkingBrakeTrigger = true; engineState = PARKING_BRAKE; @@ -873,9 +857,9 @@ void IRAM_ATTR variablePlaybackTimer() } // end of switch case - // DAC output (groups a, b, c mixed together) ************************************************************************ - uint8_t value = constrain(((a * 8 / 10) + (b / 2) + (c / 5) + (d / 5) + (e / 5) + f + g) * masterVolume / 100 + dacOffset, 0, 255); + uint8_t value = constrain(soundVal * masterVolume / 100 + dacOffset, 0, 255); + SET_PERI_REG_BITS(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_DAC, value, RTC_IO_PDAC1_DAC_S); // portEXIT_CRITICAL_ISR(&variableTimerMux); @@ -909,206 +893,171 @@ void IRAM_ATTR fixedPlaybackTimer() static uint32_t curBucketRattleSample = 0; // Index of currently loaded bucket rattle sample static uint32_t curTireSquealSample = 0; // Index of currently loaded tire squeal sample static uint32_t curOutOfFuelSample = 0; // Index of currently loaded out of fuel sample - static int32_t a, a1, a2 = 0; // Input signals "a" for mixer - static int32_t b, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9 = 0; // Input signals "b" for mixer - static int32_t c, c1, c2, c3 = 0; // Input signals "c" for mixer - static int32_t d, d1, d2 = 0; // Input signals "d" for mixer static boolean knockSilent = 0; // This knock will be more silent static boolean knockMedium = 0; // This knock will be medium static uint8_t curKnockCylinder = 0; // Index of currently ignited zylinder // portENTER_CRITICAL_ISR(&fixedTimerMux); - // Group "a" (horn & siren) ****************************************************************** + int32_t soundVal = 0; + // horn ************************************************* + if (curHornSample >= hornSampleCount) + { // End of sample + curHornSample = 0; + hornLatch = false; + } if (hornTrigger || hornLatch) { - if (curHornSample < hornSampleCount - 1) - { - a1 = (hornSamples[curHornSample] * hornVolumePercentage / 100); - curHornSample++; + soundVal += (hornSamples[curHornSample] * hornVolumePercentage / 100); + curHornSample++; #ifdef HORN_LOOP // Optional "endless loop" (points to be defined manually in horn file) if (hornTrigger && curHornSample == hornLoopEnd) curHornSample = hornLoopBegin; // Loop, if trigger still present #endif - } - else - { // End of sample - curHornSample = 0; - a1 = 0; - hornLatch = false; - } } + // siren ************************************************* + if (curSirenSample >= sirenSampleCount) + { // End of sample + curSirenSample = 0; + sirenLatch = false; + } if (sirenTrigger || sirenLatch) { - #if defined SIREN_STOP if (!sirenTrigger) { - sirenLatch = false; curSirenSample = 0; - a2 = 0; + sirenLatch = false; } #endif - if (curSirenSample < sirenSampleCount - 1) - { - a2 = (sirenSamples[curSirenSample] * sirenVolumePercentage / 100); - curSirenSample++; + soundVal += (sirenSamples[curSirenSample] * sirenVolumePercentage / 100); + curSirenSample++; #ifdef SIREN_LOOP // Optional "endless loop" (points to be defined manually in siren file) - if (sirenTrigger && curSirenSample == sirenLoopEnd) - curSirenSample = sirenLoopBegin; // Loop, if trigger still present + if (sirenTrigger && curSirenSample == sirenLoopEnd) + curSirenSample = sirenLoopBegin; // Loop, if trigger still present #endif - } - else - { // End of sample - curSirenSample = 0; - a2 = 0; - sirenLatch = false; - } } if (curSirenSample > 10 && curSirenSample < 500) cannonFlash = true; // Tank cannon flash triggering in TRACKED_MODE else cannonFlash = false; - // Group "b" (other sounds) ********************************************************************** + // other sounds ********************************************* - // Sound 1 "b0" ---- + if (curSound1Sample < sound1SampleCount) + { + curSound1Sample = 0; // ensure, next sound will start @ first sample + } if (sound1trigger) { - if (curSound1Sample < sound1SampleCount - 1) - { - b0 = (sound1Samples[curSound1Sample] * sound1VolumePercentage / 100); - curSound1Sample++; - } - else + soundVal += (sound1Samples[curSound1Sample] * sound1VolumePercentage / 100); + curSound1Sample++; + if (curSound1Sample == sound1SampleCount) { sound1trigger = false; + curSound1Sample = 0; // ensure, next sound will start @ first sample } } - else - { - curSound1Sample = 0; // ensure, next sound will start @ first sample - b0 = 0; - } // Reversing beep sound "b1" ---- + if (curReversingSample >= reversingSampleCount) + { + curReversingSample = 0; + } if (engineRunning && escInReverse) { - if (curReversingSample < reversingSampleCount - 1) - { - b1 = (reversingSamples[curReversingSample] * reversingVolumePercentage / 100); - curReversingSample++; - } - else - { - curReversingSample = 0; - } + soundVal += (reversingSamples[curReversingSample] * reversingVolumePercentage / 100); + curReversingSample++; } else { curReversingSample = 0; // ensure, next sound will start @ first sample - b1 = 0; } - // Indicator tick sound "b2" ---------------------------------------------------------------------- + // Indicator tick sound ------------------------------------------ #if not defined NO_INDICATOR_SOUND + if (curIndicatorSample >= indicatorSampleCount) + { + curIndicatorSample = 0; + } if (indicatorSoundOn) { - if (curIndicatorSample < indicatorSampleCount - 1) - { - b2 = (indicatorSamples[curIndicatorSample] * indicatorVolumePercentage / 100); - curIndicatorSample++; - } - else + soundVal += (indicatorSamples[curIndicatorSample] * indicatorVolumePercentage / 100); + curIndicatorSample++; + if (curIndicatorSample == indicatorSampleCount) { indicatorSoundOn = false; + curIndicatorSample = 0; // ensure, next sound will start @ first sample } } - else - { - curIndicatorSample = 0; // ensure, next sound will start @ first sample - b2 = 0; - } #endif // Wastegate (blowoff) sound, triggered after rapid throttle drop ----------------------------------- + if (curWastegateSample >= wastegateSampleCount) + { + curWastegateSample = 0; + } if (wastegateTrigger) { - if (curWastegateSample < wastegateSampleCount - 1) - { - b3 = (wastegateSamples[curWastegateSample] * rpmDependentWastegateVolume / 100 * wastegateVolumePercentage / 100); - curWastegateSample++; - } - else + soundVal += (wastegateSamples[curWastegateSample] * rpmDependentWastegateVolume / 100 * wastegateVolumePercentage / 100); + curWastegateSample++; + if (curWastegateSample == wastegateSampleCount) { wastegateTrigger = false; + curWastegateSample = 0; // ensure, next sound will start @ first sample } } - else - { - b3 = 0; - curWastegateSample = 0; // ensure, next sound will start @ first sample - } // Air brake release sound, triggered after stop ----------------------------------------------- + if (curBrakeSample >= brakeSampleCount) + { + curBrakeSample = 0; + } if (airBrakeTrigger) { - if (curBrakeSample < brakeSampleCount - 1) - { - b4 = (brakeSamples[curBrakeSample] * brakeVolumePercentage / 100); - curBrakeSample++; - } - else + soundVal += (brakeSamples[curBrakeSample] * brakeVolumePercentage / 100); + curBrakeSample++; + if (curBrakeSample == brakeSampleCount) { airBrakeTrigger = false; + curBrakeSample = 0; // ensure, next sound will start @ first sample } } - else - { - b4 = 0; - curBrakeSample = 0; // ensure, next sound will start @ first sample - } // Air parking brake attaching sound, triggered after engine off -------------------------------- + if (curParkingBrakeSample >= parkingBrakeSampleCount) + { + curParkingBrakeSample = 0; + } if (parkingBrakeTrigger) { - if (curParkingBrakeSample < parkingBrakeSampleCount - 1) - { - b5 = (parkingBrakeSamples[curParkingBrakeSample] * parkingBrakeVolumePercentage / 100); - curParkingBrakeSample++; - } - else + soundVal += (parkingBrakeSamples[curParkingBrakeSample] * parkingBrakeVolumePercentage / 100); + curParkingBrakeSample++; + if (curParkingBrakeSample == parkingBrakeSampleCount) { parkingBrakeTrigger = false; + curParkingBrakeSample = 0; // ensure, next sound will start @ first sample } } - else - { - b5 = 0; - curParkingBrakeSample = 0; // ensure, next sound will start @ first sample - } // Pneumatic gear shifting sound, triggered while shifting the TAMIYA 3 speed transmission ------ + if (curShiftingSample >= shiftingSampleCount) + { + curShiftingSample = 0; + } if (shiftingTrigger && engineRunning && !automatic && !doubleClutch) { - if (curShiftingSample < shiftingSampleCount - 1) - { - b6 = (shiftingSamples[curShiftingSample] * shiftingVolumePercentage / 100); - curShiftingSample++; - } - else + soundVal = (shiftingSamples[curShiftingSample] * shiftingVolumePercentage / 100); + curShiftingSample++; + if (curShiftingSample == shiftingSampleCount) { shiftingTrigger = false; + curShiftingSample = 0; // ensure, next sound will start @ first sample } } - else - { - b6 = 0; - curShiftingSample = 0; // ensure, next sound will start @ first sample - } // Diesel ignition "knock" is played in fixed sample rate section, because we don't want changing pitch! ------ if (dieselKnockTriggerFirst) @@ -1175,155 +1124,134 @@ void IRAM_ATTR fixedPlaybackTimer() if (curDieselKnockSample < knockSampleCount) { + // multiplier for volume (we divide by 100 at the end) + int32_t dieselVolume = dieselKnockVolumePercentage; + dieselVolume *= throttleDependentKnockVolume; + #if defined RPM_DEPENDENT_KNOCK // knock volume also depending on engine rpm - b7 = (knockSamples[curDieselKnockSample] * dieselKnockVolumePercentage / 100 * throttleDependentKnockVolume / 100 * rpmDependentKnockVolume / 100); + dieselVolume *= rpmDependentKnockVolume; #elif defined EXCAVATOR_MODE // knock volume also depending on hydraulic load - b7 = (knockSamples[curDieselKnockSample] * dieselKnockVolumePercentage / 100 * throttleDependentKnockVolume / 100 * hydraulicDependentKnockVolume / 100); -#else // Just depending on throttle - b7 = (knockSamples[curDieselKnockSample] * dieselKnockVolumePercentage / 100 * throttleDependentKnockVolume / 100); + dieselVolume *= hydraulicDependentKnockVolume; +#else + dieselVolume *= 100; #endif - curDieselKnockSample++; + + // changing knock volume according to engine type and cylinder! if (knockSilent && !knockMedium) - b7 = b7 * dieselKnockAdaptiveVolumePercentage / 100; // changing knock volume according to engine type and cylinder! + dieselVolume *= dieselKnockAdaptiveVolumePercentage / 100; if (knockMedium) - b7 = b7 * dieselKnockAdaptiveVolumePercentage / 75; + dieselVolume *= dieselKnockAdaptiveVolumePercentage / 75; + + soundVal += knockSamples[curDieselKnockSample] * + dieselVolume / (100 * 100); + curDieselKnockSample++; } #if not defined EXCAVATOR_MODE // Trailer coupling sound, triggered by switch ----------------------------------------------- #ifdef COUPLING_SOUND + if (curCouplingSample >= couplingSampleCount) + { + curCouplingSample = 0; + } if (couplingTrigger) { - if (curCouplingSample < couplingSampleCount - 1) - { - b8 = (couplingSamples[curCouplingSample] * couplingVolumePercentage / 100); - curCouplingSample++; - } - else + soundVal += (couplingSamples[curCouplingSample] * couplingVolumePercentage / 100); + curCouplingSample++; + if (curCouplingSample == couplingSampleCount) { couplingTrigger = false; + curCouplingSample = 0; // ensure, next sound will start @ first sample } } - else - { - b8 = 0; - curCouplingSample = 0; // ensure, next sound will start @ first sample - } // Trailer uncoupling sound, triggered by switch ----------------------------------------------- + if (curUncouplingSample >= uncouplingSampleCount) + { + curUncouplingSample = 0; + } if (uncouplingTrigger) { - if (curUncouplingSample < uncouplingSampleCount - 1) - { - b9 = (uncouplingSamples[curUncouplingSample] * couplingVolumePercentage / 100); - curUncouplingSample++; - } - else + soundVal += (uncouplingSamples[curUncouplingSample] * couplingVolumePercentage / 100); + curUncouplingSample++; + if (curUncouplingSample == uncouplingSampleCount) { uncouplingTrigger = false; + curUncouplingSample = 0; } } - else - { - b9 = 0; - curUncouplingSample = 0; // ensure, next sound will start @ first sample - } #endif #endif - // Group "c" (excavator sounds) ********************************************************************** + // excavator sounds ************************************************** #if defined EXCAVATOR_MODE // Hydraulic fluid flow sound ----------------------- - if (curHydraulicFlowSample < hydraulicFlowSampleCount - 1) - { - c1 = (hydraulicFlowSamples[curHydraulicFlowSample] * hydraulicFlowVolumePercentage / 100 * hydraulicFlowVolume / 100); - curHydraulicFlowSample++; - } - else + if (curHydraulicFlowSample >= hydraulicFlowSampleCount) { curHydraulicFlowSample = 0; } + soundVal += (hydraulicFlowSamples[curHydraulicFlowSample] * hydraulicFlowVolumePercentage / 100 * hydraulicFlowVolume / 100); + curHydraulicFlowSample++; // Track rattle sound ----------------------- - if (curTrackRattleSample < trackRattleSampleCount - 1) - { - c2 = (trackRattleSamples[curTrackRattleSample] * trackRattleVolumePercentage / 100 * trackRattleVolume / 100); - curTrackRattleSample++; - } - else + if (curTrackRattleSample >= trackRattleSampleCount) { curTrackRattleSample = 0; } + soundVal += (trackRattleSamples[curTrackRattleSample] * trackRattleVolumePercentage / 100 * trackRattleVolume / 100); + curTrackRattleSample++; // Bucket rattle sound ----------------------- + if (curBucketRattleSample >= bucketRattleSampleCount) + { + curBucketRattleSample = 0; + } if (bucketRattleTrigger) { - if (curBucketRattleSample < bucketRattleSampleCount - 1) - { - c3 = (bucketRattleSamples[curBucketRattleSample] * bucketRattleVolumePercentage / 100); - curBucketRattleSample++; - } - else + soundVal += (bucketRattleSamples[curBucketRattleSample] * bucketRattleVolumePercentage / 100); + curBucketRattleSample++; + if (curBucketRattleSample == bucketRattleSampleCount) { bucketRattleTrigger = false; + curBucketRattleSample = 0; // ensure, next sound will start @ first sample } } - else - { - c3 = 0; - curBucketRattleSample = 0; // ensure, next sound will start @ first sample - } #endif - // Group "d" (additional sounds) ********************************************************************** + // additional sounds ************************************************* #if defined TIRE_SQUEAL // Tire squeal sound ----------------------- - if (curTireSquealSample < tireSquealSampleCount - 1) - { - d1 = (tireSquealSamples[curTireSquealSample] * tireSquealVolumePercentage / 100 * tireSquealVolume / 100); - curTireSquealSample++; - } - else + if (curTireSquealSample >= tireSquealSampleCount) { - d1 = 0; curTireSquealSample = 0; } + soundVal += (tireSquealSamples[curTireSquealSample] * tireSquealVolumePercentage / 100 * tireSquealVolume / 100); + curTireSquealSample++; #endif #if defined BATTERY_PROTECTION // Out of fuel sound, triggered by battery voltage ----------------------------------------------- + if (curOutOfFuelSample >= outOfFuelSampleCount) + { + curOutOfFuelSample = 0; + } if (outOfFuelMessageTrigger) { - if (curOutOfFuelSample < outOfFuelSampleCount - 1) - { - d2 = (outOfFuelSamples[curOutOfFuelSample] * outOfFuelVolumePercentage / 100); - curOutOfFuelSample++; - } - else + soundVal += (outOfFuelSamples[curOutOfFuelSample] * outOfFuelVolumePercentage / 100); + curOutOfFuelSample++; + if (curOutOfFuelSample == outOfFuelSampleCount) { outOfFuelMessageTrigger = false; + curOutOfFuelSample = 0; // ensure, next sound will start @ first sample } } - else - { - d2 = 0; - curOutOfFuelSample = 0; // ensure, next sound will start @ first sample - } #endif - // Mixing sounds together ********************************************************************** - a = a1 + a2; // Horn & siren - // if (a < 2 && a > -2) a = 0; // Remove noise floor TODO, experimental - b = b0 * 5 + b1 + b2 / 2 + b3 + b4 + b5 + b6 + b7 + b8 + b9; // Other sounds - c = c1 + c2 + c3; // Excavator sounds - d = d1 + d2; // Additional sounds - - // DAC output (groups mixed together) **************************************************************************** - uint8_t value = constrain(((a * 8 / 10) + (b * 2 / 10) + c + d) * masterVolume / 100 + dacOffset, 0, 255); + uint8_t value = constrain(soundVal * masterVolume / 100 + dacOffset, 0, 255); SET_PERI_REG_BITS(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_DAC, value, RTC_IO_PDAC2_DAC_S); // portEXIT_CRITICAL_ISR(&fixedTimerMux); From 7b8097f00817a3d1f19d97b4dcf895d8cc47a0a4 Mon Sep 17 00:00:00 2001 From: Ralf Engels Date: Sat, 26 Aug 2023 16:12:21 +0200 Subject: [PATCH 4/6] Update all vehicles with the new sound volumes. I actually used a script for this. Indicate if you want to have that to automatically convert. --- src/vehicles/00_Master.h | 32 ++++++++++---------- src/vehicles/1000HpScaniaV8.h | 34 +++++++++++----------- src/vehicles/1965FordMustangV8.h | 30 +++++++++---------- src/vehicles/Adler.h | 30 +++++++++---------- src/vehicles/Benford3TonDumper.h | 30 +++++++++---------- src/vehicles/CAT3408OpenPipes.h | 32 ++++++++++---------- src/vehicles/CaboverCAT3408.h | 32 ++++++++++---------- src/vehicles/Caterpillar323Excavator.h | 32 ++++++++++---------- src/vehicles/Chevy468.h | 30 +++++++++---------- src/vehicles/ChevyNovaCoupeV8.h | 30 +++++++++---------- src/vehicles/ChevyNovaCoupeV8_P407.h | 30 +++++++++---------- src/vehicles/Defender62LS3.h | 30 +++++++++---------- src/vehicles/DefenderTd5.h | 30 +++++++++---------- src/vehicles/DefenderV8Automatic.h | 30 +++++++++---------- src/vehicles/DefenderV8CrawlerAutomatic.h | 30 +++++++++---------- src/vehicles/DefenderV8OpenPipe.h | 30 +++++++++---------- src/vehicles/DefenderV8OpenPipeAutomatic.h | 30 +++++++++---------- src/vehicles/FordPowerstroke.h | 30 +++++++++---------- src/vehicles/FreightlinerCummins350 2.h | 32 ++++++++++---------- src/vehicles/FreightlinerCummins350.h | 32 ++++++++++---------- src/vehicles/GAZ66.h | 32 ++++++++++---------- src/vehicles/GMCsierra.h | 30 +++++++++---------- src/vehicles/HarleyDavidsonFXSB.h | 30 +++++++++---------- src/vehicles/HiluxDiesel.h | 30 +++++++++---------- src/vehicles/IS3.h | 30 +++++++++---------- src/vehicles/JaguarXJS.h | 30 +++++++++---------- src/vehicles/JaguarXJSautomatic.h | 30 +++++++++---------- src/vehicles/JeepGrandCherokeeTrackhawk.h | 30 +++++++++---------- src/vehicles/JeepWranglerRubicon392V8.h | 32 ++++++++++---------- src/vehicles/JeepWranglerRubicon392V8_2.h | 30 +++++++++---------- src/vehicles/KenworthCummins335.h | 34 +++++++++++----------- src/vehicles/KenworthW900ACAT3408.h | 32 ++++++++++---------- src/vehicles/KenworthW900ACAT3408new.h | 32 ++++++++++---------- src/vehicles/KenworthW900ADetroit8V71.h | 32 ++++++++++---------- src/vehicles/KirovetsK700.h | 30 +++++++++---------- src/vehicles/LaFerrari.h | 30 +++++++++---------- src/vehicles/LandcruiserFJ40.h | 30 +++++++++---------- src/vehicles/LandcruiserFJ40Diesel.h | 30 +++++++++---------- src/vehicles/LandcruiserFJ40Diesel2.h | 30 +++++++++---------- src/vehicles/M35.h | 32 ++++++++++---------- src/vehicles/MGBGtV8.h | 32 ++++++++++---------- src/vehicles/MackSuperLiner.h | 32 ++++++++++---------- src/vehicles/MagirusDeutz256.h | 32 ++++++++++---------- src/vehicles/MagirusMercur125.h | 32 ++++++++++---------- src/vehicles/ManKat.h | 32 ++++++++++---------- src/vehicles/ManTgx.h | 32 ++++++++++---------- src/vehicles/MercedesActros1836.h | 32 ++++++++++---------- src/vehicles/MercedesActrosV6.h | 32 ++++++++++---------- src/vehicles/MesserschmittBf109.h | 30 +++++++++---------- src/vehicles/PeterbiltDetroit8v92.h | 32 ++++++++++---------- src/vehicles/RAM2500_Cummins12V.h | 30 +++++++++---------- src/vehicles/RAM2500_Cummins12Vautomatic.h | 30 +++++++++---------- src/vehicles/Saurer2DM.h | 32 ++++++++++---------- src/vehicles/Scania143.h | 32 ++++++++++---------- src/vehicles/ScaniaV8.h | 32 ++++++++++---------- src/vehicles/ScaniaV8Firetruck.h | 32 ++++++++++---------- src/vehicles/ScaniaV8_50ton.h | 32 ++++++++++---------- src/vehicles/Tatra813.h | 32 ++++++++++---------- src/vehicles/Tatra813new.h | 32 ++++++++++---------- src/vehicles/URAL375.h | 32 ++++++++++---------- src/vehicles/US_Firetruck.h | 32 ++++++++++---------- src/vehicles/UnimogU1000.h | 32 ++++++++++---------- src/vehicles/UnionPacific2002.h | 30 +++++++++---------- src/vehicles/Ural375D.h | 32 ++++++++++---------- src/vehicles/Ural4320.h | 32 ++++++++++---------- src/vehicles/VolvoFH16_750.h | 32 ++++++++++---------- src/vehicles/VolvoFH16_OpenPipe.h | 32 ++++++++++---------- src/vehicles/VwBeetle.h | 30 +++++++++---------- src/vehicles/generic6zylDiesel.h | 30 +++++++++---------- 69 files changed, 1074 insertions(+), 1074 deletions(-) diff --git a/src/vehicles/00_Master.h b/src/vehicles/00_Master.h index f8db1c2..c8d4dc5 100644 --- a/src/vehicles/00_Master.h +++ b/src/vehicles/00_Master.h @@ -5,7 +5,7 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) //#include "sounds/UnionPacific2002start.h" // Union Pacific 2002 SD70M Locomotive Start //#include "sounds/HgP408Start.h" // HG P408 Humvee Diesel (only for small speakers) //#include "sounds/KenworthW900Start.h" // Kenworth W900 Truck Start @@ -23,7 +23,7 @@ volatile int startVolumePercentage = 150; // Adjust the start volume (usually = //#include "sounds/KenworthCummins335Start.h" // Cummins 335 R6 Diesel start sound (1952 Kenworth) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/20Hz.h" // 20Hz test tone @@ -61,7 +61,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -94,7 +94,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 10; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -135,27 +135,27 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 25; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 5; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! //#include "sounds/UnionPacific2002turbo.h" // Union Pacific 2002 SD70M Locomotive with 16 cylinder Diesel // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 90; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 18; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/POWERSTROKEwastegate.h" // Ford Powerstroke 7.3l V8 Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -166,7 +166,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T //#include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn (no loop) //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short (incl. loop) //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (incl. loop) @@ -184,7 +184,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/StadtLuzernHorn.h" // Steam Ship Stadt Luzern Horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -209,7 +209,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -220,13 +220,13 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/Saurer2DMbrake.h" // // Saurer 2DM air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound //#include "sounds/Saurer2DMparkingBrake.h" // // Saurer 2DM air parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -242,18 +242,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually //#include "sounds/chirp.h" // central locking sound // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/1000HpScaniaV8.h b/src/vehicles/1000HpScaniaV8.h index 52bcbd4..96da000 100644 --- a/src/vehicles/1000HpScaniaV8.h +++ b/src/vehicles/1000HpScaniaV8.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) //#include "sounds/ScaniaV850tonStart.h" // SCANIA V8 #include "sounds/ScaniaV8start.h" // SCANIA V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full throttle (for rev sound as well) 200 //#include "sounds/1000HpScaniaV8idle2.h" // SCANIA V8 @@ -18,7 +18,7 @@ volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -39,7 +39,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a /* // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 300; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 60; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -50,7 +50,7 @@ volatile int dieselKnockAdaptiveVolumePercentage = 10; // Adjust the Diesel knoc // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 400; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 80; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 10; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -70,24 +70,24 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) #include "sounds/ScaniaV8knockExtreme.h" // SCANIA V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 60; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 12; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 250; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 50; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/1000HpScaniaV8wastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -97,7 +97,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 120; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 96; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -111,7 +111,7 @@ volatile int hornVolumePercentage = 120; // Adjust the horn volume (usually = 10 #include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -121,7 +121,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -130,12 +130,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -149,18 +149,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/1965FordMustangV8.h b/src/vehicles/1965FordMustangV8.h index c717217..298167a 100644 --- a/src/vehicles/1965FordMustangV8.h +++ b/src/vehicles/1965FordMustangV8.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) //#include "sounds/1965FordMustangV8start.h" // 1965 Ford Mustang V8 #include "sounds/1965FordMustangV8startShort.h" // 1965 Ford Mustang V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 80; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/1965FordMustangV8idle.h" // 1965 Ford Mustang V8 @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 80; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -38,7 +38,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 50; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -55,24 +55,24 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/1965FordMustangV8knockLowpass.h" // 1965 Ford Mustang V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -81,7 +81,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for //#include "sounds/Tatra813FanNewSlow.h" // Tatra 813 8x8 V12 Diesel Cooling Fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -93,7 +93,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 48; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -104,7 +104,7 @@ volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 1 #include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -112,12 +112,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -128,11 +128,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/Adler.h b/src/vehicles/Adler.h index 47fa6d7..40b5ae1 100644 --- a/src/vehicles/Adler.h +++ b/src/vehicles/Adler.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 100; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 80; // Adjust the start volume (usually = 80%) #include "sounds/AdlerStart.h" // Adler Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 0; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/AdlerIdle.h" // Adler // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 0; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 110; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 22; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 5; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 250; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -45,24 +45,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/DefenderTd5knock.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -71,16 +71,16 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for //#include "sounds/Tatra813FanNewSlow.h" // Tatra 813 8x8 V12 Diesel Cooling Fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/AdlerWhistle2.h" // Adler steam whistle // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 100; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 20; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound #include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -88,12 +88,12 @@ volatile int brakeVolumePercentage = 100; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -104,11 +104,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/Benford3TonDumper.h b/src/vehicles/Benford3TonDumper.h index 81edd45..04a0e13 100644 --- a/src/vehicles/Benford3TonDumper.h +++ b/src/vehicles/Benford3TonDumper.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 210; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 168; // Adjust the start volume (usually = 80%) #include "sounds/BENFORD3TONStart.h" // Benford 3 Ton Dumper // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 70; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/BENFORD3TONIdle.h" // Benford 3 Ton Dumper // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 70; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 180; // The rev sound is played instead of the idle sound above this point 200 volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 400; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 80; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 20; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 10; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -54,24 +54,24 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) #include "sounds/BENFORD3TONKnock2.h" // Benford 3 Ton Dumper // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 6; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/POWERSTROKEwastegate.h" // Ford Powerstroke 7.3l V8 Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -81,7 +81,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 128; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -96,7 +96,7 @@ volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -106,7 +106,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -116,12 +116,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -135,11 +135,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 50; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 10; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/CAT3408OpenPipes.h b/src/vehicles/CAT3408OpenPipes.h index fd5a168..cb1f1ba 100644 --- a/src/vehicles/CAT3408OpenPipes.h +++ b/src/vehicles/CAT3408OpenPipes.h @@ -4,19 +4,19 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) //#include "sounds/Cat3408Start.h" // CAT 3408 V8 Diesel start (Kenworth W900A) #include "sounds/Cat3408Start2.h" // CAT 3408 V8 Diesel start (Kenworth W900A, b+7, h-7) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/3408CatCoalIdle.h" // CAT 3408 V8 Diesel Open Pipes // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 20; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -51,18 +51,18 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) #include "sounds/3408CatCoalKnock2.h" // CAT 3408 V8 Diesel Open Pipes // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 80; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 16; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 200; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 40; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" @@ -70,7 +70,7 @@ volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, af #include "sounds/3408CatCoalWastegate.h" // CAT 3408 V8 Diesel Open Pipes // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above @@ -80,7 +80,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -94,7 +94,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 104; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren2.h" // US fire truck (incl. loop) @@ -105,7 +105,7 @@ volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = #include "sounds/Tequila(1).h" // sound from nenno @ rc-modellbau-portal.de // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -115,12 +115,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -134,18 +134,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/CaboverCAT3408.h b/src/vehicles/CaboverCAT3408.h index da2384d..c8b3b09 100644 --- a/src/vehicles/CaboverCAT3408.h +++ b/src/vehicles/CaboverCAT3408.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 180; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 144; // Adjust the start volume (usually = 80%) #include "sounds/Cat3408Start.h" // CAT 3408 V8 Diesel start (Kenworth W900A) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/3408CatIdleLowpass.h" // CAT 3408 V8 Diesel idle (Kenworth W900A, 1.5kHz lowpass filtered) // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 700; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 140; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 4; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -45,25 +45,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/CaboverCATknock.h" // Cabover wit CAT engine knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 60; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 12; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 200; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 40; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 0; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#include "sounds/Tatra813Fan.h" // Tatra 813 8x8 V12 Diesel Cooling Fan @@ -72,7 +72,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -86,7 +86,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -96,7 +96,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -106,12 +106,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -125,18 +125,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/Caterpillar323Excavator.h b/src/vehicles/Caterpillar323Excavator.h index f73fd3c..c032509 100644 --- a/src/vehicles/Caterpillar323Excavator.h +++ b/src/vehicles/Caterpillar323Excavator.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) #include "sounds/Caterpillar323Start.h" // Caterpillar 323 excavator // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 80; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) 140 #include "sounds/Caterpillar323Idle.h" // Caterpillar 323 excavator // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound) 130 +volatile int revVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound) 104 volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) 350 +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) 70 volatile int dieselKnockIdleVolumePercentage = 10; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -45,25 +45,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/Caterpillar323Knock.h" // Caterpillar 323 excavator // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 15; // Adjust the turbo volume (usually = 70%) 15 +volatile int turboVolumePercentage = 3; // Adjust the turbo volume (usually = 14%) 3 volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 50; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -73,7 +73,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 140; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 112; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -87,20 +87,20 @@ volatile int hornVolumePercentage = 140; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound // Choose the additional "sound1" (uncomment the one you want) -------- @@ -108,19 +108,19 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- //#define LED_INDICATORS // LED based indicators will switch on and off immediately -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/Chevy468.h b/src/vehicles/Chevy468.h index e2bf125..6b6b91c 100644 --- a/src/vehicles/Chevy468.h +++ b/src/vehicles/Chevy468.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 80; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 64; // Adjust the start volume (usually = 80%) //#include "sounds/468ChevyBigBlockStart.h" // Chevy 486 V8 Start #include "sounds/ChevyPickupV8SoundStart.h" // Chevy V8 Pickup Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 70; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) 60 volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/468ChevyBigBlockIdle.h" // Chevy 486 V8 @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 80; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) 60 volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point 190 volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) 300 @@ -40,7 +40,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 20; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 10; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 16; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -60,25 +60,25 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) //#include "sounds/ChevyPickupV8SoundKnock2.h" // Chevy V8 Pickup // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -88,7 +88,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -100,7 +100,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 48; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -121,7 +121,7 @@ volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 1 #include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -129,12 +129,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -145,11 +145,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/ChevyNovaCoupeV8.h b/src/vehicles/ChevyNovaCoupeV8.h index 08bd335..80bf6c2 100644 --- a/src/vehicles/ChevyNovaCoupeV8.h +++ b/src/vehicles/ChevyNovaCoupeV8.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) #include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/ChevyNovaCoupeV8idle.h" // Chevy Nova Coupe V8 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 150; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 30; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 50; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -46,24 +46,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/ChevyNovaCoupeV8knock.h" // Chevy Nova Coupe V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -72,7 +72,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for //#include "sounds/Tatra813FanNewSlow.h" // Tatra 813 8x8 V12 Diesel Cooling Fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -84,7 +84,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 48; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -95,7 +95,7 @@ volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 1 #include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -103,12 +103,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -119,11 +119,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/ChevyNovaCoupeV8_P407.h b/src/vehicles/ChevyNovaCoupeV8_P407.h index 1888dbc..11c98fb 100644 --- a/src/vehicles/ChevyNovaCoupeV8_P407.h +++ b/src/vehicles/ChevyNovaCoupeV8_P407.h @@ -4,19 +4,19 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 100; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 80; // Adjust the start volume (usually = 80%) //#include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start #include "sounds/468ChevyBigBlockStart.h" // Chevy 486 V8 Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/ChevyNovaCoupeV8idle.h" // Chevy Nova Coupe V8 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) 100 +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) 80 volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 800; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 160; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 400; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -53,25 +53,25 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/OpenPipeKnock.h" // Extreme V8 petrol open pipe knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -81,7 +81,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -93,7 +93,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -105,7 +105,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -113,12 +113,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -129,11 +129,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/Defender62LS3.h b/src/vehicles/Defender62LS3.h index dfa1e09..c661ebd 100644 --- a/src/vehicles/Defender62LS3.h +++ b/src/vehicles/Defender62LS3.h @@ -4,19 +4,19 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 130; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 104; // Adjust the start volume (usually = 80%) //#include "sounds/JeepWranglerRubicon392V8_2Start3.h" // Jeep Wrangler Rubicon HEMI V8 #include "sounds/62LS3Start2.h" // Chevy LS3 V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/62LS3Idle.h" // Chevy LS3 V8 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 150; // Adjust the idle volume (usually = 100%, more also working, depending on sound) 100 +volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 80%, more also working, depending on sound) 80 volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -37,7 +37,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 750; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 150; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 400; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -54,25 +54,25 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/62LS3Knock.h" // Chevy LS3 V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -82,7 +82,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -94,7 +94,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 64; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -107,7 +107,7 @@ volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 1 #include "sounds/Bond.h" // Bond Theme // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -115,12 +115,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -131,11 +131,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/DefenderTd5.h b/src/vehicles/DefenderTd5.h index eeac74a..3471bc6 100644 --- a/src/vehicles/DefenderTd5.h +++ b/src/vehicles/DefenderTd5.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) #include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/DefenderTd5idle.h" // Land Rover Defender Td5 5 cylinder Diesel // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 110; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 22; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 5; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 250; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -45,24 +45,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/DefenderTd5knock.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 50; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 10; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 150; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -71,7 +71,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for //#include "sounds/Tatra813FanNewSlow.h" // Tatra 813 8x8 V12 Diesel Cooling Fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -83,7 +83,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -94,7 +94,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = #include "sounds/BritishNationalAnthemSiren.h" // The British national anthem ;-) // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -102,12 +102,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -118,11 +118,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/DefenderV8Automatic.h b/src/vehicles/DefenderV8Automatic.h index 913d400..c900b95 100644 --- a/src/vehicles/DefenderV8Automatic.h +++ b/src/vehicles/DefenderV8Automatic.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) #include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 75; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 60; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/DefenderV8Idle.h" // Land Rover Defender V8 (Volume 100%, 40%, Turbo 0%, 0, Fan 0, 0, 250, No Wastegate, CEP 100, TSM 2, Knock volume 500, 0%, interval 2, 50, automatic = true) // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 80; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 1000; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 100; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -52,26 +52,26 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/DefenderV8Knock.h" // Land Rover Defender V8 knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -81,7 +81,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -93,7 +93,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -103,7 +103,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -111,12 +111,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -127,11 +127,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/DefenderV8CrawlerAutomatic.h b/src/vehicles/DefenderV8CrawlerAutomatic.h index f394545..efcfbf9 100644 --- a/src/vehicles/DefenderV8CrawlerAutomatic.h +++ b/src/vehicles/DefenderV8CrawlerAutomatic.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) #include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/DefenderV8Idle.h" // Land Rover Defender V8 @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -39,7 +39,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 700; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 140; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 300; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -57,26 +57,26 @@ uint16_t knockStartRpm = 200; // starting @ this RPM (about 50 - 400) #include "sounds/DefenderV8PureSoundKnock4.h" // Land Rover Defender V8 crawler // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -86,7 +86,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -98,7 +98,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -108,7 +108,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -116,12 +116,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -132,11 +132,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/DefenderV8OpenPipe.h b/src/vehicles/DefenderV8OpenPipe.h index a09803a..b17900e 100644 --- a/src/vehicles/DefenderV8OpenPipe.h +++ b/src/vehicles/DefenderV8OpenPipe.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) //#include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start #include "sounds/DefenderV8OpenPipeStart.h" // Land Rover Defender V8 Start (long) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 120; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/DefenderV8Idle.h" // Land Rover Defender V8 @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 120; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 80; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -38,7 +38,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 900; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 180; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 100; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -55,26 +55,26 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/DefenderV8OpenPipeKnock.h" // Land Rover Defender V8 knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -84,7 +84,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -96,7 +96,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -107,7 +107,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = #include "sounds/BritishNationalAnthemSiren.h" // The British national anthem ;-) // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -115,12 +115,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 80; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 16; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -131,11 +131,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/DefenderV8OpenPipeAutomatic.h b/src/vehicles/DefenderV8OpenPipeAutomatic.h index f84492c..b947c56 100644 --- a/src/vehicles/DefenderV8OpenPipeAutomatic.h +++ b/src/vehicles/DefenderV8OpenPipeAutomatic.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) //#include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start #include "sounds/DefenderV8OpenPipeStart.h" // Land Rover Defender V8 Start (long) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 120; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/DefenderV8Idle.h" // Land Rover Defender V8 @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 120; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 80; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -38,7 +38,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 900; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 180; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 100; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -55,26 +55,26 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/DefenderV8OpenPipeKnock.h" // Land Rover Defender V8 knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -84,7 +84,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -96,7 +96,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -107,7 +107,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = #include "sounds/BritishNationalAnthemSiren.h" // The British national anthem ;-) // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -115,12 +115,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -131,11 +131,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/FordPowerstroke.h b/src/vehicles/FordPowerstroke.h index 5abb456..1f28baa 100644 --- a/src/vehicles/FordPowerstroke.h +++ b/src/vehicles/FordPowerstroke.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/POWERSTROKEstart2.h" // Ford Powerstroke 7.3l V8 Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/POWERSTROKEidle.h" // Ford Powerstroke 7.3l V8 Diesel @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 20; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 400; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 80; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -46,24 +46,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 30; // Adjust the Diesel knoc #include "sounds/POWERSTROKEknock.h" // Ford Powerstroke 7.3l V8 Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 60; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 12; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 120; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 24; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/POWERSTROKEwastegate.h" // Ford Powerstroke 7.3l V8 Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -73,7 +73,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 128; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -88,7 +88,7 @@ volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -98,7 +98,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -108,12 +108,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -127,11 +127,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/FreightlinerCummins350 2.h b/src/vehicles/FreightlinerCummins350 2.h index 058caf1..5dfa274 100644 --- a/src/vehicles/FreightlinerCummins350 2.h +++ b/src/vehicles/FreightlinerCummins350 2.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 180; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 144; // Adjust the start volume (usually = 80%) #include "sounds/FreightlinerCummins350CaboverStart2.h" // Freightliner Cummins 350 R6 Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/FreightlinerCummins350CaboverIdle3.h" // Freightliner Cummins 350 R6 Diesel @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- //#define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 130; // Adjust the rev volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 104; // Adjust the rev volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -38,7 +38,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 250; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 50; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -49,25 +49,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/FreightlinerCummins350CaboverKnock.h" // Freightliner Cummins 350 R6 Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 30; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 6; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 120; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 24; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -77,7 +77,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -92,7 +92,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 #include "sounds/FreightlinerCummins350CaboverHorn.h" // Freightliner Cummins 350 R6 Diesel // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren2.h" // US fire truck (incl. loop) @@ -112,7 +112,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/Tequila(1).h" // sound from nenno @ rc-modellbau-portal.de // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -121,12 +121,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -140,18 +140,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/FreightlinerCummins350.h b/src/vehicles/FreightlinerCummins350.h index 53fdd8e..72051c7 100644 --- a/src/vehicles/FreightlinerCummins350.h +++ b/src/vehicles/FreightlinerCummins350.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 180; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 144; // Adjust the start volume (usually = 80%) #include "sounds/FreightlinerCummins350CaboverStart2.h" // Freightliner Cummins 350 R6 Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/FreightlinerCummins350CaboverIdle3.h" // Freightliner Cummins 350 R6 Diesel @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 130; // Adjust the rev volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 104; // Adjust the rev volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -39,7 +39,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -51,25 +51,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 80; // Adjust the Diesel knoc #include "sounds/FreightlinerCummins350CaboverKnock.h" // Freightliner Cummins 350 R6 Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 30; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 6; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 120; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 24; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -79,7 +79,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -94,7 +94,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 #include "sounds/FreightlinerCummins350CaboverHorn.h" // Freightliner Cummins 350 R6 Diesel // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren2.h" // US fire truck (incl. loop) @@ -114,7 +114,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/Tequila(1).h" // sound from nenno @ rc-modellbau-portal.de // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -123,12 +123,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -142,18 +142,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/GAZ66.h b/src/vehicles/GAZ66.h index a593cd7..0fedf27 100644 --- a/src/vehicles/GAZ66.h +++ b/src/vehicles/GAZ66.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/GAZ66start.h" // GAZ-66 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/GAZ66idle.h" // GAZ-66 @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 130; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 104; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -37,7 +37,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 150; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 30; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -47,25 +47,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/GAZ66knock.h" // GAZ-66 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -75,7 +75,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -88,7 +88,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/CaboverCAThorn.h" // Cabover wit CAT engine horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -98,7 +98,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -107,12 +107,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -126,18 +126,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/GMCsierra.h b/src/vehicles/GMCsierra.h index bac7ad8..eca5aa6 100644 --- a/src/vehicles/GMCsierra.h +++ b/src/vehicles/GMCsierra.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) #include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 70; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) 60 volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/GMCSierraPickupIdle.h" // GMC Sierra V8 Pickup // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 70; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) 60 volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 300; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 60; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 400; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -51,25 +51,25 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/GMCSierraPickupKnock.h" // GMC Sierra V8 Pickup // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -79,7 +79,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -91,7 +91,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 48; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -112,7 +112,7 @@ volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 1 #include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -120,12 +120,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -136,11 +136,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/HarleyDavidsonFXSB.h b/src/vehicles/HarleyDavidsonFXSB.h index ae560f8..10f71e0 100644 --- a/src/vehicles/HarleyDavidsonFXSB.h +++ b/src/vehicles/HarleyDavidsonFXSB.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) #include "sounds/HarleyDavidsonFXSBStart.h" // Harley Davidson FXSB start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 60; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 48; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/HarleyDavidsonFXSBIdle.h" // Harley Davidson FXSB // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 60; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 48; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) const uint16_t revSwitchPoint = 200; // The rev sound is played instead of the idle sound above this point const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -34,7 +34,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 150; // Adjust the Diesel knock volume (usually = 200 - 500%) +volatile int dieselKnockVolumePercentage = 30; // Adjust the Diesel knock volume (usually = 40 - 100%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 4; // Idle sample length divided by this number (4 for V2 engine!) volatile int dieselKnockStartPoint = 0; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -44,25 +44,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 40; // Adjust the Diesel knoc #include "sounds/HarleyDavidsonFXSBKnock.h" // Harley Davidson FXSB knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 10; // the turbo volume will be throttle dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 100; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 20; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -71,7 +71,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for //#include "sounds/Tatra813FanNewSlow.h" // Tatra 813 8x8 V12 Diesel Cooling Fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -83,7 +83,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound #include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -93,7 +93,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -101,12 +101,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 0; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 0; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -120,11 +120,11 @@ volatile int sound1VolumePercentage = 0; // Adjust the sound1 volume (usually = #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/HiluxDiesel.h b/src/vehicles/HiluxDiesel.h index 7afcd58..510adb1 100644 --- a/src/vehicles/HiluxDiesel.h +++ b/src/vehicles/HiluxDiesel.h @@ -4,20 +4,20 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) //#include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start //#include "sounds/POWERSTROKEstart2.h" // Ford Powerstroke 7.3l V8 Diesel #include "sounds/Landcruiser12HTstart.h" // Toyota Fj40 Landcruiser with 12H Turbo Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/Landcruiser12HTidle.h" // Toyota Fj40 Landcruiser with 12H Turbo Diesel // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -37,7 +37,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 320; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 64; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 150; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -48,24 +48,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/Landcruiser12HTknock.h" // Toyota Fj40 Landcruiser with 12H Turbo Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 40; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 8; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 100; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 20; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 20; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 4; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -75,7 +75,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -87,7 +87,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -97,7 +97,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -105,12 +105,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -121,11 +121,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/IS3.h b/src/vehicles/IS3.h index d6c91b7..e2c84ec 100644 --- a/src/vehicles/IS3.h +++ b/src/vehicles/IS3.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) #include "sounds/IS3TankStart.h" // IS-3 tank // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/IS3TankIdle.h" // IS-3 tank @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 250; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 250; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 12; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -46,23 +46,23 @@ volatile int dieselKnockAdaptiveVolumePercentage = 10; // Adjust the Diesel knoc #include "sounds/IS3TankKnock.h" // IS-3 tank // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -72,7 +72,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 0; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 0; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -86,7 +86,7 @@ volatile int hornVolumePercentage = 0; // Adjust the horn volume (usually = 100% #include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 120; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 96; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -97,7 +97,7 @@ volatile int sirenVolumePercentage = 120; // Adjust the siren volume (usually = #include "sounds/75mm.h" // 75mm salve // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -106,12 +106,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -125,11 +125,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually //#include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/JaguarXJS.h b/src/vehicles/JaguarXJS.h index 7e18f5e..78d38e0 100644 --- a/src/vehicles/JaguarXJS.h +++ b/src/vehicles/JaguarXJS.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/JaguarXJSstart.h" // Jaguar XJS V12 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/JaguarXJSidle2.h" // Jaguar XJS V12 @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 0; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 0; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 12; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -46,25 +46,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/DieselKnockDummy.h" // If you don't want Diesel knock sound // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 90; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 18; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -89,7 +89,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -99,7 +99,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -109,12 +109,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -128,11 +128,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/JaguarXJSautomatic.h b/src/vehicles/JaguarXJSautomatic.h index 29d4e02..7172296 100644 --- a/src/vehicles/JaguarXJSautomatic.h +++ b/src/vehicles/JaguarXJSautomatic.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/JaguarXJSstart.h" // Jaguar XJS V12 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/JaguarXJSidle2.h" // Jaguar XJS V12 @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 0; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 0; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 12; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -46,25 +46,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/DieselKnockDummy.h" // If you don't want Diesel knock sound // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 90; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 18; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -89,7 +89,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -99,7 +99,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -109,12 +109,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -128,11 +128,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/JeepGrandCherokeeTrackhawk.h b/src/vehicles/JeepGrandCherokeeTrackhawk.h index 2e8a2c1..b5e217c 100644 --- a/src/vehicles/JeepGrandCherokeeTrackhawk.h +++ b/src/vehicles/JeepGrandCherokeeTrackhawk.h @@ -4,19 +4,19 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 130; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 104; // Adjust the start volume (usually = 80%) //#include "sounds/JeepGrandCherokeeTrackhawkStart.h" // Jeep Grand Cherokee Trackhawk start #include "sounds/carCranking.h" // Generic car cranking // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 70; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/JeepGrandCherokeeTrackhawkIdle.h" // Jeep Grand Cherokee Trackhawk idle (speaker with good bass required) // Choose the motor revving sound (uncomment the one you want) -------- //#define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 150; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 30; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) const uint16_t revSwitchPoint = 250; // The rev sound is played instead of the idle sound above this point const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 800; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 160; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 20; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 10; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -53,25 +53,25 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) //#include "sounds/demonhawkKnock.h" // Jeep Grand Cherokee Trackhawk knock, 1100HP tuned // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 90; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 18; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 50; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -81,7 +81,7 @@ volatile int fanStartPoint = 50; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -93,7 +93,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 48; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -104,7 +104,7 @@ volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 1 #include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -112,12 +112,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -131,12 +131,12 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- #define LED_INDICATORS // LED based indicators will switch on and off immediately -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/JeepWranglerRubicon392V8.h b/src/vehicles/JeepWranglerRubicon392V8.h index c08fc51..3307021 100644 --- a/src/vehicles/JeepWranglerRubicon392V8.h +++ b/src/vehicles/JeepWranglerRubicon392V8.h @@ -4,19 +4,19 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 250; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 200; // Adjust the start volume (usually = 80%) //#include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start #include "sounds/JeepWranglerRubicon392V8Start.h" // Jeep Wrangler Rubicon HEMI V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/JeepWranglerRubicon392V8Idle.h" // Jeep Wrangler Rubicon HEMI V8 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) 100 +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) 80 volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a /* // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 800; // Adjust the Diesel knock volume (usually = 200 - 600%) 500 +volatile int dieselKnockVolumePercentage = 160; // Adjust the Diesel knock volume (usually = 40 - 120%) 100 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 400; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) 350 @@ -49,7 +49,7 @@ volatile int dieselKnockAdaptiveVolumePercentage = 30; // Adjust the Diesel knoc // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 800; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 160; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 400; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -66,25 +66,25 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/JeepWranglerRubicon392V8Knock.h" // Jeep Wrangler Rubicon HEMI V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -94,7 +94,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -106,7 +106,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 48; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -118,7 +118,7 @@ volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 1 #include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -126,12 +126,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -142,11 +142,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/JeepWranglerRubicon392V8_2.h b/src/vehicles/JeepWranglerRubicon392V8_2.h index b532ae2..3b3d9fc 100644 --- a/src/vehicles/JeepWranglerRubicon392V8_2.h +++ b/src/vehicles/JeepWranglerRubicon392V8_2.h @@ -4,19 +4,19 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 130; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 104; // Adjust the start volume (usually = 80%) //#include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start #include "sounds/JeepWranglerRubicon392V8_2Start3.h" // Jeep Wrangler Rubicon HEMI V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/JeepWranglerRubicon392V8_2Idle2.h" // Jeep Wrangler Rubicon HEMI V8 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) 100 +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) 80 volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 800; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 160; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 400; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -53,25 +53,25 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/JeepWranglerRubicon392V8_2Knock3.h" // Jeep Wrangler Rubicon HEMI V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -81,7 +81,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -93,7 +93,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 30; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 24; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -105,7 +105,7 @@ volatile int sirenVolumePercentage = 30; // Adjust the siren volume (usually = 1 #include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -113,12 +113,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -129,11 +129,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/KenworthCummins335.h b/src/vehicles/KenworthCummins335.h index 584fd6b..16e94f4 100644 --- a/src/vehicles/KenworthCummins335.h +++ b/src/vehicles/KenworthCummins335.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 180; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 144; // Adjust the start volume (usually = 80%) #include "sounds/KenworthCummins335Start.h" // Cummins 335 R6 Diesel start sound (1952 Kenworth) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/KenworthCummins335Idle.h" // Cummins 335 R6 Diesel idle sound (1952 Kenworth) // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 130; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 104; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a /* // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -47,7 +47,7 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 700; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 140; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 20; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -63,25 +63,25 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) #include "sounds/KenworthCummins335Knock2.h" // Cummins 335 R6 Diesel knock sound (1952 Kenworth) // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 80; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 16; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 150; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -91,7 +91,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -105,7 +105,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren2.h" // US fire truck (incl. loop) @@ -115,7 +115,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -124,12 +124,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -143,18 +143,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/KenworthW900ACAT3408.h b/src/vehicles/KenworthW900ACAT3408.h index 58cc964..8e09042 100644 --- a/src/vehicles/KenworthW900ACAT3408.h +++ b/src/vehicles/KenworthW900ACAT3408.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) //#include "sounds/Cat3408Start.h" // CAT 3408 V8 Diesel start (Kenworth W900A) #include "sounds/Cat3408Start2.h" // CAT 3408 V8 Diesel start (Kenworth W900A, b+7, h-7) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/3408CatIdle.h" // CAT 3408 V8 Diesel idle (Kenworth W900A) @@ -18,7 +18,7 @@ volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -43,7 +43,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 700; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 140; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 20; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 4; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -60,25 +60,25 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) #include "sounds/3408CatKnock.h" // CAT 3408 V8 Diesel knock (Kenworth W900A) // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 80; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 16; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 200; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 40; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above @@ -88,7 +88,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -102,7 +102,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 104; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren2.h" // US fire truck (incl. loop) @@ -113,7 +113,7 @@ volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = #include "sounds/Tequila(1).h" // sound from nenno @ rc-modellbau-portal.de // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -123,12 +123,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -142,18 +142,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/KenworthW900ACAT3408new.h b/src/vehicles/KenworthW900ACAT3408new.h index 3a45e49..8cf22ab 100644 --- a/src/vehicles/KenworthW900ACAT3408new.h +++ b/src/vehicles/KenworthW900ACAT3408new.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/Cat3408newStart.h" // CAT 3408 V8 Diesel start (Kenworth W900A) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/3408CatIdle.h" // CAT 3408 V8 Diesel idle (Kenworth W900A) @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 190; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 152; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -41,7 +41,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -56,25 +56,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 30; // Adjust the Diesel knoc //#include "sounds/straightPipedCompilationKnock.h" // Straight piped V8 knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 50; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 10; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 100; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 20; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above @@ -84,7 +84,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -98,7 +98,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 104; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren2.h" // US fire truck (incl. loop) @@ -108,7 +108,7 @@ volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -118,12 +118,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -137,18 +137,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/KenworthW900ADetroit8V71.h b/src/vehicles/KenworthW900ADetroit8V71.h index b511a37..9421bcd 100644 --- a/src/vehicles/KenworthW900ADetroit8V71.h +++ b/src/vehicles/KenworthW900ADetroit8V71.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 180; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 144; // Adjust the start volume (usually = 80%) #include "sounds/1981KenworthW900A_DetroitStart.h" // Detroit Diesel 8V71 start sound (1981 Kenworth W900A) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/DetroitDieselIdle.h" // Detroit Diesel generic Truck (Volume 80%, 30%, Turbo 60%, 10%, Wastegate 50%, 1%, CEP 100, TSM 3) @@ -24,7 +24,7 @@ volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 150; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -51,7 +51,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 400; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 80; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 4; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -63,25 +63,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/1981KenworthW900A_DetroitKnock2.h" // Detroit Diesel 8V71 knock sound (1981 Kenworth W900A) // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 35; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 7; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 110; // Volume will raise above this point (250 for Tatra 813) #define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -89,7 +89,7 @@ volatile int fanStartPoint = 110; // Volume will raise above this point (250 for //#include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -103,12 +103,12 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/FireTruckAirSiren2.h" // US fire truck (incl. loop) // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -117,12 +117,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -136,18 +136,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/KirovetsK700.h b/src/vehicles/KirovetsK700.h index 12f483f..0b2ba7f 100644 --- a/src/vehicles/KirovetsK700.h +++ b/src/vehicles/KirovetsK700.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 170; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 136; // Adjust the start volume (usually = 80%) #include "sounds/KirovetsK700start.h" // Kirovets K700 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 120; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/KirovetsK700idle.h" // Kirovets K700 @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 120; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 250; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 250; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 180; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 36; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 12; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -46,23 +46,23 @@ volatile int dieselKnockAdaptiveVolumePercentage = 10; // Adjust the Diesel knoc #include "sounds/KirovetsK700knock.h" // Kirovets K700 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 120; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 24; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 20; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -72,7 +72,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 150; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 120; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -86,7 +86,7 @@ volatile int hornVolumePercentage = 150; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 120; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 96; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -97,7 +97,7 @@ volatile int sirenVolumePercentage = 120; // Adjust the siren volume (usually = //#include "sounds/75mm.h" // 75mm salve // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -106,12 +106,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -125,11 +125,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/LaFerrari.h b/src/vehicles/LaFerrari.h index 1db011a..e4f7858 100644 --- a/src/vehicles/LaFerrari.h +++ b/src/vehicles/LaFerrari.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/LaFerrariStart.h" // Ferrari LaFerrari, V12 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/LaFerrariIdle.h" // Jaguar XJS V12 @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 10; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 12; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -52,25 +52,25 @@ uint16_t knockStartRpm = 400; // starting @ this RPM (about 50 - 400) #include "sounds/LaFerrariKnock.h" // Ferrari LaFerrari, V12 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 90; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 18; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -80,7 +80,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -95,7 +95,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -105,7 +105,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -115,12 +115,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -134,11 +134,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/LandcruiserFJ40.h b/src/vehicles/LandcruiserFJ40.h index 3f00625..f9c3ada 100644 --- a/src/vehicles/LandcruiserFJ40.h +++ b/src/vehicles/LandcruiserFJ40.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) #include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/FJ40idle.h" // Toyota Fj40 Landcruiser 2F inline 6 petrol // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 200; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 24; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 250; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -46,24 +46,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/FJ40knock.h" // Toyota Fj40 Landcruiser 2F inline 6 petrol // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 150; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 100; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 20; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -73,7 +73,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -85,7 +85,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -95,7 +95,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -103,12 +103,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -119,11 +119,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/LandcruiserFJ40Diesel.h b/src/vehicles/LandcruiserFJ40Diesel.h index 08b1e2f..a93edc9 100644 --- a/src/vehicles/LandcruiserFJ40Diesel.h +++ b/src/vehicles/LandcruiserFJ40Diesel.h @@ -4,19 +4,19 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 96; // Adjust the start volume (usually = 80%) //#include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start #include "sounds/POWERSTROKEstart2.h" // Ford Powerstroke 7.3l V8 Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/TOYOTA12H-Tidle.h" // Toyota Fj40 Landcruiser with 12H Turbo Diesel // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 350; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 70; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 150; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -47,24 +47,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/TOYOTA12H-Tknock.h" // Toyota Fj40 Landcruiser with 12H Turbo Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 30; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 6; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 100; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 20; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 20; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 4; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -86,7 +86,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -96,7 +96,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -104,12 +104,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -120,11 +120,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/LandcruiserFJ40Diesel2.h b/src/vehicles/LandcruiserFJ40Diesel2.h index 11f4749..2062c29 100644 --- a/src/vehicles/LandcruiserFJ40Diesel2.h +++ b/src/vehicles/LandcruiserFJ40Diesel2.h @@ -4,20 +4,20 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) //#include "sounds/DefenderV8Start.h" // Land Rover Defender V8 Start //#include "sounds/POWERSTROKEstart2.h" // Ford Powerstroke 7.3l V8 Diesel #include "sounds/Landcruiser12HTstart.h" // Toyota Fj40 Landcruiser with 12H Turbo Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/Landcruiser12HTidle.h" // Toyota Fj40 Landcruiser with 12H Turbo Diesel // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -37,7 +37,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 320; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 64; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 150; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -48,24 +48,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/Landcruiser12HTknock.h" // Toyota Fj40 Landcruiser with 12H Turbo Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 40; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 8; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 100; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 20; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 20; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 4; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -75,7 +75,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -87,7 +87,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -97,7 +97,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -105,12 +105,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -121,11 +121,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/M35.h b/src/vehicles/M35.h index a86682f..0fd857d 100644 --- a/src/vehicles/M35.h +++ b/src/vehicles/M35.h @@ -4,7 +4,7 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) //#include "sounds/UnionPacific2002start.h" // Union Pacific 2002 SD70M Locomotive Start //#include "sounds/ScaniaV8start.h" // Scania V8 Start //#include "sounds/ScaniaR500V8Start.h" // Scania R500 V8 Start @@ -30,7 +30,7 @@ volatile int startVolumePercentage = 150; // Adjust the start volume (usually = //#include "sounds/KenworthCummins335Start.h" // Cummins 335 R6 Diesel start sound (1952 Kenworth) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/M35idle.h" // AM General M35 Truck @@ -38,7 +38,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -60,7 +60,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -70,25 +70,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/M35knock.h" // AM General M35 Truck // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 100; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 20; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 30; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 90; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 18; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -98,7 +98,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 120; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 96; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -114,7 +114,7 @@ volatile int hornVolumePercentage = 120; // Adjust the horn volume (usually = 10 #include "sounds/M35horn.h" // AM General M35 Truck // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -124,7 +124,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -134,12 +134,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -153,18 +153,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/MGBGtV8.h b/src/vehicles/MGBGtV8.h index bcac52c..106c422 100644 --- a/src/vehicles/MGBGtV8.h +++ b/src/vehicles/MGBGtV8.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 170; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 136; // Adjust the start volume (usually = 80%) #include "sounds/MGBGtV8start.h" // MGB GT V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/MGBGtV8idle.h" // MGB GT V8 @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 250; // The rev sound is played instead of the idle sound above this point 250 volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a /* // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 800; // Adjust the Diesel knock volume (usually = 200 - 600%) 250 +volatile int dieselKnockVolumePercentage = 160; // Adjust the Diesel knock volume (usually = 40 - 120%) 50 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -49,7 +49,7 @@ volatile int dieselKnockAdaptiveVolumePercentage = 20; // Adjust the Diesel knoc // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 800; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 160; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 10; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -64,25 +64,25 @@ uint16_t knockStartRpm = 100; // starting @ this RPM (about 50 - 400) #include "sounds/MGBGtV8knock.h" // MGB GT V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 90; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 18; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -92,7 +92,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -107,7 +107,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -117,7 +117,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -127,12 +127,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -146,11 +146,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/MackSuperLiner.h b/src/vehicles/MackSuperLiner.h index 3e43deb..0e65c22 100644 --- a/src/vehicles/MackSuperLiner.h +++ b/src/vehicles/MackSuperLiner.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/Cat3408Start.h" // CAT 3408 V8 Diesel start (Kenworth W900A) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/MackSuperLinerIdle.h" // MACK Super Liner idle // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 280; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 56; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -45,25 +45,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/MackSuperLinerKnock.h" // MACK Super Liner knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 25; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 5; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 90; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 18; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -73,7 +73,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 170; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 136; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -88,7 +88,7 @@ volatile int hornVolumePercentage = 170; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -98,7 +98,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -108,12 +108,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -127,18 +127,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/MagirusDeutz256.h b/src/vehicles/MagirusDeutz256.h index 6a31b6c..db640da 100644 --- a/src/vehicles/MagirusDeutz256.h +++ b/src/vehicles/MagirusDeutz256.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) #include "sounds/MagirusDeutz256Start.h" // Magirus Deutz 256 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/MagirusDeutz256Idle.h" // Magirus Deutz 256 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 5; // The rev sound is played instead of the idle sound above this point 150 volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 250; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 850; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 170; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 20; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -51,24 +51,24 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) //#include "sounds/MagirusDeutz256Knock2.h" // Magirus Deutz 256 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 150; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/1000HpScaniaV8wastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 30; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 6; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 10; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -78,7 +78,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -92,7 +92,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -102,7 +102,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -111,12 +111,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound #include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -130,18 +130,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/MagirusMercur125.h b/src/vehicles/MagirusMercur125.h index c93fe47..92d39e7 100644 --- a/src/vehicles/MagirusMercur125.h +++ b/src/vehicles/MagirusMercur125.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) #include "sounds/MagirusDeutz256Start.h" // Magirus Deutz 256 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/MagirusMercur125Idle.h" // Magirus Mercur 125 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 5; // The rev sound is played instead of the idle sound above this point 150 volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 250; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) 850 +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) 850 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 20; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -52,24 +52,24 @@ uint16_t knockStartRpm = 20; // starting @ this RPM (about 50 - 400) #include "sounds/MagirusMercur125Knock2.h" // Magirus Mercur 125 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 150; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/1000HpScaniaV8wastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 10; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -79,7 +79,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -93,7 +93,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -103,7 +103,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 140; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 28; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -112,12 +112,12 @@ volatile int brakeVolumePercentage = 140; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 130; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 26; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -131,18 +131,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/ManKat.h b/src/vehicles/ManKat.h index 495bba0..3b0413a 100644 --- a/src/vehicles/ManKat.h +++ b/src/vehicles/ManKat.h @@ -4,7 +4,7 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 300; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 240; // Adjust the start volume (usually = 80%) //#include "sounds/UnionPacific2002start.h" // Union Pacific 2002 SD70M Locomotive Start //#include "sounds/ScaniaV8start.h" // Scania V8 Start //#include "sounds/ScaniaR500V8Start.h" // Scania R500 V8 Start @@ -26,7 +26,7 @@ volatile int startVolumePercentage = 300; // Adjust the start volume (usually = #include "sounds/ManKatStart.h" // MAN KAT V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 40; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/Ural4320Idle.h" // URAL 4320 V8 Diesel @@ -35,7 +35,7 @@ volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 40; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 80; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -58,7 +58,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 400; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 80; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 50; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -70,25 +70,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/ManKatKnock.h" // MAN KAT V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 10; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 10; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 10; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 300; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -97,7 +97,7 @@ volatile int fanStartPoint = 300; // Volume will raise above this point (250 for //#include "sounds/Tatra813FanNewSlow.h" // Tatra 813 8x8 V12 Diesel Cooling Fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 150; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 120; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -113,7 +113,7 @@ volatile int hornVolumePercentage = 150; // Adjust the horn volume (usually = 10 // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -123,7 +123,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 250; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 50; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -133,12 +133,12 @@ volatile int brakeVolumePercentage = 250; // Adjust the brake volume (usually = #include "sounds/ManKatBrake.h" // MAN KAT V8 // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 160; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 32; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -152,18 +152,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually //#include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 60; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 12; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/ManTgx.h b/src/vehicles/ManTgx.h index 22e8e19..e26237e 100644 --- a/src/vehicles/ManTgx.h +++ b/src/vehicles/ManTgx.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/MANTGXstart.h" // MAN TGX 680 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/MANTGXidle.h" // MAN TGX 680 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 150; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 250; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 600; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -45,24 +45,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 15; // Adjust the Diesel knoc #include "sounds/MANTGXknock2.h" // MAN TGX 680 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 40; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 8; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 150; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/MANTGXwastegate2.h" // MAN TGX 680 // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -72,7 +72,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short #include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -86,7 +86,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -96,7 +96,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -105,12 +105,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -125,18 +125,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/MercedesActros1836.h b/src/vehicles/MercedesActros1836.h index 36d72d6..4e03ee3 100644 --- a/src/vehicles/MercedesActros1836.h +++ b/src/vehicles/MercedesActros1836.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 130; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 104; // Adjust the start volume (usually = 80%) #include "sounds/Actros1863start.h" // Actros 1863 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/Actros1863idle2.h" // Actros 1863 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 130; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 104; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 130; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 26; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 10; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -46,25 +46,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/Actros1863knock3.h" // Actros 1863 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 30; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 6; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 50; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short #include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -88,7 +88,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -108,7 +108,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/Alphorn.h" // Alphorn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -117,12 +117,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -136,19 +136,19 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- //#define LED_INDICATORS // LED based indicators will switch on and off immediately -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/MercedesActrosV6.h b/src/vehicles/MercedesActrosV6.h index 69e07c1..f21b627 100644 --- a/src/vehicles/MercedesActrosV6.h +++ b/src/vehicles/MercedesActrosV6.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 160; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 128; // Adjust the start volume (usually = 80%) #include "sounds/ActrosV6Start.h" // Actros V6 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/ActrosV6Idle.h" // Actros V6 @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 160; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 128; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -37,7 +37,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 800; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 160; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 10; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 110; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -53,25 +53,25 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) #include "sounds/ActrosV6Knock.h" // Actros V6 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 150; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 30; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 250; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 50; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -81,7 +81,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short #include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -95,7 +95,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -115,7 +115,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/Alphorn.h" // Alphorn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -124,12 +124,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -143,19 +143,19 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 50; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 10; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- //#define LED_INDICATORS // LED based indicators will switch on and off immediately -volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/MesserschmittBf109.h b/src/vehicles/MesserschmittBf109.h index d4c7f30..7ff04df 100644 --- a/src/vehicles/MesserschmittBf109.h +++ b/src/vehicles/MesserschmittBf109.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 130; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 104; // Adjust the start volume (usually = 80%) #include "sounds/MesserschmittBf109start3.h" // Messerschmitt Bf109 Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 110; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/MesserschmittBf109idle.h" // Messerschmitt Bf109 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 150; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 10; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 10; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 12; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 200; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -45,26 +45,26 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/MesserschmittBf109knock.h" // Messerschmitt Bf109 Knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 40; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 8; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! //#include "sounds/UnionPacific2002turbo.h" // Union Pacific 2002 SD70M Locomotive with 16 cylinder Diesel // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 90; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 18; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 0; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 0; // Adjust the horn volume (usually = 80%) #include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -89,7 +89,7 @@ volatile int hornVolumePercentage = 0; // Adjust the horn volume (usually = 100% //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -99,7 +99,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -109,12 +109,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -129,11 +129,11 @@ volatile int sound1VolumePercentage = 170; // Adjust the sound1 volume (usually #include "sounds/MesserschmittBf109Guns.h" // Messerschmitt Bf109 Gun // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/PeterbiltDetroit8v92.h b/src/vehicles/PeterbiltDetroit8v92.h index 8d13f06..34499b8 100644 --- a/src/vehicles/PeterbiltDetroit8v92.h +++ b/src/vehicles/PeterbiltDetroit8v92.h @@ -4,19 +4,19 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 170; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 136; // Adjust the start volume (usually = 80%) //#include "sounds/Cat3408Start.h" // CAT 3408 V8 Diesel start (Kenworth W900A) #include "sounds/8v92PeterbiltStart.h" // Peterbilt with Detroit 8V92 2 stroke V8 Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 70; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/8v92PeterbiltIdle.h" // Peterbilt with Detroit 8V92 2 stroke V8 Diesel // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -38,7 +38,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 450; // Adjust the Diesel knock volume (usually = 200 - 600%) 700 +volatile int dieselKnockVolumePercentage = 90; // Adjust the Diesel knock volume (usually = 40 - 120%) 140 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 20; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -53,18 +53,18 @@ uint16_t knockStartRpm = 50; // starting @ this RPM (about 50 - 400) #include "sounds/8v92PeterbiltKnock.h" // Peterbilt with Detroit 8V92 2 stroke V8 Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 10; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 10; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 200; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 40; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" @@ -72,7 +72,7 @@ volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, af //#include "sounds/3408CatCoalWastegate.h" // CAT 3408 V8 Diesel Open Pipes // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above @@ -82,7 +82,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -96,7 +96,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 104; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren2.h" // US fire truck (incl. loop) @@ -107,7 +107,7 @@ volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = #include "sounds/Tequila(1).h" // sound from nenno @ rc-modellbau-portal.de // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -117,12 +117,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -136,18 +136,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/RAM2500_Cummins12V.h b/src/vehicles/RAM2500_Cummins12V.h index f21de5a..24a4b13 100644 --- a/src/vehicles/RAM2500_Cummins12V.h +++ b/src/vehicles/RAM2500_Cummins12V.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/POWERSTROKEstart2.h" // Ford Powerstroke 7.3l V8 Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/RAM2500_Cummins12Vidle.h" // Cummins R6 12V 5.9l Diesel @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 20; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 260; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 52; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -47,24 +47,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 80; // Adjust the Diesel knoc #include "sounds/RAM2500_Cummins12Vknock.h" // Cummins R6 12V 5.9l Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 60; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 12; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 120; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 24; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/POWERSTROKEwastegate.h" // Ford Powerstroke 7.3l V8 Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 128; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -89,7 +89,7 @@ volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 48; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -100,7 +100,7 @@ volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 1 #include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -110,12 +110,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -129,11 +129,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/RAM2500_Cummins12Vautomatic.h b/src/vehicles/RAM2500_Cummins12Vautomatic.h index 958e256..f4d33bf 100644 --- a/src/vehicles/RAM2500_Cummins12Vautomatic.h +++ b/src/vehicles/RAM2500_Cummins12Vautomatic.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/POWERSTROKEstart2.h" // Ford Powerstroke 7.3l V8 Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/RAM2500_Cummins12Vidle.h" // Cummins R6 12V 5.9l Diesel @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 20; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 260; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 52; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -47,24 +47,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 80; // Adjust the Diesel knoc #include "sounds/RAM2500_Cummins12Vknock.h" // Cummins R6 12V 5.9l Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 60; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 12; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 120; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 24; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/POWERSTROKEwastegate.h" // Ford Powerstroke 7.3l V8 Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 128; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn #include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -89,7 +89,7 @@ volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 48; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -100,7 +100,7 @@ volatile int sirenVolumePercentage = 60; // Adjust the siren volume (usually = 1 #include "sounds/kittScanner.h" // Knight Rider KITT scanner. Use it in combination with Neopixel animation. // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -110,12 +110,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -129,11 +129,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/Saurer2DM.h b/src/vehicles/Saurer2DM.h index 8e4775b..e7534f4 100644 --- a/src/vehicles/Saurer2DM.h +++ b/src/vehicles/Saurer2DM.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) #include "sounds/Saurer2DMstart.h" // Saurer 2DM // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) 80 +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) 64 volatile int engineIdleVolumePercentage = 70; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/Saurer2DMidle.h" // Saurer 2DM // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) 100 +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) 80 volatile int engineRevVolumePercentage = 70; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point 5 volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -35,7 +35,7 @@ volatile int jakeBrakeMinRpm = 250; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 300; // Adjust the Diesel knock volume (usually = 200 - 600%) 250 +volatile int dieselKnockVolumePercentage = 60; // Adjust the Diesel knock volume (usually = 40 - 120%) 50 volatile int dieselKnockIdleVolumePercentage = 30; // Diesel knock volume while no throttle is applied (usually = 20%) volatile int dieselKnockStartPoint = 20; // Volume will raise above this throttle input( usually 0, for "open pipe" exhaust about 250) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) @@ -51,23 +51,23 @@ uint16_t knockStartRpm = 100; // starting @ this RPM (about 50 - 400) #include "sounds/Saurer2DMknock.h" // Saurer 2DM // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 150; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 10; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -77,7 +77,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -91,7 +91,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -101,7 +101,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 140; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 28; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -111,13 +111,13 @@ volatile int brakeVolumePercentage = 140; // Adjust the brake volume (usually = #include "sounds/Saurer2DMbrake.h" // // Saurer 2DM air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 130; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 26; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound #include "sounds/Saurer2DMparkingBrake.h" // // Saurer 2DM air parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -131,18 +131,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/Scania143.h b/src/vehicles/Scania143.h index 7371dd8..9d578ab 100644 --- a/src/vehicles/Scania143.h +++ b/src/vehicles/Scania143.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) #include "sounds/Scania143start4.h" // SCANIA V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/Scania143idle2.h" // SCANIA 143 V8 @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 150; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -37,7 +37,7 @@ volatile int jakeBrakeMinRpm = 250; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -47,24 +47,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 10; // Adjust the Diesel knoc #include "sounds/Scania143knock.h" // SCANIA 143 V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 40; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 8; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 150; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/1000HpScaniaV8wastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -88,7 +88,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -98,7 +98,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -107,12 +107,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -126,18 +126,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/ScaniaV8.h b/src/vehicles/ScaniaV8.h index 22c9211..ac26ff4 100644 --- a/src/vehicles/ScaniaV8.h +++ b/src/vehicles/ScaniaV8.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) //#include "sounds/ScaniaV850tonStart.h" // SCANIA V8 #include "sounds/ScaniaV8start.h" // SCANIA V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/ScaniaV8idle.h" // SCANIA V8 @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -40,7 +40,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -51,24 +51,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/ScaniaV8knock.h" // SCANIA V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 40; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 8; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 100; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 20; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/1000HpScaniaV8wastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -78,7 +78,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -92,7 +92,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 #include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -102,7 +102,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -111,12 +111,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -131,18 +131,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/Pigs.h" // pig transporter for Onkel_Tom ;-) // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/ScaniaV8Firetruck.h b/src/vehicles/ScaniaV8Firetruck.h index 6b48da9..62ed39b 100644 --- a/src/vehicles/ScaniaV8Firetruck.h +++ b/src/vehicles/ScaniaV8Firetruck.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) //#include "sounds/ScaniaV850tonStart.h" // SCANIA V8 #include "sounds/ScaniaV8start.h" // SCANIA V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/ScaniaV8idle.h" // SCANIA V8 @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 50; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -40,7 +40,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -51,24 +51,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/ScaniaV8knock.h" // SCANIA V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 40; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 8; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 100; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 20; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/1000HpScaniaV8wastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -78,7 +78,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -92,7 +92,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 #include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -102,7 +102,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -111,12 +111,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -130,18 +130,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/ScaniaV8_50ton.h b/src/vehicles/ScaniaV8_50ton.h index 1e18af6..500dad5 100644 --- a/src/vehicles/ScaniaV8_50ton.h +++ b/src/vehicles/ScaniaV8_50ton.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) #include "sounds/ScaniaV850tonStart.h" // SCANIA V8 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 130; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 104; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/ScaniaV850tonIdle3.h" // SCANIA V8 @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 130; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 104; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -46,25 +46,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/ScaniaV850tonKnock.h" // SCANIA V8 // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -88,7 +88,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 #include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -98,7 +98,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -107,12 +107,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -126,18 +126,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/Tatra813.h b/src/vehicles/Tatra813.h index 39867f1..41f1a2e 100644 --- a/src/vehicles/Tatra813.h +++ b/src/vehicles/Tatra813.h @@ -4,7 +4,7 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) //#include "sounds/UnionPacific2002start.h" // Union Pacific 2002 SD70M Locomotive Start #include "sounds/ScaniaV8start.h" // Scania V8 Start //#include "sounds/ScaniaR500V8Start.h" // Scania R500 V8 Start @@ -25,14 +25,14 @@ volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 1 //#include "sounds/carCranking.h" // Generic car cranking // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 64; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/Tatra813Idle.h" // Tatra 813 8x8 air cooled V12 Diesel (Volume 80%, 50%, Turbo 0%, 0, Fan 250, 0, 250, No Wastegate, CEP 100, TSM 2, Knock volume 500, 0%, interval 2, 50) // Choose the motor revving sound (uncomment the one you want) -------- //#define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 150; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 30; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 250; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -52,7 +52,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 500; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 100; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 2; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 50; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -65,25 +65,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc //#include "sounds/Tatra813RoarShort.h" // Tatra 813 8x8 air cooled V12 Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 250; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 50; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 250; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -92,7 +92,7 @@ volatile int fanStartPoint = 250; // Volume will raise above this point (250 for //#include "sounds/Tatra813FanNewSlow.h" // Tatra 813 8x8 V12 Diesel Cooling Fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -104,7 +104,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -114,7 +114,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -122,12 +122,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = #include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -141,18 +141,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 50; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 10; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/Tatra813new.h b/src/vehicles/Tatra813new.h index 13f4c37..53a1013 100644 --- a/src/vehicles/Tatra813new.h +++ b/src/vehicles/Tatra813new.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 160; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 128; // Adjust the start volume (usually = 80%) #include "sounds/Tatra813start.h" // Tatra 813 8x8 air cooled V12 Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/Tatra813Idle.h" // Tatra 813 8x8 air cooled V12 Diesel @@ -19,7 +19,7 @@ volatile int fullThrottleVolumePercentage = 150; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 0; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -43,7 +43,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 12; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 50; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -57,25 +57,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc //#include "sounds/Tatra813knock4.h" // Tatra 813 8x8 air cooled V12 Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 150; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 30; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 10; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 300; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -84,7 +84,7 @@ volatile int fanStartPoint = 300; // Volume will raise above this point (250 for //#include "sounds/Tatra813FanNewSlow.h" // Tatra 813 8x8 V12 Diesel Cooling Fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 180; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 144; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -98,7 +98,7 @@ volatile int hornVolumePercentage = 180; // Adjust the horn volume (usually = 10 //#include "sounds/MackSuperLinerHorn.h" // MACK Super Liner horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -108,7 +108,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -117,12 +117,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -136,18 +136,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/URAL375.h b/src/vehicles/URAL375.h index 5fcfb63..6c7d976 100644 --- a/src/vehicles/URAL375.h +++ b/src/vehicles/URAL375.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) #include "sounds/Ural375Dstart2.h" // Ural 375D //#include "sounds/Урал375start.h" // Ural 375D // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 55; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) 50 volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/URAL375idle.h" // Ural 375D @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 150; // Adjust the idle volume (usually = 100%, more also working, depending on sound) 150 +volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 80%, more also working, depending on sound) 120 volatile int engineRevVolumePercentage = 55; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) 50 volatile const uint16_t revSwitchPoint = 150; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -38,7 +38,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 300; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 60; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -48,25 +48,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/URAL375knock.h" // Ural 375D // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) 40 +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) 8 volatile int fanIdleVolumePercentage = 10; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -76,7 +76,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -89,7 +89,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/CaboverCAThorn.h" // Cabover wit CAT engine horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -99,7 +99,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -108,12 +108,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = #include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -127,18 +127,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually //#include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/US_Firetruck.h b/src/vehicles/US_Firetruck.h index 1e59ad1..44a3df3 100644 --- a/src/vehicles/US_Firetruck.h +++ b/src/vehicles/US_Firetruck.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/Cat3408Start.h" // CAT 3408 V8 Diesel start (Kenworth W900A) // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/3408CatIdle.h" // CAT 3408 V8 Diesel idle (Kenworth W900A) @@ -16,7 +16,7 @@ volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 10; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -40,7 +40,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 4; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -54,26 +54,26 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc //#include "sounds/straightPipedCompilationKnock.h" // Straight piped V8 knock // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 80; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 16; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) //#include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! #include "sounds/SuperchargerDummy.h" // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 200; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 40; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above @@ -84,7 +84,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/FanDummy.h" // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 130; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 104; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -98,7 +98,7 @@ volatile int hornVolumePercentage = 130; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 104; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren #include "sounds/FireTruckAirSiren2.h" // US fire truck (incl. loop) @@ -108,7 +108,7 @@ volatile int sirenVolumePercentage = 130; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -118,12 +118,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -137,18 +137,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/UnimogU1000.h b/src/vehicles/UnimogU1000.h index 49797b9..ad87099 100644 --- a/src/vehicles/UnimogU1000.h +++ b/src/vehicles/UnimogU1000.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 180; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 144; // Adjust the start volume (usually = 80%) //#include "sounds/UnimogU1000Start.h" // Unimog U1000 Turbo #include "sounds/UnimogU1000Start2.h" // Unimog U1000 Turbo // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 35; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/UnimogU1000TurboFullLoad.h" // Unimog U1000 Turbo (Volume 100%, 35%, Turbo 50%, 10%, Wastegate 150%, 1%) @@ -19,7 +19,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 75; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 30; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -41,7 +41,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 0; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -52,25 +52,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 65; // Adjust the Diesel knoc #include "sounds/UnimogU1000TurboKnock2.h" // Unimog U1000 Turbo // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 50; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 10; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 10; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 150; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -80,7 +80,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -92,7 +92,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) //#include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -102,7 +102,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -111,12 +111,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -131,18 +131,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/UnimogU1000Door.h" // Unimog U1000 Turbo // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/UnionPacific2002.h b/src/vehicles/UnionPacific2002.h index 2184b33..d9baa46 100644 --- a/src/vehicles/UnionPacific2002.h +++ b/src/vehicles/UnionPacific2002.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 160; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 128; // Adjust the start volume (usually = 80%) #include "sounds/UnionPacific2002start.h" // Union Pacific 2002 SD70M Locomotive Start // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/20Hz.h" // 20Hz test tone @@ -18,7 +18,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -38,7 +38,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 100; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 20; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 16; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -49,26 +49,26 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/UnionPacific2002knock.h" // Union Pacific 2002 SD70M Locomotive with 16 cylinder Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 15; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 3; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 100; // the turbo volume will be engine rpm dependent (usually = 10%) //#include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! #include "sounds/UnionPacific2002turbo.h" // Union Pacific 2002 SD70M Locomotive with 16 cylinder Diesel // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 90; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 18; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -78,7 +78,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 80%) #include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -93,7 +93,7 @@ volatile int hornVolumePercentage = 200; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -103,7 +103,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -113,12 +113,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -132,11 +132,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually //#include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 0; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/Ural375D.h b/src/vehicles/Ural375D.h index 7a2f803..f2ce827 100644 --- a/src/vehicles/Ural375D.h +++ b/src/vehicles/Ural375D.h @@ -4,12 +4,12 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 140; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 112; // Adjust the start volume (usually = 80%) //#include "sounds/Ural375Dstart.h" // Ural 375D #include "sounds/Ural375Dstart2.h" // Ural 375D // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/Ural375Didle.h" // Ural 375D @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 130; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 150; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -37,7 +37,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 120; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 24; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -47,25 +47,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/Ural375Dknock.h" // Ural 375D // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -75,7 +75,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -88,7 +88,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/CaboverCAThorn.h" // Cabover wit CAT engine horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -98,7 +98,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -107,12 +107,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = #include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -126,18 +126,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually //#include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/Ural4320.h b/src/vehicles/Ural4320.h index e628e9a..442c558 100644 --- a/src/vehicles/Ural4320.h +++ b/src/vehicles/Ural4320.h @@ -4,7 +4,7 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 72; // Adjust the start volume (usually = 80%) //#include "sounds/UnionPacific2002start.h" // Union Pacific 2002 SD70M Locomotive Start //#include "sounds/ScaniaV8start.h" // Scania V8 Start //#include "sounds/ScaniaR500V8Start.h" // Scania R500 V8 Start @@ -25,7 +25,7 @@ volatile int startVolumePercentage = 90; // Adjust the start volume (usually = 1 //#include "sounds/carCranking.h" // Generic car cranking // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 120; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 96; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 40; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/Ural4320Idle.h" // URAL 4320 V8 Diesel @@ -33,7 +33,7 @@ volatile int fullThrottleVolumePercentage = 160; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 40; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 80; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -54,7 +54,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 200; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 40; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 8; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 50; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -65,25 +65,25 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/Ural4320knock3.h" // URAL 4320 V8 Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 10; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/UnimogU1000TurboWastegate.h" //#include "sounds/ScaniaR730V8TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 300; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -92,7 +92,7 @@ volatile int fanStartPoint = 300; // Volume will raise above this point (250 for //#include "sounds/Tatra813FanNewSlow.h" // Tatra 813 8x8 V12 Diesel Cooling Fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -106,7 +106,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/MackSuperLinerHorn.h" // MACK Super Liner horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -116,7 +116,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -125,12 +125,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = #include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 200; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 40; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -144,18 +144,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually //#include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/VolvoFH16_750.h b/src/vehicles/VolvoFH16_750.h index e6e7665..a55f4f6 100644 --- a/src/vehicles/VolvoFH16_750.h +++ b/src/vehicles/VolvoFH16_750.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 130; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 104; // Adjust the start volume (usually = 80%) #include "sounds/Actros1863start.h" // Actros 1863 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/FH16_750idle.h" // Volvo FH16 750 // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -38,7 +38,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 280; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 56; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 10; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -50,24 +50,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 30; // Adjust the Diesel knoc #include "sounds/FH16_750knock2.h" // Volvo FH16 750 (more bass) // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 70; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 14; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 120; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 24; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -77,7 +77,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 170; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 136; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -91,7 +91,7 @@ volatile int hornVolumePercentage = 170; // Adjust the horn volume (usually = 10 #include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -101,7 +101,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -110,12 +110,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -129,18 +129,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/VolvoFH16_OpenPipe.h b/src/vehicles/VolvoFH16_OpenPipe.h index 10f1d04..2f1b01f 100644 --- a/src/vehicles/VolvoFH16_OpenPipe.h +++ b/src/vehicles/VolvoFH16_OpenPipe.h @@ -5,18 +5,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 130; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 104; // Adjust the start volume (usually = 80%) #include "sounds/Actros1863start.h" // Actros 1863 // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 140; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/VOLVO_FH_open_pipeIdle.h" // Volvo FH // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 100; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 80; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 50; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 100; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 400; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -38,7 +38,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 280; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 56; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 10; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (1 - 20, depending on sound files) volatile int dieselKnockStartPoint = 110; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -49,24 +49,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/VOLVO_FH_open_pipeKnock.h" // Volvo FH // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 40; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 8; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 120; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 24; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch //#include "sounds/WastegateDummy.h" #include "sounds/UnimogU1000TurboWastegate.h" // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -76,7 +76,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 170; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 136; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -90,7 +90,7 @@ volatile int hornVolumePercentage = 170; // Adjust the horn volume (usually = 10 #include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -100,7 +100,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -109,12 +109,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) //#include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound #include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -128,18 +128,18 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 70; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 14; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound // Choose the trailer couplig & uncoupling sounds (uncomment the ones you want) -------- #define COUPLING_SOUND // uncomment this, if you want to use the trailer coupling & uncoupling sounds -volatile int couplingVolumePercentage = 100; // Adjust the volume (usually = 100%) +volatile int couplingVolumePercentage = 20; // Adjust the volume (usually = 20%) #ifdef COUPLING_SOUND #include "sounds/coupling.h" // coupling #include "sounds/uncoupling.h" // uncoupling diff --git a/src/vehicles/VwBeetle.h b/src/vehicles/VwBeetle.h index d891043..ed3d7fc 100644 --- a/src/vehicles/VwBeetle.h +++ b/src/vehicles/VwBeetle.h @@ -4,18 +4,18 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 70; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 56; // Adjust the start volume (usually = 80%) #include "sounds/VWBeetleStart.h" // VW Beetle / Käfer // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 80; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 170; // Volume Percentage while full throttle (for rev sound as well) #include "sounds/VWBeetleIdle.h" // VW Beetle / Käfer // Choose the motor revving sound (uncomment the one you want) -------- //#define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 70; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 56; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 80; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 280; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 300; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -36,7 +36,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 100; // Adjust the Diesel knock volume (usually = 200 - 600%) 50 +volatile int dieselKnockVolumePercentage = 20; // Adjust the Diesel knock volume (usually = 40 - 120%) 10 volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 4; // Idle sample length divided by this number (usually number of cylinders) volatile int dieselKnockStartPoint = 50; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -47,24 +47,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 50; // Adjust the Diesel knoc #include "sounds/VWBeetleKnock.h" // VW Beetle / Käfer // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 0; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/DefenderTd5wastegate.h" // Land Rover Defender Td5 5 cylinder Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 10; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 10; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 20; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -74,7 +74,7 @@ volatile int fanStartPoint = 20; // Volume will raise above this point (250 for #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 80; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -86,7 +86,7 @@ volatile int hornVolumePercentage = 100; // Adjust the horn volume (usually = 10 //#include "sounds/2ToneTruckHorn.h" // A 2 tone truck horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -96,7 +96,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -104,12 +104,12 @@ volatile int brakeVolumePercentage = 200; // Adjust the brake volume (usually = //#include "sounds/AirBrakeSqueak.h" // Squeaky air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 200; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 40; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) #include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound //#include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -120,11 +120,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound diff --git a/src/vehicles/generic6zylDiesel.h b/src/vehicles/generic6zylDiesel.h index e779610..70b9ee3 100644 --- a/src/vehicles/generic6zylDiesel.h +++ b/src/vehicles/generic6zylDiesel.h @@ -4,11 +4,11 @@ // Sound files (22'050 Hz, 8 bit PCM recommended) ----------------------------------------------------------------------- // Choose the start sound (uncomment the one you want) -------- -volatile int startVolumePercentage = 150; // Adjust the start volume (usually = 100%) +volatile int startVolumePercentage = 120; // Adjust the start volume (usually = 80%) #include "sounds/POWERSTROKEstart2.h" // Ford Powerstroke 7.3l V8 Diesel // Choose the motor idle sound (uncomment the one you want) -------- -volatile int idleVolumePercentage = 90; // Adjust the idle volume (usually = 100%, more also working, depending on sound, 50 - 60% if additional diesel knock sound is used) +volatile int idleVolumePercentage = 72; // Adjust the idle volume (usually = 80%, more also working, depending on sound, 40 - 48% if additional diesel knock sound is used) volatile int engineIdleVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full throttle (for rev sound as well) //#include "sounds/RAM2500_Cummins12Vidle.h" // Cummins R6 12V 5.9l Diesel @@ -17,7 +17,7 @@ volatile int fullThrottleVolumePercentage = 180; // Volume Percentage while full // Choose the motor revving sound (uncomment the one you want) -------- #define REV_SOUND // uncomment this, if you want to use the separate, optional rev sound -volatile int revVolumePercentage = 110; // Adjust the idle volume (usually = 100%, more also working, depending on sound) +volatile int revVolumePercentage = 88; // Adjust the idle volume (usually = 80%, more also working, depending on sound) volatile int engineRevVolumePercentage = 60; // the engine volume will be throttle dependent (usually = 40%, never more than 100%!) volatile const uint16_t revSwitchPoint = 20; // The rev sound is played instead of the idle sound above this point volatile const uint16_t idleEndPoint = 500; // above this point, we have 100% rev and 0% idle sound volume (usually 500, min. 50 more than revSwitchPoint) @@ -39,7 +39,7 @@ volatile int jakeBrakeMinRpm = 200; // Adjust the min. RPM for the jake brake (a // Choose the Diesel (or whatever) ignition "knock" sound (played in the fixed sampling rate interrupt, uncomment the one you want, // play around here, the results are amazing, if you hit the right combination with the idle sound!) -------- -volatile int dieselKnockVolumePercentage = 260; // Adjust the Diesel knock volume (usually = 200 - 600%) +volatile int dieselKnockVolumePercentage = 52; // Adjust the Diesel knock volume (usually = 40 - 120%) volatile int dieselKnockIdleVolumePercentage = 0; // Diesel knock volume while idling (usually = 20%) volatile int dieselKnockInterval = 6; // Idle sample length divided by this number (number of peaks per engine cycle in idle.h) volatile int dieselKnockStartPoint = 10; // Volume will raise above this point ( usually 0, for "open pipe" exhaust about 250) @@ -51,24 +51,24 @@ volatile int dieselKnockAdaptiveVolumePercentage = 80; // Adjust the Diesel knoc #include "sounds/RAM2500_Cummins12Vknock2.h" // Cummins R6 12V 5.9l Diesel // Adjust the additional turbo sound (set "turboVolumePercentage" to "0", if you don't want it) -------- -volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 70%) +volatile int turboVolumePercentage = 0; // Adjust the turbo volume (usually = 14%) volatile int turboIdleVolumePercentage = 0; // the turbo volume will be engine rpm dependent (usually = 10%) #include "sounds/TurboWhistle.h" // Turbo sound, playing in parallel with engine sound! // Adjust the additional supercharger sound (set "chargerVolumePercentage" to "0", if you don't want it) -------- -volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 70%) +volatile int chargerVolumePercentage = 0; // Adjust the supercharger volume (usually = 14%) volatile int chargerIdleVolumePercentage = 10; // the supercharger volume will be engine rpm dependent (usually = 10%) volatile int chargerStartPoint = 10; // Volume will raise above this point ( usually 10) #include "sounds/supercharger.h" // supercharger sound, playing in parallel with engine sound! // Adjust the additional turbo wastegate / blowoff valve sound (set "wastegateVolumePercentage" to "0", if you don't want it)-------- -volatile int wastegateVolumePercentage = 30; // Adjust the wastegate volume (usually = 70%, up to 250%) +volatile int wastegateVolumePercentage = 6; // Adjust the wastegate volume (usually = 14%, up to 50%) volatile int wastegateIdleVolumePercentage = 1; // Wastegate sound is played, after rapid throttle drop with engaged clutch #include "sounds/WastegateDummy.h" //#include "sounds/POWERSTROKEwastegate.h" // Ford Powerstroke 7.3l V8 Diesel // Adjust the additional cooling fan sound (set "fanVolumePercentage" to "0", if you don't want it) -------- -volatile int fanVolumePercentage = 0; // Adjust the fan volume (250% for Tatra 813, else 0%) +volatile int fanVolumePercentage = 0; // Adjust the fan volume (50% for Tatra 813, else 0%) volatile int fanIdleVolumePercentage = 0; // the fan volume will be engine rpm dependent (usually = 10%) volatile int fanStartPoint = 0; // Volume will raise above this point (250 for Tatra 813) //#define GEARBOX_WHINING // Disables sound, if gearbox in neutral. Fan noise is used to simulate gearbox whining (set fanStartPoint above clutchEngagingPoint) @@ -78,7 +78,7 @@ volatile int fanStartPoint = 0; // Volume will raise above this point (250 for T #include "sounds/GenericFan.h" // Generic engine cooling fan // Choose the horn sound (uncomment the one you want) -------- -volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 100%) +volatile int hornVolumePercentage = 128; // Adjust the horn volume (usually = 80%) //#include "sounds/TrainHorn.h" // American train horn //#include "sounds/HornblastersOUTLAWTrainHornShort.h" // Hornblasters outlaw train horn short //#include "sounds/ManTgeHorn.h" // MAN TGE truck horn (King Hauler) @@ -93,7 +93,7 @@ volatile int hornVolumePercentage = 160; // Adjust the horn volume (usually = 10 //#include "sounds/ScaniaV8trainHorn.h" // Scania with train horn // Choose the siren / additional horn sound (uncomment the one you want) -------- -volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = 100%) +volatile int sirenVolumePercentage = 80; // Adjust the siren volume (usually = 80%) #include "sounds/sirenDummy.h" // If you don't want siren sound //#include "sounds/UsPoliceSiren.h" // US Police siren //#include "sounds/FireTruckAirSiren.h" // US fire truck air siren (King Hauler) @@ -103,7 +103,7 @@ volatile int sirenVolumePercentage = 100; // Adjust the siren volume (usually = //#include "sounds/PostAutoHorn.h" // The typical Swiss post bus horn // Choose the air brake release sound (uncomment the one you want) -------- -volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int brakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/AirBrakeDummy.h" // If you don't want air brake sound //#include "sounds/TruckAirBrakes.h" // Short truck air brake sound //#include "sounds/TruckAirBrakesLong.h" // Long truck air brake sound @@ -113,12 +113,12 @@ volatile int brakeVolumePercentage = 150; // Adjust the brake volume (usually = //#include "sounds/UralBrakeSqueak.h" // URAL 4320 air brake sound // Choose the parking brake engaging sound (uncomment the one you want) -------- -volatile int parkingBrakeVolumePercentage = 150; // Adjust the brake volume (usually = 200%) +volatile int parkingBrakeVolumePercentage = 30; // Adjust the brake volume (usually = 40%) #include "sounds/ParkingBrakeDummy.h" // If you don't want parking brake sound //#include "sounds/ParkingBrake.h" // Parking brake sound // Choose the gear shifting sound (uncomment the one you want) -------- -volatile int shiftingVolumePercentage = 100; // Adjust the shifting volume (usually = 200%) +volatile int shiftingVolumePercentage = 20; // Adjust the shifting volume (usually = 40%) //#include "sounds/AirShiftingDummy.h" // If you don't want pneumatic shifting sound //#include "sounds/AirShifting.h" // Pneumatic shifting sound #include "sounds/ClunkingGearShifting.h" // Manual clunking shifting sound @@ -132,11 +132,11 @@ volatile int sound1VolumePercentage = 100; // Adjust the sound1 volume (usually #include "sounds/door.h" // opening and closing the door // Choose the reversing beep sound -------- -volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 70%) +volatile int reversingVolumePercentage = 0; // Adjust the reversing sound volume (usually = 14%) #include "sounds/TruckReversingBeep.h" // 1000Hz peep sound // Choose the indicator / turn signal options -------- -volatile int indicatorVolumePercentage = 100; // Adjust the indicator sound volume (usually = 100%) +volatile int indicatorVolumePercentage = 10; // Adjust the indicator sound volume (usually = 10%) const uint16_t indicatorOn = 300; // The indicator will be switched on above +/- this value, if wheels are turned const boolean INDICATOR_DIR = true; // adjust indicator direction with true or false #include "sounds/Indicator.h" // "Tick-Tack" sound From 202cebe4e028bc2bf27902af3638d0eec4286088 Mon Sep 17 00:00:00 2001 From: Ralf Engels Date: Wed, 6 Sep 2023 18:28:56 +0200 Subject: [PATCH 5/6] Fix sample end logic --- src/src.ino | 65 ++++++++++------------------------------------------- 1 file changed, 12 insertions(+), 53 deletions(-) diff --git a/src/src.ino b/src/src.ino index 4cd3d7e..c3378cb 100644 --- a/src/src.ino +++ b/src/src.ino @@ -936,7 +936,7 @@ void IRAM_ATTR fixedPlaybackTimer() soundVal += (sirenSamples[curSirenSample] * sirenVolumePercentage / 100); curSirenSample++; #ifdef SIREN_LOOP // Optional "endless loop" (points to be defined manually in siren file) - if (sirenTrigger && curSirenSample == sirenLoopEnd) + if (sirenTrigger && curSirenSample >= sirenLoopEnd) curSirenSample = sirenLoopBegin; // Loop, if trigger still present #endif } @@ -947,15 +947,11 @@ void IRAM_ATTR fixedPlaybackTimer() // other sounds ********************************************* - if (curSound1Sample < sound1SampleCount) - { - curSound1Sample = 0; // ensure, next sound will start @ first sample - } if (sound1trigger) { soundVal += (sound1Samples[curSound1Sample] * sound1VolumePercentage / 100); curSound1Sample++; - if (curSound1Sample == sound1SampleCount) + if (curSound1Sample >= sound1SampleCount) { sound1trigger = false; curSound1Sample = 0; // ensure, next sound will start @ first sample @@ -979,15 +975,11 @@ void IRAM_ATTR fixedPlaybackTimer() // Indicator tick sound ------------------------------------------ #if not defined NO_INDICATOR_SOUND - if (curIndicatorSample >= indicatorSampleCount) - { - curIndicatorSample = 0; - } if (indicatorSoundOn) { soundVal += (indicatorSamples[curIndicatorSample] * indicatorVolumePercentage / 100); curIndicatorSample++; - if (curIndicatorSample == indicatorSampleCount) + if (curIndicatorSample >= indicatorSampleCount) { indicatorSoundOn = false; curIndicatorSample = 0; // ensure, next sound will start @ first sample @@ -996,15 +988,11 @@ void IRAM_ATTR fixedPlaybackTimer() #endif // Wastegate (blowoff) sound, triggered after rapid throttle drop ----------------------------------- - if (curWastegateSample >= wastegateSampleCount) - { - curWastegateSample = 0; - } if (wastegateTrigger) { soundVal += (wastegateSamples[curWastegateSample] * rpmDependentWastegateVolume / 100 * wastegateVolumePercentage / 100); curWastegateSample++; - if (curWastegateSample == wastegateSampleCount) + if (curWastegateSample >= wastegateSampleCount) { wastegateTrigger = false; curWastegateSample = 0; // ensure, next sound will start @ first sample @@ -1012,15 +1000,11 @@ void IRAM_ATTR fixedPlaybackTimer() } // Air brake release sound, triggered after stop ----------------------------------------------- - if (curBrakeSample >= brakeSampleCount) - { - curBrakeSample = 0; - } if (airBrakeTrigger) { soundVal += (brakeSamples[curBrakeSample] * brakeVolumePercentage / 100); curBrakeSample++; - if (curBrakeSample == brakeSampleCount) + if (curBrakeSample >= brakeSampleCount) { airBrakeTrigger = false; curBrakeSample = 0; // ensure, next sound will start @ first sample @@ -1028,15 +1012,11 @@ void IRAM_ATTR fixedPlaybackTimer() } // Air parking brake attaching sound, triggered after engine off -------------------------------- - if (curParkingBrakeSample >= parkingBrakeSampleCount) - { - curParkingBrakeSample = 0; - } if (parkingBrakeTrigger) { soundVal += (parkingBrakeSamples[curParkingBrakeSample] * parkingBrakeVolumePercentage / 100); curParkingBrakeSample++; - if (curParkingBrakeSample == parkingBrakeSampleCount) + if (curParkingBrakeSample >= parkingBrakeSampleCount) { parkingBrakeTrigger = false; curParkingBrakeSample = 0; // ensure, next sound will start @ first sample @@ -1044,15 +1024,11 @@ void IRAM_ATTR fixedPlaybackTimer() } // Pneumatic gear shifting sound, triggered while shifting the TAMIYA 3 speed transmission ------ - if (curShiftingSample >= shiftingSampleCount) - { - curShiftingSample = 0; - } if (shiftingTrigger && engineRunning && !automatic && !doubleClutch) { soundVal = (shiftingSamples[curShiftingSample] * shiftingVolumePercentage / 100); curShiftingSample++; - if (curShiftingSample == shiftingSampleCount) + if (curShiftingSample >= shiftingSampleCount) { shiftingTrigger = false; curShiftingSample = 0; // ensure, next sound will start @ first sample @@ -1150,15 +1126,11 @@ void IRAM_ATTR fixedPlaybackTimer() #if not defined EXCAVATOR_MODE // Trailer coupling sound, triggered by switch ----------------------------------------------- #ifdef COUPLING_SOUND - if (curCouplingSample >= couplingSampleCount) - { - curCouplingSample = 0; - } if (couplingTrigger) { soundVal += (couplingSamples[curCouplingSample] * couplingVolumePercentage / 100); curCouplingSample++; - if (curCouplingSample == couplingSampleCount) + if (curCouplingSample >= couplingSampleCount) { couplingTrigger = false; curCouplingSample = 0; // ensure, next sound will start @ first sample @@ -1166,15 +1138,11 @@ void IRAM_ATTR fixedPlaybackTimer() } // Trailer uncoupling sound, triggered by switch ----------------------------------------------- - if (curUncouplingSample >= uncouplingSampleCount) - { - curUncouplingSample = 0; - } if (uncouplingTrigger) { soundVal += (uncouplingSamples[curUncouplingSample] * couplingVolumePercentage / 100); curUncouplingSample++; - if (curUncouplingSample == uncouplingSampleCount) + if (curUncouplingSample >= uncouplingSampleCount) { uncouplingTrigger = false; curUncouplingSample = 0; @@ -1204,15 +1172,11 @@ void IRAM_ATTR fixedPlaybackTimer() curTrackRattleSample++; // Bucket rattle sound ----------------------- - if (curBucketRattleSample >= bucketRattleSampleCount) - { - curBucketRattleSample = 0; - } if (bucketRattleTrigger) { soundVal += (bucketRattleSamples[curBucketRattleSample] * bucketRattleVolumePercentage / 100); curBucketRattleSample++; - if (curBucketRattleSample == bucketRattleSampleCount) + if (curBucketRattleSample >= bucketRattleSampleCount) { bucketRattleTrigger = false; curBucketRattleSample = 0; // ensure, next sound will start @ first sample @@ -1234,15 +1198,11 @@ void IRAM_ATTR fixedPlaybackTimer() #if defined BATTERY_PROTECTION // Out of fuel sound, triggered by battery voltage ----------------------------------------------- - if (curOutOfFuelSample >= outOfFuelSampleCount) - { - curOutOfFuelSample = 0; - } if (outOfFuelMessageTrigger) { soundVal += (outOfFuelSamples[curOutOfFuelSample] * outOfFuelVolumePercentage / 100); curOutOfFuelSample++; - if (curOutOfFuelSample == outOfFuelSampleCount) + if (curOutOfFuelSample >= outOfFuelSampleCount) { outOfFuelMessageTrigger = false; curOutOfFuelSample = 0; // ensure, next sound will start @ first sample @@ -1250,7 +1210,6 @@ void IRAM_ATTR fixedPlaybackTimer() } #endif - uint8_t value = constrain(soundVal * masterVolume / 100 + dacOffset, 0, 255); SET_PERI_REG_BITS(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_DAC, value, RTC_IO_PDAC2_DAC_S); @@ -4004,7 +3963,7 @@ int8_t escPulse() } // If you connect your ESC to pin 33, the vehicle inertia is simulated. Direct brake (crawler) ESC required -// *** WARNING!! Do it at your own risk!! There is a falisafe function in case, the signal input from the +// *** WARNING!! Do it at your own risk!! There is a failsafe function in case, the signal input from the // receiver is lost, but if the ESP32 crashes, the vehicle could get out of control!! *** void esc() From e9117e896b841b74320e19043b9c8fcb5cadb5b8 Mon Sep 17 00:00:00 2001 From: Ralf Engels Date: Wed, 13 Sep 2023 14:49:25 +0200 Subject: [PATCH 6/6] Fix knock volume --- src/src.ino | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/src.ino b/src/src.ino index c3378cb..3d4a944 100644 --- a/src/src.ino +++ b/src/src.ino @@ -1118,8 +1118,8 @@ void IRAM_ATTR fixedPlaybackTimer() if (knockMedium) dieselVolume *= dieselKnockAdaptiveVolumePercentage / 75; - soundVal += knockSamples[curDieselKnockSample] * - dieselVolume / (100 * 100); + soundVal += (knockSamples[curDieselKnockSample] * + dieselVolume) / (100 * 100 * 100); curDieselKnockSample++; }