ULtra Compact 1800W charger + Eltek programming

dnmun said:
circuit said:
MrDude_1 said:
I would just find a friendly engineer that works for them, and talk to them directly. No sales guys.
Let me know when you do...

i can just see it now. engineer spends 4 months writing code and finally has a successful product and some dufous wants him to spill the beans secretly so he can hack and sell his own design. yeh sure, i know a lotta engineers who would gladly do that. NOT.
Read it twice, no luck understanding it yet.
Can you rephrase it? who's the dufous one here?
 
dnmun said:
i don't think you would expect an engineer to share his secret code with you. you seem more experienced about engineering work.
You are confusing two different things: "secret code" and communications protocols. A "code" or source code can be used to copy your product and typically is hard and expensive to obtain. Communications protocol allows someone to use your product and is not that big a deal to reverse engineer. Not sure there is much of secret in it. I did it in several systems with good results. But it is always better to ask and get it quicker, than buying additional equipment you don't need and spending days playing with it.
 
dnmun said:
ok, dufous here. i expected it would be proprietary.


its not. If it matters, I am a software engineer and can tell you from experience...we like talking to others that speak our language. lol.
At least he corrected you. I just laughed and walked away from the conversation.... ironically to go talk to other software engineers about what im working on, and its communications protocols. (simple XML being transmitted via MQ if it matters)
 
dnmun said:
ok, dufous here. i expected it would be proprietary.
Sometimes it more or less is. In Eltek's example, they don't want you using their gear not where and how it was meant to. In this case they want you to buy a full rack system with it's controller and services. So the protocol is meant to be used only between their devices and so probably no one is going to reveal that info without financial interest, because all they will get is many questions on forums, sharing stories, that are not always a good ones.
I know it actually is possible to get that info without reverse engineering, but you really need to know who to ask. And if you do get it, you have to keep it to yourself.
 
i bot a used Elcon charger on ebay figuring i could fix it.

it had been worked on by someone who had no clue and he had cut out the schottky diode so i emailed Elcon and they would not even tell me what part they used.

they told me i could only send it in and they would fix it.
 
Doctorbass said:
Welcome to the forum remmie!

Nice tests!.. What would be awsome is to find a way to reprogram the set voltage to the desired value. These can be programmed for 58Vdc witch wold be awsome for the Zero motorcycle battery of 116V. That would only require 2 of these in serie to put 3600W in a very ultra compact size for charging the battery!

I guess it would be possible to modify the resistor divider that measure the voltage to false the reading and get the 116V, but let see if someone can get it reprogrammed!

I already asked to the Canadian sales rep from Eltek and he said he would help me to hget the software but he can't....

Doc

Thanks,
My thoughts exactly, to change it to 57/58 Volt should only be a series of messages or maybe even a single message.
Maybe I'll just try different messages until something changes :D That does imply a risk though. I bet I end with a power supply which does 58 Volt but only 0.5A :lol:

2 of these in series would fit into the standard compartment in the "tank" area together with a chain lock and the mennekes type 2 connector we use here in Europe.

I also got in touch with eltek Germany (local office for the Netherlands) asking for a quote and got about halfway before the guy went on vacation until august 21st. He had some questions about the use and said it was not the use it was intended for but was still happy to quote me anyway.
I think I'll ask him about the can-bus message or to send my PSU in and have it set at 58 Volts and buy another which is already set to 58 volts.
 
circuit said:
pm_dawn said:
Should be just a matter of finding out the correct CAN message to send and have a little arduino to do that.
.....
There is no 'correct message'. It actually has a quite complex communications protocol, with logging in, pinging, selftests, etc. And protocol is not publicly available.
Your best bet would be to buy a complete system with controller, tap in to the line and reverse engineer it. Not for average people for sure, and not for most of us here. But doable.

I would say that you are half right.
These Supplys a really complex. And yes there is a logging in and all that, but not to the actual supply, but to the controller.
I have a complete rack of these Flatpack2HE here at work with the Smartpack controller.
There is no complex stuff going on between each supply and the Smartpack.
Unless you do FW update of the supply.
That is done with a tool that is for service personal only.

I would look at the open protocol that is for the EV version of the Eltek charger to see the protocol definition there first.
I think that it gives a really good idea on what to send and to expect from each supply.

Can be found here:
http://evolveelectrics.com/PDF/Eltek/Eltek%20CANbus%20Protocol.pdf

I would suspect that a lot of the protocol is common.

REgards
/PEr
 
That is a good info, thanks.

I have tried to control the HE2 according to this document:
http://lithiumate.elithion.com/php/eltek.php
But it did not work.

Looking at Message ID 0x2FF, looks like both documents describe the same protocol.

Are you sure we are talking about the same product? HE2? I've heard from other sources they are quite different.

I have obtained some very poor quality "inside" documentation and tried to implement the protocol. Document described a way of logging in and from what I saw it actually worked that way: without logging in, or after timeout from last log in, it would stop to respond. Due to limited time never got to actually controlling anything. There was some other nasty thing going on, log in was not enough, like you had to confirm the setting within time window or something.

Would be great if you could add some more info to the pool.
 
I Cannot say for sure that it is the way I have described until I have tested it.
Your story is probably closer to the truth since you actually have done some testing.

But I can try to see if I can do a little sniffing on the CAN bus to see what is going on.

If you would like to share that unofficial i'm really interested.
Please PM me with the info if like to share.
I will put some tests into the todo list.

REgards
/Per
 
madin88 said:
what a nice find DOC! Put it into a peli 1170 case together with the Adaptto coil and you have a very transport friendly charger.
do you know if eltek also offers lower power, but smaller size 48V psu (as ex 1000W)? The 1000W flatpack 2 charger has same size as 1800W model.
Yes!
 
A smaller sized 48V model with about 500-800W would be nice for use as lightweight travelcharger or direct installation on the bike.

DOC, do you have some pics of the inside?
 
Any progress from anybody looking at these?

I've requested quotes for a number of units from a couple of Alibaba suppliers. Will let you know what I get back...

If there is sufficient interest I may buy a full 1u unit along with a number of rectifiers and could re-program and send out. I will use the 1u chassis as my home base charger.
 
remmie1972 said:
Well, I had some success connecting to the Flatpack S

Of the middle port (with the 4 tabs on the top) the 2 tabs on the top right of that port are for the CAN-bus (not RS485!)
The top right pin (of the middle port) is the CAN-H and the pin to the left of it is the CAN-L.

That's consistent with the picture in my previous post if disregard the fourth pin in the port.

Connecting it all up to an arduino with a can-bus converter it took some time to discover that the bus speed is 125 kbps which is kind of an odd speed. :?

Anyway it outputs this message about every 2 seconds :
32 (can bus ID) 27 20 20 113 17 8 32 0
and every 15 seconds
0 (can bus ID) 20 20 113 17 8 32 5 0

The second message looks a lot like the first but shifted 1 byte.

When I put a load on the PSU (4 lightbulbs 12V 21W, measured at 1.90 A) the last number of the first line reads 12 instead of 0 and to me that looks like the current draw.
roughly calculating that 12 out of 255 (8 bits) equals a range of 0-40A
The second message however doesn't change at all.

So with 1.90 Amps the message every 2 seconds
32 (can bus ID) 27 20 20 113 17 8 32 12
and every 15 seconds
0 (can bus ID) 20 20 113 17 8 32 5 0

Next was trying to get a temperature reading but no change whatsoever from the values.

I could imagine that the 113 value is the voltage on a range of 0-120 Volt (113/255*120 = 53.2) but I haven't got a load large enough for the voltage to drop.


I got some more info from eltek.
I use a flatpack2 HE but after reading your post I believe the can data are the same.

What you got is the serial number of your device. Just read it in hexa.
You receive 8 bytes. The 6 first are the serial number. The 2 last always 00.

Note that the can bus is at 125 kb/s and 29 bits.

A flatpack have two main states.

Stand alone or
Logged In

What your read is in stand alone mode.

To go further you have to log each device on the can bus.
To do such a thing you nead it serial number and you have to give him a ID = a number between 01 and 96.

For exemple:
in stand alone I get 29 bits 05 02 44 00 and 8 bytes 15 16 17 18 19 20 00 00

02 is the ID number (between 01 and 96) 01 is the factory default. 151617181920 the device serial number.

To go in logged mode send for exemple
the 29 bits 05 00 48 08 and 8 bytes with the serial number 15 16 17 18 19 20 00 00 (Edit I remove the right 00 in the header.)
48 08 is for ID=02 (48 0C ID=3, 48 10 ID=4 ...)

Then you receive a rectifier status message:
29 bits 05 02 40 04 and 8 bytes 1A 00 00 EB 14 E8 00 1C
The 04 in the 29 bits say : disabled (I don't connect the output wires). 00 would be Normal
1A = intake temp in °C
00 00 Is the output amperage in deci Amp
14 EB (invert the 2 bytes) is the output voltage in centi volts
00 E8 is the input voltage in volts
1C is the out air temp in °C.

After connecting à battery with a voltage close to the default output (53.5v) I received:

29 bits 05 02 40 00 and 8 bytes 19 31 00 F0 14 E7 00 19
that is
19 = 25°C
00 31 (you have to invert 31 and 00) is 4.9 A DC, deci amp
14 F0 = 53.60v, centi volts DC
00 E7 = 231v volts AC

I will do some more testing.

:D
 
Thanks planetaire for pointing me in the right direction.
I didn't realize the charger outputted 29-bits CAN (extended CAN) so the ID is now in 29 bits.

A little tweaking of the arduino code produced the following information from the charger. (ALL Hex value now)

05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05014400 14 14 71 11 08 20 05 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05014400 14 14 71 11 08 20 05 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05014400 14 14 71 11 08 20 05 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05014400 14 14 71 11 08 20 05 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00

One thing i don't understand in the explanation of planetaire is :

To go in logged mode send for exemple
the 29 bits 05 00 48 08 00 and 8 bytes with the serial number 15 16 17 18 19 20 00 00
48 08 is for ID=02 (48 0C ID=3, 48 10 ID=4 ...)

05 00 48 08 00 is at least 33 bits instead of 29 bits, is it supposed to be 05 48 08 00 or 05 00 48 08 ?

i've tried sending the messages :
0x0500480800 1B 14 14 71 11 08 20 00
0x05004808 1B 14 14 71 11 08 20 00
0x05480800 1B 14 14 71 11 08 20 00

but no effect at all.
Any thoughts?
 
Hi remmie1972.

You are right I write a too long header, the rigth 00 does not exist. I correct my previews post.
The good header is 05 00 48 08 for an Id=2.
The Id is left shifted 2 bits that is why I writed 4808 for Id=2, 480C for id=3. 4804 for id=1.

You received: 05014400 14 14 71 11 08 20 05 00

I think that your device have the Id=1. So your header will be 05 00 48 04
Probably your device have this serial number: 141471110820. Is it what you read on the sticker on your device ?
What is strange is that you have only one "00" à the right and the 14 is twice ?
May be there is a problem in your arduino code and the good serial number is 147111082005

So you could try the header 05 00 48 04 and 8 bytes 14 71 11 08 20 05 00 00
If this don't work try 05 00 48 04 and 14 14 71 11 08 20 00 00

:D
 
Haha, stupid me. I didn't even look at the sticker for the serial number. :oops:

The serial number is indeed 141471110820 just like you said.

Sending header 05004804 and 8 bytes 14 14 71 11 08 20 00 00 does not give a reaction but that may be the arduino code.

05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05014400 14 14 71 11 08 20 05 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05014400 14 14 71 11 08 20 05 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00
05000820 1B 14 14 71 11 08 20 00

Any idea what the 1B means ?
 
Ok. 141471110820=serial number and 01= Id.

But you receive:
05014400 14 14 71 11 08 20 05 00
Where the 05 at the right come from ? You should receive a 00 at this place.

Sending header 05004804 and 8 bytes 14 14 71 11 08 20 00 00 does not give a reaction but that may be the arduino code.
That should work. You should receive after the temp+voltages+amp.

So check your arduino code. Remember the strange 05 that is displayed.
Could you test with a dongle and a pc with for example realterm ?

I have used a canusb and a pc. (With a elm327 125kb/s AND 29 bits header is not easy)

Any idea what the 1B means ?

I don't have this info. But I also saw 1B or 1C at this place. And also a power % or amperage % at the right byte (FF=40A for my flatpack 2 HE) after the serial number.
This don't seem interesting.

Be carefull to never send a 9 in place of the 4 just after the Id. This is for permanent changes (that don't work for my device...) Always send a 4 in all commands:

05004804 <- the 4 is in red color
 
SUCCES !

The arduino code was not sending an extended code but a standard code :? . The result when I changed the code to send an extended code :

05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 EF 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 EA 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 EF 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05000820 1B 14 14 71 11 08 20 0D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 EA 14 E1 00 2D
05014004 19 13 00 EF 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
05014004 19 13 00 EF 14 E1 00 2D
05014004 19 13 00 ED 14 E1 00 2D
Also the charger sends the messages much faster, about 0.25 seconds apart instead of 1 every 2 seconds

And after adding some code to translate the HEX numbers to readable data (and even calculating power by multiplying voltage and current) I had the Arduino outputting the following to the serial monitor (PC):

05014004 19 13 00 ED 14 E0 00 2D
Temperature = 25
Current = 1.90
OutputVoltage = 53.37
OutputPower = 101.40
InputVoltage = 224


The current of 1.90 Amps is accurate, I connected 4 pcs 21W 12V indicator bulbs in series to the charger and measured a current of 1.89 Amps and a voltage of 53.5 V so spot on.

For those interested in the Arduino Code (using a arduino UNO) and the base code/library from SEEEDstudio
https://github.com/Seeed-Studio/CAN_BUS_Shield

Code:
#include <mcp_can.h>
#include <mcp_can_dfs.h>
#include <SPI.h>

const int SPI_CS_PIN = 10;
MCP_CAN CAN(SPI_CS_PIN);                                                              // Set CS pin for CANBUS shield

void setup()                                                                          // Initialisation routine
{
    Serial.begin(115200);                                                             // Sets the data rate in bits per second (baud) for serial data transmission to PC.

START_INIT:

    if(CAN_OK == CAN.begin(CAN_125KBPS))                                              // init can bus : baudrate = 125k !!
    {
        Serial.println("CAN BUS Shield init ok!");
    }
    else
    {
        Serial.println("CAN BUS Shield init fail");
        Serial.println("Init CAN BUS Shield again");
        delay(100);
        goto START_INIT;
    }
}

void loop()                                                                           // main program (LOOP)
{
    unsigned char len = 0;
    unsigned char buf[8] ;
    if(CAN_MSGAVAIL == CAN.checkReceive())                                            // check if data coming
    {

        CAN.readMsgBuf(&len, buf);                                                    // read data,  len: data length, buf: data buf
          INT32U canId = CAN.getCanId();                                              // read the CAN Id
          Serial.print("0");                                                          // leading zero 
          Serial.print(canId,HEX);                                                    // output CAN Id to serial monitor
          Serial.print("\t");                                                         // send Tab
        for(int i = 0; i<len; i++)                                                    // print the data
        {
            if( buf[i] < 0x10){ Serial.print("0");} Serial.print(buf[i],HEX);         // send a leading zero if only one digit
            Serial.print(" ");                                                        // space to seperate bytes
        }
       Serial.println();
       Serial.print("Temperature = ");
       Serial.println(buf[0]);                                                        //first byte is temperature in celcius
       Serial.print("Current = ");
       Serial.println(buf[2]*255*0.1+buf[1]*0.1);                                     // third (msb) and second byte are current in 0.1A (deciamp) calculated to show directly in Amps
       Serial.print("OutputVoltage = ");
       Serial.println(buf[4]*255*0.01+buf[3]*0.01);                                   // fifth (msb) and fourth byte are voltage in 0.01V (centivolt) calculated to show directly in Volts dc
       Serial.print("OutputPower = ");
       Serial.println((buf[4]*255*0.01+buf[3]*0.01)*(buf[2]*255*0.1+buf[1]*0.1));     // Power is calculated from output voltage and current. Output is in Watts
       Serial.print("InputVoltage = ");          
       Serial.println(buf[5]);                                                        // sixth byte is input voltage in volts ac/dc
//send request for new update
       unsigned char stmp3[8] = {0x14, 0x14, 0x71, 0x11, 0x08, 0x20, 0x00, 0x00};     //this is the serial number of the unit
       CAN.sendMsgBuf(0x05004804, 1, 8, stmp3);                                       //send message to request updated figures
    }
 

}

/*********************************************************************************************************
  END FILE
*********************************************************************************************************/


Now for the big question : How to change the output voltage to 57.0 Volt :shock: 8)
 
That is perfect. 8)

You can now change temporally the output voltage.

You need been loging first
then
send 05 FF 40 04 header and 8 bytes FF FF LL MM LL MM LL MM

LL MM is your voltage in volts *100 same codding as previously (LSB left MSB right) For exemple FE 10 = 43.50v

This is a brodcast to all rectifiers on the can bus.
You need to send it 10th /second.

It work fine on my rectifier. You can even use this to adjust the amperage. If it is close the battery voltage, the amperage is reduced.

If you stop sending your rectifier will be logged off and voltage will go back to 53.50V

:D
 
IT WORKS :D WOOHOO

Here's a list of the requested output voltages (from 11 00 to 18 00), returned is the output voltage as reported by the charger and measured is the voltage (with no load) as measured with a multimeter.

// 00 10 should be 40.96 returned is 43.8 measured is 44.0
// 00 11 should be 43.52 returned is 43.7 measured is 43.6
// 00 12 should be 46.08 returned is 46.2 measured is 46.1
// 00 13 should be 48.64 returned is 48.8 measured is 48.7
// 00 14 should be 51.20 returned is 51.3 measured is 51.2
// 00 15 should be 53.76 returned is 53.8 measured is 53.8
// 00 16 should be 56.32 returned is 56.4 measured is 56.4
// 80 16 should be 57.60 returned is 57.0 measured is 56.9
// 00 17 should be 58.88 returned is 57.7 measured is 57.6
// 00 18 should be 61.44 returned is 57.7 measured is 57.6

The datasheet says the output voltage can be adjusted between 43.5 and 57.6 Volt and the list shows that as well. When going lower than 43.5 the output voltage stays at 43.5 and when going higher the voltage stays around 57.5 Volts

You only have to send the message with the new voltage once, but after that you have to keep requesting the status to keep being 'logged in', otherwise indeed the charger will default to 53.5 Volts after a few seconds.

THANKS A LOT PLANETAIRE !!! :D

I've added my revised code below for anyone who wants to know

Code:
#include <mcp_can.h>
#include <mcp_can_dfs.h>
#include <SPI.h>

const int SPI_CS_PIN = 10;
MCP_CAN CAN(SPI_CS_PIN);                                                              // Set CS pin for CANBUS shield

void setup()                                                                          // Initialisation routine
{
    Serial.begin(115200);                                                             // Sets the data rate in bits per second (baud) for serial data transmission to PC.
    delay(1000); 
START_INIT:

    if(CAN_OK == CAN.begin(CAN_125KBPS))                                              // init can bus : baudrate = 125k !!
    {
        Serial.println("CAN BUS Shield init ok!");
    }
    else
    {
        Serial.println("CAN BUS Shield init fail");
        Serial.println("Init CAN BUS Shield again");
        delay(100);
        goto START_INIT;
    }
       unsigned char stmp3[8] = {0x14, 0x14, 0x71, 0x11, 0x08, 0x20, 0x00, 0x00};     //this is the serial number of the unit
       CAN.sendMsgBuf(0x05004804, 1, 8, stmp3);                                       //send message to log in
       delay(10);   
       unsigned char stmp4[8] = {0xFF, 0xFF, 0x80, 0x16, 0x80, 0x16, 0x80, 0x16};     //this is the command for changing the output voltage 16 80 is the maximum voltage of 57.6 V
       CAN.sendMsgBuf(0x05FF4004, 1, 8, stmp4);                                       //send message to set ouput voltage to all chargers connected to the CAN-bus
//  00 10 should be 40.96 returned is 43.8 measured is 44.0
//  00 11 should be 43.52 returned is 43.7 measured is 43.6 
//  00 12 should be 46.08 returned is 46.2 measured is 46.1
//  00 13 should be 48.64 returned is 48.8 measured is 48.7
//  00 14 should be 51.20 returned is 51.3 measured is 51.2 
//  00 15 should be 53.76 returned is 53.8 measured is 53.8
//  00 16 should be 56.32 returned is 56.4 measured is 56.4
//  80 16 should be 57.60 returned is 57.0 measured is 56.9
//  00 17 should be 58.88 returned is 57.7 measured is 57.6
//  00 18 should be 61.44 returned is 57.7 measured is 57.6
      Serial.print("Output Voltage set to : ");
      Serial.println(stmp4[3]*256*0.01+stmp4[2]*0.01);
      

}

void loop()                                                                           // main program (LOOP)
{
    unsigned char len = 0;
    unsigned char buf[8] ;
    if(CAN_MSGAVAIL == CAN.checkReceive())                                            // check if data coming
    {

        CAN.readMsgBuf(&len, buf);                                                    // read data,  len: data length, buf: data buf
          INT32U canId = CAN.getCanId();                                              // read the CAN Id
          Serial.print("0");                                                          // leading zero 
          Serial.print(canId,HEX);                                                    // output CAN Id to serial monitor
          Serial.print("\t");                                                         // send Tab
        for(int i = 0; i<len; i++)                                                    // print the data
        {
            if( buf[i] < 0x10){ Serial.print("0");} Serial.print(buf[i],HEX);         // send a leading zero if only one digit
            Serial.print(" ");                                                        // space to seperate bytes
        }
       Serial.println();
       Serial.print("Temperature = ");
       Serial.println(buf[0]);                                                        //first byte is temperature in celcius
       Serial.print("Current = ");
       Serial.println(buf[2]*256*0.1+buf[1]*0.1);                                     // third (msb) and second byte are current in 0.1A (deciamp) calculated to show directly in Amps
       Serial.print("OutputVoltage = ");
       Serial.println(buf[4]*256*0.01+buf[3]*0.01);                                   // fifth (msb) and fourth byte are voltage in 0.01V (centivolt) calculated to show directly in Volts dc
       Serial.print("OutputPower = ");
       Serial.println((buf[4]*256*0.01+buf[3]*0.01)*(buf[2]*256*0.1+buf[1]*0.1));     // Power is calculated from output voltage and current. Output is in Watts
       Serial.print("InputVoltage = ");          
       Serial.println(buf[5]);                                                        // sixth byte is input voltage in volts ac/dc
//send request for new update
       unsigned char stmp3[8] = {0x14, 0x14, 0x71, 0x11, 0x08, 0x20, 0x00, 0x00};     //this is the serial number of the unit
       CAN.sendMsgBuf(0x05004804, 1, 8, stmp3);                                       //send message to request updated figures and keep being 'logged in' or the charger defaults to 53.5 V
       

    }
 

}

/*********************************************************************************************************
  END FILE
*********************************************************************************************************/

Planetaire, do you have more info on the current limiting as well, i imagine it is the same format as the voltage adjustment, and are there more adjustments available.
And is there any way to make the voltage output change permanent so i wouldn't need the Arduino every time ?
 
Back
Top