sending binary files to a 16 micro controller.

[johnny.karlsson]

Hi, I'm working on a project were a need to be able to upload firmware
to a microcontroller based Ethernet device. But because of the memory
constraints the controller can only handle packages of 300 bytes each
time. So therefore the firmware file must be sent in chunks and i need
a header in each file describing which part of the file it is I'm
sending. Could anyone give me some pointer on how a could accomplish
that in python? I'm talking about the client that uploads the software
to the device via TCP.

Best regards

Johnny Karlsson

[Nick Craig-Wood]

Grant Edwards <gr****@visi.co m> wrote:

You have no control over packet size in TCP if you use the
normal socket interface. About the only thing you can to is
put delays between calls to send() in hope that the TCP stack
will send a packet.
You can set the MTU (maximum transfer unit) for that interface. You
do with with ifconfig under un*x - I expect windows has an interface
to do it too (perhaps ipconfig?)

For ethernet the MTU is 1500 bytes normally.
If you really do want control over packet size, you'll have to
use a raw socket and impliment TCP yourself.

Actually I'd recommend the OP uses UDP, not TCP. I've implemented a
few systems which speak UDP directly and its very easy. I wouldn't
like to implement TCP though!

--
Nick Craig-Wood <ni**@craig-wood.com> -- http://www.craig-wood.com/nick

[johnny.karlsson]

yeah, i didn't mean running python on the HC12 but using compiled
python on a ARM7 or simular would be nice. There was a project for
embedded python but it seems to have died. Yeah i've been thinking
about using UDP but then i would have to impliment checksums and having
a reliable way to send and acknowlege the chunks sent. But i'll start
tinkering with it tomorow and se what i'll end up with. I allready have
a tcp-server for the device so it would'nt be to much hassle to modify
it. i'm using OpenTCP by the way.

[Tom Anderson]

On Mon, 22 Aug 2005, Grant Edwards wrote:

On 2005-08-22, Magnus Lycka <ly***@carmen.s e> wrote:

Hi, I'm working on a project were a need to be able to upload firmware
to a microcontroller based Ethernet device. But because of the memory
constraints the controller can only handle packages of 300 bytes each
time. So therefore the firmware file must be sent in chunks

It's very probable that the TCP stack will combine chunks and
send out full Ethernet frames (4K bytes).

Those are *very* full ethernet frames!

It seems to me that if the receiver can only handle a certain amount of
data at a time, this should be reflected in its receive window; it should
never advertise a bigger window than it can handle. if that's the case,
the program should be able to write data as fast as it likes, as the
sending TCP module will throttle it down so it goes out in right-sized
drips. I'm not a TCP expert, though.

Anyway, if you are going the small-writes route, make sure you set the
TCP_NODELAY flag, to turn of Nagleing on the connection. I'm not sure if
anyone mentioned that already.

tom

--
sh(1) was the first MOO