Let's see if I'm sure then.
So welcome, and thanks for being here.
So this talk is about a very, do it yourself project.
And this is how I made some smartness into a done EV charger for,
well, for open source and for being viable for me
to charge a car at my parents.
Okay, I'll try to speak louder.
My voice is really getting a hard time.
Thanks.
So I'm currently a kickhouse developer at the,
a tiny bit, which is a company we do with data analytics.
I presented a track like founded this.
I presented on 1, 2019 about privacy and showing who is tracking us
through the internet.
And I'm also a hip-olycerly user group that exists in a cornea.
And we are organizing also a free software conference there,
and CFP is open.
So, okay, so I made my own way of interacting with a car for,
for charging.
And first of all, the reason why I did this is this was a site project,
and I wanted to learn Rust.
So I ended up making this as an excuse as a project to learn the language.
And I talked yesterday at the Rust that room about how I did it,
the talk of today is why I did it.
So why?
Well, I now own an EV and charging cheaper than the public pricing
and my parents lived in the countryside where there's a very poor electric power.
There's less than 2.2 kilowatts peak available.
And most of the chargers that are currently available do a kind of,
this smart grid balancing and so on,
but they are only interested in high power output for 10 cars or 20 cars,
and this is not my use case.
These balancing chargers exist,
but first of all, they usually require physical wiring,
which is cumbersome because when you have a car that is like 15 meters away from
your circuit breaker in a different area,
then you would have to do a different groundwork to put a wire.
Just a tiny little wire that only carries like one volt to check
what's the amperage of the breaker.
So it's really expensive and really not convenient for this to do.
This is kind of displaced.
So it doesn't really make a lot of sense to like,
all through like 15 meters away to just go to the other side and charge the car there.
Because we already had, we already had AC there.
We just didn't have that one wire.
So the thing is also that cost matters,
because part of the sighting to purchase an EV was the cheap electricity
and the convenience, like 10 years across,
that it would be cheaper than running a gas car.
So given that this is also decreasing the preheating acid,
it doesn't make sense to spend more on chargers and other infrastructure
than it's needed because then you're just moving the milestones
and it doesn't make sense economically.
As I said, this is expensive.
Should they?
Well, the tech is very complex right now.
Many of these chargers that are quite intelligent
that they have hardware inside, like a Raspberry Pi or something like that,
which is already quite expensive on itself.
It's like 50-60 euros, just the device.
And if the goal is saving money, then this is my economics.
If I charge at home, I would be charging at around 18 cents of an euro,
particularly what I learned that I have already been charging at the average of 34,
which means that if I visited my parents twice a year twice a month for a year,
I get to save at most 80 euros.
So, there's a point where it doesn't make sense to purchase a charger.
Oh, it's just less expensive for me to just charge a type,
which doesn't make a lot of sense for the charging industry.
So, as I said,
the Turkey solutions are expensive and also the open solutions that exist
on opening VSC and so on are also very expensive,
because they use computing hardware that is quite expensive to have in an embedded device.
And there are reasons for this of course, but can we do more with less than that?
So, what I did is I tried to research for what I think is the sensible way of going through this,
trying to see what is already existing.
How could I make it?
What are the standard simple things in charging?
What are the projects of existing open source that implement this?
And maybe develop something that doesn't anything that is missing.
And keeping mind that what I want to do is I wanted to just be able to charge the car
at the maximum rate possible,
but keeping in mind that things like having running water and having rich open
and that the secret breaker doesn't break is the main point here.
And also maximum, the car charge rate,
because I could just charge out one amp, but that wouldn't take me there here long.
So, there's two standards.
How many of you know about how EVSE is charging what are the standards around this?
Okay.
Okay, for the majority of the room doesn't so let's talk a bit about this.
There's basically two main standards about going this way.
Here's the letter one, the IECU 6181.
This is electric signaling that uses pulse with modulated signal,
where depending on how much of the pulse is full,
then this signals how much of an amp you are requesting.
So, for each one percent of the cycle that you had,
this is 0.6 amps, this was based on an American standard before.
And this is very cheap to implement.
You don't even need an integrated circuit to do this.
You could do it with a 555 timer,
but you can also do this with an SP32 with anything that has the capacity to output one volt
and then have a couple of resistors and the capacitors to do the rest of the wiring.
This is very, very easy to do.
The bad thing about this is that since 0.6 amps is the,
it's the one percent and the minimum if it's a 10 percent on the standard,
you can't really tell the car to charge at less than 6 amps.
And in my case, I had between 0 and 10 amps.
So if I only have from 6 to 10,
then for half the time where anything is being run at home,
the car would just be sitting idle, which is not convenient.
Then there's the more sophisticated ISOIC-15118 standard,
which is a lot more convenient to implement,
because this is packet based.
So on both of these things,
what basically what you have,
if you have ever seen one of these chargers at the street or anywhere,
you will see that there's five connectors.
One of them is called the control pilot and what it does is,
this is that one and earth is the only path
where the charger communicates to the car.
So this ISO is standard.
Well, the people that have the same standard,
just uses that wire to make up all that,
with modulated signal, which is very easy.
But the ISO, what it does is, over that signal,
it has to send Ethernet packets,
which requires you to use something that is called
a PLC.
You may have seen this, for example, when you use,
there's these solutions where you put two devices on the AC,
directly, and then you put, you have Ethernet over there,
that's using this sort of same kind of communication.
The thing is, these modules are quite expensive.
I didn't see them online to be able to purchase them for less than 60 euros.
Maybe there's, I mean, probably for integrators,
this is cheaper, but for me, it's an individual,
I couldn't even participate of getting this in an open source,
how we can think for less than that.
And I would also have to implement over this Ethernet thing,
also the actual signaling with the car, which is XML.
So you will either have to do all of the XML signaling
in some embedded kinds of devices, like,
on ESP32 or something like this,
but the things that are already built,
like in opening the EVSE, and some other projects,
are using currently full Linux OS with Python
to run the XML parser basically,
which means that there's also a lot of overhead
in terms of, like, the kind of computer devices that we are using for this.
So maybe there's a third way.
I used something that is not standard here,
which is the car vendor API.
This is for different providers.
This is the one I'm using, where you have an API,
that using the own car 5G car,
you can ask it how much it should charge.
This is possible in AC, because when you charge car in AC,
it's the onboard charging in the car,
the one who knows how much it can charge.
So you can request it directly to that.
So what did I do?
I first bought the dumbest charger I could,
and the cheapest one I could find
to write to understand how this works.
Step two, this assembly.
To check whether the cheapest thing has enough
of what it needs to, to not break apart
and catch up in flames.
And it does.
Basically, the one thing that is the most expensive,
the thing that is most expensive here,
if I wanted to do this on my own,
which I also thought about doing,
is the big wires here.
I'll step away from the camera for a moment.
These three wires, the five meters of cable,
are the most expensive thing on a charger.
Just the five meters of wire,
can run you maybe like 40, 50 years of the 60,
that this costs, is basically copper.
Copper is really expensive nowadays.
The rest of it is very cheap electronics.
You have a couple of relays to switch on
and off the GAC current.
And then, well, you can see there's not much.
The one thing that is maybe a bit interesting to see here,
is that there's this small chip,
this is a,
he got the bias,
A Rm chip, this is a small,
A Rm chip that is doing the post,
with more related thing.
I could change this and program it to do whatever I wanted,
but I couldn't find a new sheet easily online to flash it.
So it was,
if I wanted to do this with,
with the IEC standard,
I could just remove this wire,
this is the control pilot that I mentioned,
and run this through my own microcontroller,
and then talk to the car,
and then put another wire here so that the charger knows
that I'm talking to something that is like the car,
so that the charger knows I'm talking to something,
the car knows I'm talking to something,
and I put something in the middle to make things work.
This is what I thought,
I had in mind at the first time,
but then I saw the car API,
it was very much easier to do that way,
so I started in that,
but if we all wanted to do something with this,
this is a very possible and easy.
This is basically a Cortex M3,
with 72 megahertz,
it's a really, really small microcontroller.
So in order for me to be able to do this,
smart and be able to do a grid balancing,
I would have to build a wattmeter,
and I wanted to do this wirelessly,
so that I didn't have to run wires over the countryside,
to tell the car a plus something to let
the car know how many I'm still request.
So this wattmeter,
instead of all of the money that we would cost to other things,
I, well, you can see,
this is really cheap to do.
The current transformer is just,
I'm not sure if I don't think they have here,
the picture of the city anyway.
This is basically,
the current transformer is something that you,
yeah, it's a coil that you,
you put one wire over it,
and it will measure in both,
how many amps are being passed through the wire,
really small electronics device,
not even electronics.
And then a power source to power this from the,
from the grid.
And then, yeah,
something to the car, which is an API.
For doing this with the,
the SP32, I used Rust,
because you can see my talk just today,
because it just works,
it's easier to build this,
but then with the C++ SDK in my opinion,
if you want to do something with this,
I highly recommend it.
And then, sorry,
and then,
here it is.
Just,
well, this is basically the current transformer,
this is running to AC directly,
and then,
this is the current transformer,
you just put one of the wires over here,
and you will measure how much,
so it will measure one bolt over this,
over this line,
if there's 30 amps here,
and otherwise it's just linearly,
whatever it is.
So, I,
oops,
okay.
So now, I could do this manually,
I could just go and curl every,
a couple of seconds for the,
the website that I put on this device,
then,
step,
I could automate it,
and set the charging amps to the car,
every few times,
then I could put this in a more sophisticated script,
but still running from my laptop,
this is not ideal,
because, well,
all of these requirements to have a laptop here,
have LAN access,
and,
well, I just have to remember to do this.
So,
I think,
tap to the car automatically.
Basically,
these things,
so,
I used,
I used a backend with,
with Rust,
and,
for this,
I used Rocket,
because of several reasons,
regarding Rust,
basically,
to ensure that the,
the API requests were valid,
with the,
with the database token,
and so on.
And then,
I even did,
I mapped the vendors,
the,
the energy usage over the,
of the house,
over a period of time.
This was even useful to me,
outside of the,
the thing,
because,
we noticed that,
when,
this,
okay,
this,
at this home,
we have,
our running water,
it comes from,
well,
and,
we have,
water pump to,
to get it through,
and we noticed that we had,
picks of electricity running,
due to the pump,
by just looking,
every few seconds on the,
on the wire,
and we could notice that,
that we,
we should put something to,
to filter this,
this noise on the,
on the,
like,
to,
anyway,
I didn't like this,
very much in the,
the,
the car vendor API,
I would have preferred to use one of the standards,
but,
unfortunately,
um,
as I said,
there's no current open source implementations of,
uh,
talking via the XML,
uh,
interface with,
with the car,
that doesn't require you to have a full OS,
um,
as,
as such.
So,
I started with this,
because start small,
and then,
go incrementally from,
from here.
Uh,
this is very easy,
and if we wanted to,
be implemented for some other kind of charge,
or some other kind of,
car API,
this would be very easy,
because most of the work is already done,
in a way that is,
um,
uh,
pluggable.
So, you just need to change the,
eV charge handler kind of thing,
um,
which is something that you only have to implement two things,
well,
actually three,
uh,
one is,
uh,
the kind of object that you want to keep,
as state of what you,
uh,
what you have internally,
which can be whatever you want,
um,
and then,
uh,
only two methods.
One of them is,
get the state,
so that we can,
um,
and the state can be whatever you want,
with some restrictions,
that I have on the next slide,
and then,
request,
uh,
something to,
ask the car to charge at the specific rate.
This can be in,
in the charger,
in the car,
whatever it is.
Uh,
and then there's the state,
the state has to implement five things,
uh,
which is whether it's charging or not,
because if it's not,
uh,
we,
and ask repeatedly things,
until it's done,
and then,
uh,
get the current charge,
get the last request items,
because this may not be the same,
because it,
uh,
takes a while for,
for the things to ramp up,
so this should,
uh,
this should,
remember what was requested,
and this should measure actually on the car.
And this is,
uh,
well,
I also got this,
get the car distance to the point,
in kilometers,
because if you have a way to,
notice,
then we kick,
we can just sleep for hours,
if you are 500 kilometers away,
you don't have to ask,
uh,
for the state,
for at least five hours,
uh,
if you're going at legal speed limits.
Um,
this is the interface that,
uh,
I am rendering right now on,
on this,
so every,
uh,
you can see every three to six seconds,
something like that,
uh,
the,
the water meter is pushing,
um,
a packet with the,
with the amps at that point,
and then,
uh,
the picks in red,
and then in,
in blue the,
the average over a few,
a few,
a few seconds,
uh,
of the,
of the energy usage.
This is,
this was quite fast for me to do,
um,
I only,
I took approximately,
maybe one month of total development time,
um,
better-show charge car from,
from scratch,
Without,
uh,
with a budget of,
seventy years at most,
because this,
The charger was sixty-three,
plus the,
Three dollars of the,
opportunities plus four of the other,
uh,
so I mean,
Um,
compared to running and open and
VSE which,
a winning, in this case, I wanted to highlight this room because, well, basically, because
there's nothing currently that that does this, I had to do this because I didn't want
to run a full Linux just to talk some XML with with car or just to send a few packets
to an HTTP API. This costs one order of magnitude less than what we have on the current
resource space. And I think that sometimes, and this is maybe a bit much of a, you know,
I'll comment, but I believe that also in my work, we work with highly potent machines with
lots of resources, but then when we go to the real world, many of the devices that other
our users are using, don't have as many as much process in power for maybe a website or for
maybe anything else, okay. And also, in general, I think that this is a bit of a waste of resources
in the sense that we have a whole Raspberry Pi work we could be using, something that has
a hundred of the computing power and still do the same thing. That's so it's less
egoist, it's a whole of that, right. Then a future work for this would be, it would be very,
very great to be able to create an ISO-115-118 charger that doesn't require a full OS.
And of course, being able to push the wattmeter through mother, because this is like the
new IoT automation standard, and I think there's no definition of a wattmeter in the mother standard.
Please, correct me, I'm wrong if there's anything from the CSA that knows more about this,
but I didn't find a way to publish this information through that, and I believe that for anyone
with a solar, with a solar roof or with any kind of grid management system, it would be great
to be able to automate this in the same way that the rest of the home automation systems work,
and this is like the new standard going forward. And currently, all of the energy-related parts
of balancing are done in a separate protocol, in a separate way, and I think that the
converging could be a good idea, but I'm not sure, and I'm open to questions here, and for
discussion, for the five minutes we have four minutes we have, so yeah, that we could be interesting.
And yeah, in general, just, well, think about all of the CPU hours that we have wasted on
the charges that we have on the streets and the hundreds of euros that every one of them is
costing that we could just remove from existence just by putting something smaller there.
And that's it. Now, if you have any questions, anything to add here, that would be awesome.
Although there's a standard stack which is used for, and when someone has smart leaching or something,
it's not glued to them. I'm thinking to remember what the moment is, there's a standard stack
of including an energy stack, you probably know, which definitely covers metering, because it covers the
metering of a house and so that might be another way of tackling it, because there's a bunch of
software already written around to do some of this sort of thing for you. Okay, so
matter might be too need to be commercially adopted for it, whereas the other stuff is in every
smart metering Europe, for example. What is it called? I'm fading to remember sitting on band
the band 30 or whatever, it's very cool in every consumer access device, so they run this
approach calls. Oh, thank you. Oh, thank you. We might be the last time,
sometimes we can use some of the questions. Yes. All right, so what was being said is that there's
a different energy standard that was older that exists, that is called Zigbee, and in Zigbee
there is an energy profile that you can run and basically, and this is probably a way where
we could go forward with this. I can compliment that with saying that I believe that a lot of this
Zigbee energy profiles are available in matters, so maybe there is a way of doing this. I believe that
this is the case. So yeah, maybe I'm just strong on the success and we can do this. Yeah, yeah, yeah.
Yeah, so anyone has, I don't know if there's anyone from the open EVSE community here,
maybe, no. Okay. Because, yeah, this, I mean, it would be great if we could make this smaller in a way that
is, yeah. Any other questions coming? Yeah, good. Okay, thanks.
All right, thank you.