Jump to content

Jens

Members
  • Posts

    706
  • Joined

  • Last visited

  • Days Won

    3

Posts posted by Jens

  1. On 08/05/2021 at 12:53, DavidBH said:

    Thanks guys as always. So I presume these wheels will not ballon the same way the stock ones do? The lagging you put in do you glue that together or just fill the inside of the tyres. As they are bigger and if I do not change the gearing am I right in saying that will mean less acceleration but a higher top speed as same number of revolutions of the motor will mean same number of revolutions of the tyre but because of the increased circumference it will go further hence faster but slower acceleration?

     

    That would actually be good as we feed the throttle in it constantly wheelies anyway! Sons 10th birthday on 26th May so spot on timing. Will nip to B&Q and see what sort of foam they have. Also 1 last thing what sort of glue do you use (CA is that contact adhesive?)

     

    David

    Not as much.

    Here 2 old pics to compare.

    One with the pipe lagging , one with the original insert:

    IMG-4985.jpgIMG-4986.jpg

     

    You might want to gear down, since the wheels are even bigger than the Bugsta ones.

    Unless you want speed and stay on road.

     

    See that you get closed cell foam from B&Q. they don't soak with water.

    And the version that is not open on one side.

    Bad: https://www.ebay.co.uk/itm/223999193686?hash=item3427647256:g:oIsAAOSww41esEDG

    Good: https://www.ebay.co.uk/itm/273509911546?epid=22030367669&hash=item3fae760bfa:g:Z-MAAOSwLXNbxLm5

     

     

     

     

     

  2. On 08/05/2021 at 21:15, walkbythesea said:

    None so far.

    And I searched a long time for suitable wheels for the Carnage and Rustler.

    ( Apart from the blue alloy version, which I really do not recommend )

     

  3. 8 hours ago, DavidBH said:

    someone here mentioned these https://www.ebay.co.uk/itm/154220196248?ssPageName=STRK%3AMEBIDX%3AIT&_trksid=p2060353.m1438.l2649 but it does mention they are soft.

    I was the one mentioning it. :-)

    Those wheels are fantastic. I even use them now on my Rustler.

    But....

     

    The tire inserts are crap. The foam is just glued in a ring and if they get soaked the glue will likely dissolve.

    They are also too soft.

     

    I went to put in some pipe lagging made of closed cell foam.

    They are waterproof, not glued to a ring and quite a bit firmer.

    Firm enough for the wheels not to balloon anymore.

    Armaflex pipe lagging 76mm OD, 19mm thickness. 

    https://www.ebay.co.uk/itm/202623606704?ssPageName=STRK%3AMEBIDX%3AIT&_trksid=p2060353.m1438.l2649

     

     

    • Like 1
    • Thanks 1
  4. 1 minute ago, Jack Reacher said:

    Im finding this odd i run my vantage for speed runs up to 60+ MPH and no issues, have you got both little metal pins in the slipper assembly

    I think speed runs don't cause so much stress to the slipper clutch then bashing around with constant speed changes.

    Provided that you accelerate calmly to reach max speed.

     

    I think the slipper clutch goes faster if you are constantly accelerating and braking.

    For mine I never found the right level of tightening the screw. Ended up tightening at full.

    Anything less and the clutch was gone after a few runs.

     

    I remember a post here long ago that mentioned either full tight or constant pad replacement.

     

    Having tightened it full, I accepted the risk of other damages along the drive train....

     

    When I compare the power of my Carnage with the Hobbywing ESC to my Rustler, it's about the same.

    But then the Rustler uses aluminum pads that are much better than the Carnage ones.

     

    • Like 1
  5. Just now, Guns said:

    But you would never spend £100 on a Traxxas motor when you can get superior ones for a fraction of the price. In your situation, Id be selling the Velineon ESC, and buying a Max 10 SCT/3660 Combo for £116.

    No doubt, the Hobbywing might be superior.

    But not really a desired option for me.

    I want to keep the car in its original state.

    But that is just my personal preference.

     

  6. 15 hours ago, Guns said:

    With the price of a replacement (upgraded) motor so cheap, Im not sure its worth the hassle of repairing it. That said, if you want a challenge then crack on 🙂

    Well...

    A replacement Velineon motor still costs more than £100.

    But then I got a good deal for a used one for £50.

     

    Nevertheless, I thought of taking up the challenge and keep a spare motor.

    But when it came to balancing the rotor after putting on the Kevlar/Epoxy stuff I scrapped the idea.

  7. 1 minute ago, turok007 said:

    glue and cotton or floss   the issue will be gap between copper wires and whatever you use.   It's a bit like fitting a new ring to a fishing rod.  So take a look at a video of that to see the process

    Just digged out a really old forum thread from the never forgetting internet.

    https://www.rc-monster.com/forum/showthread.php?t=16781

     

    It needs to be wrapped with a really strong and thin thread. Something like Kevlar.

    And glued with something like a heat resistant epoxy.

     

    Then the rotor needs to be perfectly balanced.

    Too much for me. I don't have any reasonable means to balance a rotor to be able to run at 10000++ revs.

     

    At that point I decided to just keep the remaining parts as spares...

     

    At least I learned that I also need to spray some GT85 on the ball bearing on the shaft side after each water run.

     

  8. 9 minutes ago, turok007 said:

    It is used to keep everything in one piece.  So you will have to redo it  if poss

    Thanks. :good:

    Just found some pictures and more information about the motor and its rotor.

    You are right, the yellow stuff is originally wrapped all around, probably to keep the 4 magnets in place (as you say).

    And it's the rotor for a newer version of the motor.

    And that newer rotor is no more available as a spare part.

    For the older one it was part 3353.

     

    2 choices left.

    Garbage or find a way to rewrap the rotor.

    Since I am expecting a spare motor soon I want to try to repair the old one.

     

    How can I wrap the rotor?

    Or better, what material could I use?

    My guess is that I must be strong to keep the magnets in place (fabric) and it should be heat resistant.

     

  9. I am attempting to repair my Velineon motor that came out of my Traxxas Rustler VXL 4x4.

    Basically the ball bearing at the shaft side disintegrated.

     

    I know there is a rebuild kit (TRX3352) with all bushings and ball bearings.

    That, at least, would need to be ordered.

     

    But I am bit puzzled if the rotor also needs to be replaced.

    There is some partial yellow stuff around it and I don't know if that belongs there or not.

     

    IMG-5309.jpg

     

    IMG-5309-Copy.jpg

     

    For me it looks like it belonged there before and some parts have been ripped off when the motor was rotating unbalanced.

    Or it is some stuff that came into the motor and wrapped it self around the rotor.

     

    Any ideas?

    Replace the rotor or not?

     

     

     

  10. 5 hours ago, Scottyb said:

    I got the hobbywing max10 combo with 3300kv motor and this pinion and spur as recommended by @Jens https://www.ebay.co.uk/itm/FTX-Carnage-Bugsta-32DP-Hard-Steel-Spur-kit-/264098799917?var=0&mkevt=1&mkcid=1&mkrid=710-53481-19255-0&campid=5338268676&toolid=10044&customid=CjwKCAjwmv-DBhAMEiwA7xYrd0kz1qQYobg7z9Fe8jwloiIqlbFZc-rA-Vm3ZPrab8DlZ9R45WRimBoCsR8QAvD_BwE

    You'll need hardened steel pinions with that spur as it's savage, extremely well made and will rip straight through a normal one 😄

    Really happy with it now it's a little beast for what it is, I've not gps'd it but I'd say it does around 30mph on grass and probably 35 on road. Just using mine on gravel now and it's fantastic, you can change the punch setting on the hobbywing esc as well, I use 2 for what I'm doing with it, you'll need a wheelie bar for anything above that no matter what terrain you're using it on, it's great!

    I am happy your are having great fun with that setup.

    Looking back the past few weeks I think our Carnages/Bugstas/Vantages turned into real fun machines.

     

    No more hiding from the Traxxas', Arrma's & Losi's out there!!!

    ( Apart from the constant repairing  )

     

    That said, we haven't touched our cars since Easter.

    My Rustler's motor went bust and those Velineon ones cost as much as a Carnage 2.0 brushed.

    Luckily it's rebuild-able. Getting the parts though will take some time.

    And my son has no mood to bash alone.

     

    On top, my work doesn't allow much free time these days. It's getting really too much...

  11. On 18/04/2021 at 19:33, HanZie82 said:

    Oh man what an inspiration this is. This is  (besides different controls) the exact thing i wanted to do to my TRX4-Defender.

    I've already got most if not all the hardware, but im such a noob as it comes to coding. So i managed to copy and paste some together. (will share below if possible), i managed to be able to read the PWM inputs but thats about it).

    Also i've heavily modified the transmitter that came with it. (single 18650 cell for power. with night light, winch transmitter and the 4 channel transmitter built in. Can show pictures if need be.)

     

    Thank you for showing me howto start all this, as this leaves great potential on the table for some nice fancy light stuff. 😄
    Thanks again.

     

     

    My non completed code. (Yes i did copy some found in this topic 🙂 )

     

    
    
    //--------- Constants//
    //------ Input Pin Assignment//
    //--- Variable input//
    const int InSteering        = 2;
    const int InThrottle        = 4;
    const int InGearbox         = 7;
    //--- Binary input//
    const int InRemote1         = 10; //PWM
    const int InRemote2         = 11; //PWM
    const int InRemote3         = 12;
    const int InRemote4         = 13;
    //------ Output Pin Assignment//
    //--- Front//
    const int OutBumper         = 3;  //PWM
    const int OutHeadlights     = 5;  //PWM
    const int OutBlinkersLeft   = 15;
    const int OutBlinkersRight  = 16;
    const int OutDaylight       = 17;
    //--- Rear//
    const int OutRear           = 6;  //PWM
    const int OutReverse        = 19;
    const int OutFog            = 18;
    //--- Middle//
    const int OutWheel          = 14;
    const int OutLightbar       = 21;
    
    
    //--- Serial monitor output names for debug
    String S1 = "Throttle: ";
    String S2 = " - Steering: ";
    String S3 = " - Gearbox: ";
    
    
    
    //--- Input values PWM and reset them
    int long Steering     = 0;
    int long Throttle     = 0;
    int long Gearbox      = 0;
    
    //--- Timeout for Pulse-in
    unsigned long PulseTm  = 35000;
    
    
    void setup() {
      Serial.begin(9600);
    
    
    //-- Define Input Pins//
    pinMode(InRemote1   ,INPUT_PULLUP);
    pinMode(InRemote2   ,INPUT_PULLUP);
    pinMode(InRemote3   ,INPUT_PULLUP);
    pinMode(InRemote4   ,INPUT_PULLUP);
    pinMode(InSteering  ,INPUT);
    pinMode(InThrottle  ,INPUT);
    pinMode(InGearbox   ,INPUT);
    
     //-- Define Output Pins//
    pinMode(OutBumper         ,OUTPUT);
    pinMode(OutHeadlights     ,OUTPUT);
    pinMode(OutBlinkersLeft   ,OUTPUT);
    pinMode(OutBlinkersRight  ,OUTPUT);
    pinMode(OutDaylight       ,OUTPUT);
    pinMode(OutRear           ,OUTPUT);
    pinMode(OutReverse        ,OUTPUT);
    pinMode(OutFog            ,OUTPUT);
    pinMode(OutWheel          ,OUTPUT);
    pinMode(OutLightbar       ,OUTPUT);
    
    
    }
    
    void loop() {
      Steering  = pulseIn(InSteering  , HIGH, PulseTm);
      Throttle  = pulseIn(InThrottle  , HIGH, PulseTm);
      Gearbox   = pulseIn(InGearbox   , HIGH, PulseTm);
    
    
    //--- Print to serial monitor for debug
      Serial.print(S1 + Steering);
      Serial.print(S2 + Throttle);
      Serial.print(S3 + Gearbox);
      Serial.println();
    }

     

     

     

    I haven't had much time to progress on mine.

    These days, I spend too much time repairing either my son's Carnage or my Rustler.

    The programming is mostly done, but I am somewhat postponing all the wiring and soldering.

     

    I am not sure if I ever posted my complete program, but here we go.

     

    Don't forget to plant some easter eggs in your programming!

    An idea for you.

    Catch a sequence from your transmitter: Gear 1 to 2, diff locks on, diff locks off, gear 2 to 1.

    Then play a sequence of lights. 

    It's something eye catching.

     

    There are 2 pieces of code I am somewhat proud of.

    The initial ignition of the Xenon lamp. I could simulate the real flicker on. --> Function setHeadlightStart

    And the integration of a light sensor. It turns on the headlights only in the dark. :-) --> Function checkPhotoSensor

     

    I also integrated the ESS Dual sound module to create realistic engine sound.

     

    ( Indented code is fully completed and tested )

     

    #include <PinChangeInterrupt.h>
    #include <ServoInput.h>
    #include <Servo.h>
    
    //---------------- Constants
    
    //-- Input Pin Assignment
    const int pinSteering             = 11;
    const int pinThrottle             = 12;           
    const int pinTransmission         = 14;           // Analog A0
    const int pinDiffLockFront        = 15;           // Analog A1
    const int pinDiffLockRear         = 16;           // Analog A2
    const int pinRemoteButton1        = 17;           // Analog A3
    const int pinRemoteButton2        = 18;           // Analog A4
    const int pinRemoteButton3        = 19;           // Analog A5//
    const int pinRemoteButton4        = 20;           // Analog A6
    const int pinLightSensor          = 21;           // Analog A7
    
    //-- Output Pin Assignment
    const int pinFogLight             =  0;
    const int pinReverseLight         =  1;
    const int pinThirdBrakelight      =  2;
    const int pinHorn                 =  3;           // with PWM out
    const int pinDaytimeLights        =  4;
    const int pinHeadlight            =  5;           // with PWM out
    const int pinTaillight            =  6;           // with PWM out
    const int pinIndicatorRight       =  7;
    const int pinIndicatorLeft        =  8;
    const int pinLicensePlateLight    =  9;
    const int pinRooflightFront       = 10;
    const int pinRooflightRear        = 13;
    
    //-- Declaring the RC Receiver Channels
    ServoInputPin<pinSteering>      servoSteering;
    ServoInputPin<pinThrottle>      servoThrottle;
    ServoInputPin<pinTransmission>  servoTransmission;
    ServoInputPin<pinDiffLockFront> servoDiffLockFront;
    ServoInputPin<pinDiffLockRear>  servoDiffLockRear;
    //ServoInputPin<pinHorn>          ESSDual;
    Servo                             ESSDual;
    
    //-- PhotoSensor
    const int numPhotoSensorDelayOn   = 5;            // Time delay for the Light Sensor to turn off
    const int numPhotoSensorDelayOff  = 2;            // Time delay for the Light Sensor to turn on
    
    //-- Throttle
    const int numPWMThrottleForward   = 1550;         // 
    const int numPWMThrottleReverse   = 1450;         // 
    const int durIgnition             = 12;            // How long stays the ignition on
    
    //-- Steering
    const int numPWMSteeringLeftMin   = 1550;         // 
    const int numPWMSteeringRightMin  = 1450;         // 
    const int numPWMSteeringLeftMax   = 1950;         // 
    const int numPWMSteeringRightMax  = 1100;         // 
    
    //-- LED Brightness
    const int numBrightness000        = 0;            // LED off
    const int numBrightness010        = 25;           // LED at 10%
    const int numBrightness020        = 50;           // LED at 20%
    const int numBrightness025        = 62;           // LED at 25%
    const int numBrightness030        = 75;           // LED at 30%
    const int numBrightness035        = 87;           // LED at 35%
    const int numBrightness040        = 100;          // LED at 40%
    const int numBrightness045        = 112;          // LED at 45%
    const int numBrightness050        = 127;          // LED at 50%
    const int numBrightness100        = 255;          // LED at 100%
    
    //-- Indicator
    const float durIndicatorActivate  = 1;            // time to activate the indicator
    const float durIndicatorOn        = 0.2;          // duration indicator LED is on
    const float durIndicatorOff       = 0.3;          // duration indicator LED is off
    
    //-- Horn
    const float durHornSignalPWM      = 3;          // dur for the PWM Signal to the ESS Dual
    
    
    //-- Transmission
    
    //-- Diff Locks
    
    //-- Start Headlights
    const float HeadlightStage1       = 0.1;          // Headlight Start Stage 1: 100%
    const float HeadlightStage2       = 0.2;          // Headlight Start Stage 2: Off
    const float HeadlightStage3       = 0.4;          // Headlight Start Stage 3: 10%
    const float HeadlightStage4       = 0.6;          // Headlight Start Stage 4: 20%
    const float HeadlightStage5       = 0.8;          // Headlight Start Stage 5: 25%
    const float HeadlightStage6       = 1.0;          // Headlight Start Stage 6: 30%
    const float HeadlightStage7       = 1.2;          // Headlight Start Stage 7: 35%
    const float HeadlightStage8       = 1.4;          // Headlight Start Stage 8: 40%
    const float HeadlightStage9       = 1.6;          // Headlight Start Stage 9: 45%
    
    //-- ChristmasTree
    
    
    //---------------- Variables
    
    //-- Input Variables
    bool  isButton1Pressed;                   // Remote Control Button 1 Pressed
    bool  isButton1Released;                  // Remote Control Button 1 Released
    bool  isButton2Pressed;                   // Remote Control Button 2 Pressed
    bool  isButton2Released;                  // Remote Control Button 2 Released
    bool  isButton3Pressed;                   // Remote Control Button 3 Pressed
    bool  isButton3Released;                  // Remote Control Button 3 Released
    bool  isButton4Pressed;                   // Remote Control Button 4 Pressed
    bool  isButton4Released;                  // Remote Control Button 4 Released
    
    //-- State Variables
    bool  isIgnition;                         // "Ignition" is turned on. Throttle has been pulled and stays on for a time defined by durIgnition.
    bool  isCountdown;                        // Countdown to turn off ignition has started.
    bool  isDark;                             // set by the photosensitive sensor if the environment is dark
    bool  isForward;                          // Car is driving
    bool  isReverse;                          // Car is reversing
    bool  isStopping;                         // Car is Stopping
    bool  isHeadlightStart;                   // Turn on the Headlight and simulate a Xenon startup sequence
    bool  isHeadlightStarted;                 // Headlight Start Sequence completed
    bool  isHighBeamFlash;                    // Flash the Highbeam when Remote1 is pressed and headlights are off
    bool  isHighBeam;                         // Turn on/off Highbeam when Remote1 is pressed and headlights are on
    bool  isFullLeft;                         // Steering to Full Left
    bool  isFullRight;                        // Steering to Full Right
    bool  isIndicatorRight;                   // Indicator Right is On
    bool  isIndicatorLeft;                    // Indicator Left is On
    bool  stateIndicatorRightIsOn;            // state of Right Indicator LED
    bool  stateIndicatorLeftIsOn;             // state of Left Indicator LED
    bool  toggleGear;                         // Gear Change
    bool  isDiffLockFront;                    // Front Differentials locked
    bool  toggleDiffLockFront;                // Front Differentials changed
    bool  isDiffLockRear;                     // Rear Differentials locked
    bool  toggleDiffLockRear;                 // Rear Differentials changed
    
    
    bool  isHazardLight;                      // Turn on/off Hazard Lights when Remote2 is pressed
    bool  isFogLightOn;                       // Turn on/off Rear Fog Light and Headlights when Remote3 is pressed
    bool  isHorn;                             // Send one time signal to sound horn when Remote4 is pressed
    bool  isHornContinuous;                   // Sound Horn while Remote4 is pressed
    
    
    int   numCurrentGear;                     // current Gear
    unsigned long   timeLastNeutral;          // time the Throttle was last in neutral
    unsigned long   timeCountdown;            // countdown timer for Ignition off
    unsigned long   timeLightSensorDelayOn;   // delay timer to turn on the headlights after it is dark
    unsigned long   timeLightSensorDelayOff;  // delay timer to turn off the headlights after it is bright
    unsigned long   timerHeadlightStart;      // timer to start Headlights
    unsigned long   timeLastHeadlightStart;   // time of the last Headlight start process
    unsigned long   timerLeftIndBlink;        // timer to control the left indicator blinking
    unsigned long   timerRightIndBlink;       // timer to control the right indicator blinking
    unsigned long   timerHorn;                // timer for the duration of the horn
    
    
    
    //---------------- Setup section
    
    void  setup()
    {
    
      //-- Enabling Output
      Serial.begin(9600);
      delay(1000);
    
      //-- Set Variable Defaults
      isIgnition              = false;
      isCountdown             = false;
      isDark                  = false;
      isForward               = false;
      isReverse               = false;
      isStopping              = false;
      isHeadlightStart        = false;
      isHeadlightStarted      = false;
      isHighBeamFlash         = false;
      isHighBeam              = false;
      isFullLeft              = false;
      isFullRight             = false;
      isIndicatorRight        = false;
      isIndicatorLeft         = false;
      stateIndicatorRightIsOn = false;
      stateIndicatorLeftIsOn  = false;
      toggleGear              = false;
      isDiffLockFront         = false;
      toggleDiffLockFront     = false;
      isDiffLockRear          = false;
      toggleDiffLockRear      = false;
    
    
      isHazardLight           = false;
      isFogLightOn            = false;
      isHorn                  = false;
      isHornContinuous        = false;
    
      numCurrentGear          = 0;
      timeLastNeutral         = millis();
      timeCountdown           = 0;
      timeLightSensorDelayOn  = 0;
      timeLightSensorDelayOff = 0;
      timerHeadlightStart     = 0;
      timeLastHeadlightStart  = 0;
      timerLeftIndBlink       = 0;
      timerRightIndBlink      = 0;
    
      //-- Define Input Pins
      pinMode( pinSteering,           INPUT );    // Pin 11
      pinMode( pinThrottle,           INPUT );    // Pin 12
      pinMode( pinTransmission,       INPUT );    // Pin 14/A0
      pinMode( pinDiffLockFront,      INPUT );    // Pin 15/A1
      pinMode( pinDiffLockRear,       INPUT );    // Pin 16/A2
      pinMode( pinRemoteButton1,      INPUT );    // Pin 17/A3
      pinMode( pinRemoteButton2,      INPUT );    // Pin 18/A4
      pinMode( pinRemoteButton3,      INPUT );    // Pin 19/A5
      pinMode( pinRemoteButton4,      INPUT );    // Pin 20/A6
      pinMode( pinLightSensor,        INPUT );    // Pin 21/A7
    
      //-- Define Output Pins
      pinMode( pinFogLight,           OUTPUT );    // Pin 0
      pinMode( pinReverseLight,       OUTPUT );    // Pin 1
      pinMode( pinThirdBrakelight,    OUTPUT );    // Pin 2
      //pinMode( pinHorn,               OUTPUT );    // Pin 3
      pinMode( pinDaytimeLights,      OUTPUT );    // Pin 4
      pinMode( pinHeadlight,          OUTPUT );    // Pin 5
      pinMode( pinTaillight,          OUTPUT );    // Pin 6
      pinMode( pinIndicatorRight,     OUTPUT );    // Pin 7
      pinMode( pinIndicatorLeft,      OUTPUT );    // Pin 8
      pinMode( pinLicensePlateLight,  OUTPUT );    // Pin 9
      pinMode( pinRooflightFront,     OUTPUT );    // Pin 10
      pinMode( pinRooflightRear,      OUTPUT );    // Pin 13
    //  ESSDual.attach(pinHorn); 
    
    
    
    }
    
    
    //---------------- Loop Section
    void  loop()
    {
    //    Serial.println("Test");
    
    
    
      //-- Read Inputs
                        //  checkRemote1();
                        //  checkRemote2();
                        //  checkRemote3();
      checkRemote4();
                        //  checkPhotoSensor();
      checkThrottle();
      checkSteering();
                        //  checkGear();
                        //  checkDiff1();
                        //  checkDiff2();
    
      //-- Write Outputs
      setDaytimeLights();
                                                              //  setHeadlight();
                        //  setRooflightFront();
                                                              //  setHeadlightStart();
                                                              //  setTaillight();
                        //  setLicensePlateLight();
                        //  setThirdBrakelight();
                        //  setReverseLight();
                        //  setRooflightRear();
      setIndicatorRight();
      setIndicatorLeft();
                        //  setFogLight();
      setHorn();
                        //  setChristmasTree();
    
    
      //-- reset Toggles
      toggleGear          = false;
      toggleDiffLockFront = false;
      toggleDiffLockRear  = false;
    
    
    
    
    // Serial.print("Throttle: ");
    // Serial.print(servoThrottle.getPulse());
    
    // Serial.print(" - Steering: ");
    // Serial.print(servoSteering.getPulse());
    
    // Serial.print(" - Gear: ");
    // Serial.print(servoTransmission.getPulse());
    
    // Serial.print(" - DiffFront: ");
    // Serial.print(servoDiffLockFront.getPulse());
    
    // Serial.print(" - DiffRear: ");
    // Serial.print(servoDiffLockRear.getPulse());
    
    
    
    
      Serial.println();
    //  isIgnition              = true;
    
    
    }
    
    
    //---------------- Function Section
    
    //-- Function checkRemote1
    void  checkRemote1()
                                                                                                                                              {
                                                                                                                                                if (digitalRead(pinRemoteButton1) == HIGH) {
                                                                                                                                                  isButton1Pressed  = true;
                                                                                                                                                  isButton1Released = false;
                                                                                                                                                  // isHighBeamFlash   = true;
                                                                                                                                                                                      isDark                  = true;    // todo test
                                                                                                                                                                                      isIgnition              = true;    // todo test
                                                                                                                                                }
                                                                                                                                                if (digitalRead(pinRemoteButton1) == LOW) {
                                                                                                                                                  isButton1Released = true;
                                                                                                                                                  // isHighBeamFlash   = false;
                                                                                                                                                                                      isDark                  = false;    // todo test
                                                                                                                                                                                      isIgnition              = false;    // todo test
                                                                                                                                                }
                                                                                                                                              }
    
    
    //-- Function checkRemote2
                                                                                                                                              void  checkRemote2()
                                                                                                                                              {
    
                                                                                                                                              // Serial.print("Hazard: ");
                                                                                                                                              // Serial.print(isHazardLight);
                                                                                                                                              // Serial.print(" - ");
    
    
                                                                                                                                                if (digitalRead(pinRemoteButton2) == HIGH) {
                                                                                                                                                  isButton2Pressed  = true;
                                                                                                                                                  isButton2Released = false;
                                                                                                                                                  }
                                                                                                                                                if (digitalRead(pinRemoteButton2) == LOW)
                                                                                                                                                  isButton2Released = true;
                                                                                                                                                if (isButton2Pressed && isButton2Released) {
                                                                                                                                                  isButton2Pressed  = false;
                                                                                                                                                  isButton2Released = false;
                                                                                                                                                  if (isHazardLight) {
                                                                                                                                                    isHazardLight       = false;
                                                                                                                                                    timerLeftIndBlink   = 0;
                                                                                                                                                    timerRightIndBlink  = 0;
                                                                                                                                                  }
                                                                                                                                                  else {
                                                                                                                                                    isHazardLight       = true;
                                                                                                                                                    timerLeftIndBlink   = millis();
                                                                                                                                                    timerRightIndBlink  = millis();
                                                                                                                                                  }
                                                                                                                                                }
                                                                                                                                              }
    
    
    //-- Function checkRemote3
                                                                                                                                              void  checkRemote3()
                                                                                                                                              {
                                                                                                                                                if (digitalRead(pinRemoteButton3) == HIGH) {
                                                                                                                                                  isButton3Pressed  = true;
                                                                                                                                                  isButton3Released = false;
                                                                                                                                                  }
                                                                                                                                                if (digitalRead(pinRemoteButton3) == LOW)
                                                                                                                                                  isButton3Released = true;
                                                                                                                                                if (isButton3Pressed && isButton3Released) {
                                                                                                                                                  isButton3Pressed  = false;
                                                                                                                                                  isButton3Released = false;
                                                                                                                                                  isFogLightOn      = !isFogLightOn;
                                                                                                                                                }
                                                                                                                                              }
    
    
    //-- Function checkRemote4
    void  checkRemote4()
    {
    
    // Serial.print(" Horn: ");
    // Serial.print(analogRead(pinRemoteButton4));
    // Serial.print(" - ");
    // Serial.print(isHorn);
    // Serial.print(" - ");
    
      if (analogRead(pinRemoteButton4) > 512) {
        isButton4Pressed  = true;
        isButton4Released = false;
        isHorn            = true;
      }
      if (analogRead(pinRemoteButton4) < 512) {
        isButton4Released = true;
        isHorn            = false;
      }
      if (isButton4Pressed && isButton4Released) {
        isButton4Pressed  = false;
        isButton4Released = false;
        isHornContinuous  = !isHornContinuous;
      }
    }
    
    //-- Function checkPhotoSensor
                                                                                                                                              void  checkPhotoSensor()
                                                                                                                                              {
    
                                                                                                                                              // Serial.print("Light Sensor: ");
                                                                                                                                              // Serial.print(analogRead(pinLightSensor));
    
                                                                                                                                                if (analogRead(pinLightSensor) <= 512) {
                                                                                                                                                  // Serial.print(" - Bright - ");
                                                                                                                                                  timeLightSensorDelayOff   = 0;
                                                                                                                                                  if (timeLightSensorDelayOn == 0)
                                                                                                                                                    timeLightSensorDelayOn  = millis();
                                                                                                                                                  if (millis() >= timeLightSensorDelayOn + ( numPhotoSensorDelayOn * 1000 )) {
                                                                                                                                                    timeLightSensorDelayOn  = 0;
                                                                                                                                                    isDark                  = false;
                                                                                                                                                  }
                                                                                                                                                }
                                                                                                                                                else {
                                                                                                                                                  // Serial.print(" - Dark   - ");
                                                                                                                                                  timeLightSensorDelayOn    = 0;
                                                                                                                                                  if (timeLightSensorDelayOff == 0)
                                                                                                                                                    timeLightSensorDelayOff = millis();
                                                                                                                                                  if (millis() >= timeLightSensorDelayOff + ( numPhotoSensorDelayOff * 1000 )) {
                                                                                                                                                    timeLightSensorDelayOff = 0;
                                                                                                                                                    isDark                  = true;
                                                                                                                                                  }
                                                                                                                                                }
                                                                                                                                              }
    
    
    //-- Function checkThrottle
    void  checkThrottle()
    {
      isReverse  = false;
      isForward  = false;
      isStopping = false;
    
    
    // Serial.print("Throttle: ");
    // Serial.print(servoThrottle.getPulse());
    
    
    
      if (servoThrottle.getPulse() > numPWMThrottleForward) {
        isIgnition = true;
        isForward  = true;
        isCountdown = false;
      }
      else {
        if (servoThrottle.getPulse() < numPWMThrottleReverse) {
          isIgnition  = true;
          isReverse   = true;
          isCountdown = false;
        }
        else {
          isStopping = true;
          if (isIgnition) {
            if (!isCountdown) {
              isCountdown = true;
              timeCountdown = millis();
            }
          }
        }
      }
      if (isCountdown)
        if (millis() >= timeCountdown + ( durIgnition * 1000 ))
          isIgnition = false;
    
    
    }
    
    
    //-- Function checkSteering
    void  checkSteering()
    {
    
    Serial.print(servoSteering.getPulse());
    Serial.print(" - ");
    Serial.print(isFullRight);
    Serial.print(" - ");
    Serial.print(isFullLeft);
    Serial.print(" - ");
    Serial.print(isIndicatorRight);
    Serial.print(" - ");
    Serial.print(isIndicatorLeft);
    Serial.print(" - ");
    Serial.print(" - ");
    
    
      // Full Left Steering
      if (servoSteering.getPulse() > numPWMSteeringLeftMax) {
        if (millis() - timeLastNeutral < ( durIndicatorActivate * 1000 )) {
          isFullLeft = true;
          isFullRight = false;
        }
        else {
          isFullLeft = false;
        }
      }
    
      // Full Right Steering
      if (servoSteering.getPulse() < numPWMSteeringRightMax) {
        if (millis() - timeLastNeutral < ( durIndicatorActivate * 1000 )) {
          isFullRight = true;
          isFullLeft = false;
        }
        else {
          isFullRight = false;
        }
      }
    
      // Little Left Steering
      if (servoSteering.getPulse() > numPWMSteeringLeftMin) {
        isIndicatorRight = false;
      }
    
      // Little Right Steering
      if (servoSteering.getPulse() < numPWMSteeringRightMin) {
        isIndicatorLeft = false;
      }
    
      // Steering in Neutral
      if (servoSteering.getPulse() > numPWMSteeringRightMin && servoSteering.getPulse() < numPWMSteeringLeftMin) {
    
        if (isFullLeft && millis() - timeLastNeutral < ( durIndicatorActivate * 1000 )) {
          isIndicatorLeft     = true;
          timerLeftIndBlink   = millis();
          isIndicatorRight    = false;
          timerRightIndBlink  = 0;
        }
    
        if (isFullRight && millis() - timeLastNeutral < ( durIndicatorActivate * 1000 )) {
          isIndicatorRight    = true;
          timerRightIndBlink  = millis();
          isIndicatorLeft     = false;
          timerLeftIndBlink   = 0;
        }
    
        isFullRight = false;
        isFullLeft = false;
        timeLastNeutral = millis();
      }
    
    }
    
    
    //-- Function checkGear
    void  checkGear()
    {
      if (1 == 1) {
    // ToDo if (PWM > numPWMGear) {
        if (numCurrentGear == 1)
          toggleGear = true;
        numCurrentGear = 2;
      }
      else {
        if (numCurrentGear == 2)
          toggleGear = true;
        numCurrentGear = 1;
      }
    }
    
    
    //-- Function checkDiff1
    void  checkDiff1()
    {
      if (1 == 1) {
    // ToDo if (PWM > numPWMDiffLockFront) {
        if (isDiffLockFront)
          toggleDiffLockFront = true;
        isDiffLockFront = false;
      }
      else {
        if (!isDiffLockFront)
          toggleDiffLockFront = true;
        isDiffLockFront = true;
      }
    }
    
    
    //-- Function checkDiff2
    void  checkDiff2()
    {
      if (1 == 1) {
    // ToDo if (PWM > numPWMDiffLockRear) {
        if (isDiffLockRear)
          toggleDiffLockRear = true;
        isDiffLockRear = false;
      }
      else {
        if (!isDiffLockRear)
          toggleDiffLockRear = true;
        isDiffLockRear = true;
      }
    }
    
    
    
    
    
    
    
    
    
    
    
    //-- Function setDaytimeLights
                                                                                                                                      void  setDaytimeLights()
                                                                                                                                      {
                                                                                                                                        if (isIgnition)
                                                                                                                                          digitalWrite(pinDaytimeLights, HIGH );
                                                                                                                                        else
                                                                                                                                          digitalWrite(pinDaytimeLights, LOW );
                                                                                                                                      }
    
    
    //-- Function setHeadlight
                                                                                                                                    void  setHeadlight()
                                                                                                                                    {
                                                                                                                                      if (isIgnition) {
                                                                                                                                        if (isHighBeam || isHighBeamFlash) {
                                                                                                                                          analogWrite(pinHeadlight, numBrightness100 );
                                                                                                                                        }
                                                                                                                                        else
                                                                                                                                          if (isFogLightOn)
                                                                                                                                            if (isHeadlightStarted) {
                                                                                                                                              analogWrite(pinHeadlight, numBrightness050 );
                                                                                                                                              timeLastHeadlightStart = 0;
                                                                                                                                            }
                                                                                                                                            else
                                                                                                                                              isHeadlightStart = true;
                                                                                                                                          else {
                                                                                                                                            if (isDark) {
                                                                                                                                              if (isHeadlightStarted) {
                                                                                                                                                analogWrite(pinHeadlight, numBrightness050 );
                                                                                                                                                timeLastHeadlightStart = 0;
                                                                                                                                              }
                                                                                                                                              else
                                                                                                                                                isHeadlightStart = true;
                                                                                                                                            }
                                                                                                                                            else {
                                                                                                                                              analogWrite(pinHeadlight, numBrightness000 );
                                                                                                                                              if (timeLastHeadlightStart == 0)
                                                                                                                                                timeLastHeadlightStart = millis();
                                                                                                                                              if (millis() >= timeLastHeadlightStart + 10000) {
                                                                                                                                                timeLastHeadlightStart = 0;
                                                                                                                                                isHeadlightStarted  = false;
                                                                                                                                              }
                                                                                                                                            }
                                                                                                                                          }
                                                                                                                                      }
                                                                                                                                      else {
                                                                                                                                        analogWrite(pinHeadlight, numBrightness000 );
                                                                                                                                        isHeadlightStarted  = false;
                                                                                                                                      }
                                                                                                                                    }
    
    
    //-- Function setTaillight
                                                                                                                                        void  setTaillight()
                                                                                                                                        {
                                                                                                                                          if (isIgnition) {
                                                                                                                                            // Serial.println("Ignition on");
                                                                                                                                            if (isStopping)
                                                                                                                                              analogWrite(pinTaillight, numBrightness100 );
                                                                                                                                            else
                                                                                                                                              if (isFogLightOn)
                                                                                                                                                analogWrite(pinTaillight, numBrightness050 );
                                                                                                                                              else
                                                                                                                                                if (isDark)
                                                                                                                                                  // analogWrite(pinTaillight, numBrightness050 );
                                                                                                                                                  analogWrite(pinTaillight, numBrightness050 );
                                                                                                                                                else
                                                                                                                                                  analogWrite(pinTaillight, numBrightness000 );
                                                                                                                                          }
                                                                                                                                          else {
                                                                                                                                            // Serial.println("Ignition off");
                                                                                                                                            analogWrite(pinTaillight, numBrightness000 );
                                                                                                                                          }
                                                                                                                                        }
    
    
    //-- Function setLicensePlateLight
    
    
    //-- Function setIndicatorRight
    void  setIndicatorRight()
    {
    
    Serial.print(isIndicatorRight);
    
      
      if ((isIgnition && isIndicatorRight) || isHazardLight) {        
        if (stateIndicatorRightIsOn) {
          if (millis() >= timerRightIndBlink + ( durIndicatorOn * 1000 )) {
            stateIndicatorRightIsOn = false;
            timerRightIndBlink      = millis();
          }
        }
        else {
          if (millis() >= timerRightIndBlink + ( durIndicatorOff * 1000 )) {
            stateIndicatorRightIsOn = true;
            timerRightIndBlink      = millis();
          }
        }
    
        if (stateIndicatorRightIsOn) {
          Serial.print(" - On");
          digitalWrite(pinIndicatorRight, HIGH );
        }
        else {
          Serial.print(" - Off");
          digitalWrite(pinIndicatorRight, LOW );
        }
      }
      else
        digitalWrite(pinIndicatorRight, LOW );
    }
    
    
    //-- Function setIndicatorLeft
                                                                                                                                        void  setIndicatorLeft()
                                                                                                                                        {
                                                                                                                                          if ((isIgnition && isIndicatorLeft) || isHazardLight) {
                                                                                                                                              if (stateIndicatorLeftIsOn) {
                                                                                                                                                if (millis() >= timerLeftIndBlink + ( durIndicatorOn * 1000 )) {
                                                                                                                                                  stateIndicatorLeftIsOn  = false;
                                                                                                                                                  timerLeftIndBlink       = millis();
                                                                                                                                                }
                                                                                                                                              }
                                                                                                                                              else {
                                                                                                                                                if (millis() >= timerLeftIndBlink + ( durIndicatorOff * 1000 )) {
                                                                                                                                                  stateIndicatorLeftIsOn  = true;
                                                                                                                                                  timerLeftIndBlink       = millis();
                                                                                                                                                }
                                                                                                                                              }
    
                                                                                                                                              if (stateIndicatorLeftIsOn)
                                                                                                                                                digitalWrite(pinIndicatorLeft, HIGH );
                                                                                                                                              else
                                                                                                                                                digitalWrite(pinIndicatorLeft, LOW );
                                                                                                                                          }
                                                                                                                                          else
                                                                                                                                            digitalWrite(pinIndicatorLeft, LOW );
                                                                                                                                        }
    
    
    //-- Function setReverseLight
    
    
    //-- Function setThirdBrakelight
    
    
    //-- Function setRooflightFront
    
    
    //-- Function setRooflightRear
    
    
    //-- Function setFogLight
    
    
    //-- Function setHorn
    void  setHorn()
    {
    // Serial.print(timerHorn);
    // Serial.print(" - ");
    // Serial.print(timerHorn + (durHornSignalPWM*1000));
    
      if (isHorn) {
        if (timerHorn == 0) {
          ESSDual.attach(pinHorn); 
          ESSDual.writeMicroseconds(1800);
          timerHorn = millis();
        }
      }
    
      if (timerHorn != 0) {
        if (millis() >= timerHorn + (durHornSignalPWM*1000)) {
          timerHorn = 0;
          ESSDual.writeMicroseconds(1500);
          ESSDual.detach(); 
        }
      }
        
    
    
    
    
    
    
    
    
    
    
    }
    
    
    //-- Function setHeadlightStart
                                                                                                                                  void  setHeadlightStart()
                                                                                                                                  {
    
                                                                                                                                    if (isHeadlightStart)
                                                                                                                                    {
                                                                                                                                      // Start the timer
                                                                                                                                      if (timerHeadlightStart == 0)
                                                                                                                                        timerHeadlightStart = millis();
    
                                                                                                                                      if (millis() <= timerHeadlightStart + ( HeadlightStage1 * 1000 ))
                                                                                                                                        analogWrite(pinHeadlight, numBrightness100 );
                                                                                                                                      else
                                                                                                                                        if (millis() <= timerHeadlightStart + ( HeadlightStage2 * 1000 ))
                                                                                                                                          analogWrite(pinHeadlight, numBrightness000 );
                                                                                                                                        else
                                                                                                                                          if (millis() <= timerHeadlightStart + ( HeadlightStage3 * 1000 ))
                                                                                                                                            analogWrite(pinHeadlight, numBrightness010 );
                                                                                                                                          else
                                                                                                                                            if (millis() <= timerHeadlightStart + ( HeadlightStage4 * 1000 ))
                                                                                                                                              analogWrite(pinHeadlight, numBrightness020 );
                                                                                                                                            else
                                                                                                                                              if (millis() <= timerHeadlightStart + ( HeadlightStage5 * 1000 ))
                                                                                                                                                analogWrite(pinHeadlight, numBrightness025 );
                                                                                                                                              else
                                                                                                                                                if (millis() <= timerHeadlightStart + ( HeadlightStage6 * 1000 ))
                                                                                                                                                  analogWrite(pinHeadlight, numBrightness030 );
                                                                                                                                                else
                                                                                                                                                  if (millis() <= timerHeadlightStart + ( HeadlightStage7 * 1000 ))
                                                                                                                                                    analogWrite(pinHeadlight, numBrightness035 );
                                                                                                                                                  else
                                                                                                                                                    if (millis() <= timerHeadlightStart + ( HeadlightStage8 * 1000 ))
                                                                                                                                                      analogWrite(pinHeadlight, numBrightness040 );
                                                                                                                                                    else
                                                                                                                                                      if (millis() <= timerHeadlightStart + ( HeadlightStage9 * 1000 ))
                                                                                                                                                        analogWrite(pinHeadlight, numBrightness045 );
                                                                                                                                                      else {
                                                                                                                                                        isHeadlightStarted      = true;
                                                                                                                                                        timeLastHeadlightStart  = millis();
                                                                                                                                                        isHeadlightStart        = false;
                                                                                                                                                        timerHeadlightStart     = 0;
                                                                                                                                                      }
                                                                                                                                    }
                                                                                                                                  }
    
    
    //-- Function setChristmasTree

     

     

    The heavy

     

     

    • Like 2
  12. 16 hours ago, Scottyb said:

    Got through 2 batteries with loads of somersaults and no breakages today 😁😁😁

     

    I'm only getting 20mins out of each battery though and @Jens said I'd get around 40mins each with my setup. The low voltage cutoff is set to intermediate on the esc from factory, I don't know if I should change it to low?  Have multimetered them both when I got back and they both read 6.9v but the car won't go anywhere. There's no guide in the book as to what voltage the cutoffs are. I'm guessing low would be something around 6v.

    I don't think it's the thermal cutoff as the motor is hot but not hot enough for me to not hold my hand on it

     

    I would say the driving time depends mostly on driving style, surface, motor/ESC setup and battery quality and of course the capacity.

    Something similar to real life. :lol:

     

    So when I say my son runs one battery for 40 minutes, it would apply only to my son.

    It might just give you a little reference, but I would say it cannot be directly compared.

     

     

     

  13. 2 minutes ago, Scottyb said:

    I bought the last pair, but he has front and rear seperate on his other auctions

    https://www.ebay.co.uk/itm/FTX-Aluminium-Front-and-Rear-Shock-Tower-For-Carnage-Bugsta-Outlaw-Vantage-Zorro/194021872266

    I have been looking for them for a long time.

    They must have become available again.

     

    I believe they are better than the carbon ones.

    The carbon ones don't have threads and therefore you need to use nylocs on the other side.

    Thus preventing me from properly fixing the wheelie bar.

  14. 1 hour ago, Scottyb said:

    2 minutes into it's maiden voyage on grass, it gets traction, flips over and shatters the rear suspension tower, amazing

    Now you know why that car got its name. :rofl:   --> Carnage

    If you plan for heavy jumping get the Carbon shock towers. But leave the shell holders in plastic.

     

    And there is an optional wheelie bar available.

    Might make it easier for you to used to the power.

     

    But once you got the hang of it the fun is endless.

    And I have the feeling you will enjoy its power for quite a while...

     

  15. 29 minutes ago, walkbythesea said:

    You’ll almost certainly be wanting some of these in the spares box

     

    https://www.modelsport.co.uk/index.php?product_id=365755

     

    beware that if you replace them with alloy the next most likely thing to break is a wishbone if you hit something hard enough

     

    Either the suspension arm or the holder will give way in a crash.

    Keep the holder in plastic since they are cheaper and easier to replace.

     

     

  16. Maybe we all pushed our Carnages to its physical limits? 

    The only next step would to upgrade to a different, more expensive model.

    I don't know. Just got that feeling coming in......

     

    So far the "claimed" hardened steel diff gears on my Carnage with the Max10 ESC are holding.

    But who knows how long.

    The Bugsta ones lost their teeth last weekend, but that car is running with the stock brushless motor and only 2S Lipos.

     

    For me, I am starting to save up my money for a Traxxas e-Revo 2.0.

    My son is behaving so well, that I fear I really have to spend £600++ by the end of the summer term.

    • Haha 3
  17. On 04/04/2021 at 20:57, Ant.p said:

    So today was good and bad. Sun was out and the park was empty. Was great fun bashing around and getting some decent air until... another diff gear shredded. That’s 2 times in 3 runs on 3s. Miraculously the rest of the car is intact, it’s really quite robust now. I have a carbon chassis and top plate on order but not sure when that’s going to arrive, it’s already been weeks. I’m hoping this will ease some of the movement stresses on the gears as the stock chassis flexes all over the place.

    does anyone know of a way to cure this? I know that @Jens has recently fitted a hardened diff gear, but haven’t heard if this has made a difference? The spur will be the next problem. Probably too early to tell. There are lots of people suffering with this issue, and a gap in the market. Who do I go to to get some super tough gears made for me (and the rest of the extended FTX family). 
    It’s like the car wasn’t designed to go this fast and/or take such abuse 😭😖😅

    I broke another diff this weekend.

    Then I remembered something on the ebay page for the hardened steel spur/pinion:

    https://www.ebay.co.uk/itm/FTX-Carnage-Bugsta-32DP-Hard-Steel-Spur-kit/264098799917?mkcid=1&mkrid=710-53481-19255-0&siteid=3&customid=link&campid=5338629070&toolid=20001&mkevt=1

     

    Use an alloy or carbon top plate to prevent flexing of the bottom plate.

    It prevents damage to the diffs and keeps the mesh aligned.

     

    Just ordered the carbon top plate since I couldn't find the cheaper alloy version.

    • Like 1
  18. 5 hours ago, Scottyb said:

    Angry day today, was fully expecting the car to turn up this morning and it's not even getting posted until the 19th. Had to cancel it that's just rediculous! So now i'm sat here with a brushless conversion and nothing to use it in 😡😄
    Is the Bugsta 100% the same car coz i might just get that from timetunnelmodels instead as i prefer the shell?

    That's a shame.

    The Bugsta I originally bought is slightly different to the Carnage 2.0.

    Carnage 2.0 came out later I think and it has some improvements with the problem of stones getting into the gear mesh.

    But then, it is possible that the Bugsta has now the same improvements.

    Difference that I know of:

    The bottom plate has some extra plastic near the rear diff.

    A gap in the motor holder is closed now.

     

    Both were meant to prevent stones coming in and ruining the spur.

     

    But then the hardened steel pinion/spur would eat the stones. :good:

     

     

    On 04/04/2021 at 17:46, Scottyb said:

    It's not coming until Tuesday now, then probably a parcel everyday this week, a bit annoyed as i paid for next day and the weathers been beaut today lol. I saw he had a spur and pinion set on ebay (last one) so had to buy it, i think this is right one isn't it? i did check with @Jensoriginal post and as far as i can see it's the same, just making sure    https://www.ebay.co.uk/itm/FTX-Carnage-Bugsta-32DP-Hard-Steel-Spur-kit/264098799917

    Perfectly the right one. 👍

  19. 56 minutes ago, Ant.p said:

    whatever you decide, I would recommend getting a balance charge extension cable and a lipo fire/explosion proof bag for when charging and storing lipo batteries 

    @Scottyb: This is very important.

    There is quite enough information about Lipos and their explosive nature if handled wrong, here in this forum.

    One member recently had a fire in his house because of that.

    Please take care of this.

     

    For myself, I am always in the same room where the batteries are charging.

    Either in my office or in my living area.

    And always with a fire extinguisher in reach.

    • Like 1
  20. 8 hours ago, Scottyb said:

    I wouldn't want to say anything wrong.

    I think it is.

    But then I cannot guarantee.

    I bought my charger in a local shop last year. And the shop made me an adapter. Freshly soldered.

     

    I find it an advantage, that my adapter is with a cable. 

×
×
  • Create New...