What is the colon equals sign ( := ) in makefiles?

Andrew (2015/06/23):  I posted this article on a blog many months ago, which has long since disappeared off the internet.  A few people found it useful at the time, so I decided to repost it here:

In Linux Makefiles, you will often see a notation which looks like this:

This is called "expansion assignment".
So what's the difference between expansion assignment and ordinary variable assignment (=)? Let's get straight into a coding example:

So nothing unexpected or unusual here! But lets try the same thing using expansion assignment ( := ):

Oh no! It appears that we have a frog instead of the porcupine we wanted. So what happened?
When using the equals sign the variable is only expanded when used. In other words, when we run test.

In the second example we used ":=".  This means that the variable is expanded at the time of assignment. If we want to see PORCUPINE again in the second example, we need to make a slight modification to it:

Serio: A serial file transfer program without needing z/y/xmodem

In one of my previous posts I talked about using zmodem as a backup/emergency method to transfer files onto an embedded device using the serial console.  This technique requires you to have the lrz binary on the target to initiate the transfer.  But what happens if you have no way of getting lrz onto the target in the first place?  In this post I show you a method of serial transfer requiring no binaries to be on the target, and absolutely no setup on the target-side.

First, check that you have a Python 2.x version installed.  If you don't, apt-get or yum install it onto your host OS.  Check the version with python --version.

Now get the utility, which is called 'serio'.  Get it with hg clone https://code.google.com/p/serio/. Before you go ahead, there are two patches you need to apply (by hand):

Patch 1:
Insert self.last_size = 0 at the location shown, highlighted in green:
if callable(fp.read) and callable(fp.write) and callable(fp.readline) and callable (fp.readlines):
                        self.fp = fp
                        self.current = 0
                        self.showprogress = progress
                        self.last_size = 0 

Patch 2:
Get rid of this line, on line 19:
self.s.open()

and insert these lines instead:
already_open = self.s.isOpen()
if not already_open:
        self.s.open()

Update (14 June 2015): I tried this again recently.  It seems you may need to use self.serial.isOpen() and self.serial.open() instead.

That patch above is for people who get the "Port is already open" error.  Now you can run the utility:


sudo ./serio -s lrz -d lrz -p /dev/ttyS0

where -s is the source file, -d is the destination, and -p is the serial (console) port.  You'll get a nice progress bar.

I recommend putting lrz onto your target (as per my example) so you can do zmodem transfers from here on in.

Help!  It transfers, but the executable doesn't work!

• Check that the echo command on your target supports the "-n" and "-e" options (that's all you need).
• Try cross-compiling a minimal "hello world" program with your toolchain and try transferring that, as a test.  Run it, and if you see "hello world" your settings are probably OK.  See the next point...
• Open the source code and modify the parameter IO_TIME = .1 to be something greater than .1 (try .3 or .5).
• In addition to the previous step, try using your toolchain's strip command to reduce the size of the binary.

Zmodem and minicom

Zmodem is a great "emergency backup" way of getting files on and off your target board when all other methods (SD card, ethernet, etc.) have stopped working or you don't have those functions yet.

In order to use Zmodem with Minicom, you need to first cross-compile the 'lrzsz' source code.

What happens if I can't get this file onto my target to begin with?   If this your situation, don't panic!  See my other serial transfers post.


Do a google search for lrzsz-0.12.20.tar.gz, untar it, and configure it with the following command:

CC=arm-linux-uclibc-gcc ./configure --host=arm-linux-uclibc --prefix=/home/andrew/lrzsz_out/

You'll obviously need to replace the CC, --host and --prefix with your own.  Then run:

make; make install

From all the binaries which are built, you're only going to need lrz (for receiving) and lsz (for sending).

If you want to receive a file (that is, get a file onto your target board), you first run the ./lrz binary from anywhere on the target's filesystem, and you'll get a message 'waiting to receive' (along with some ascii garble).

Then you press ctrl+a+z and then s , and then choose 'zmodem'.








After you select 'zmodem' and choose your file from the file browser, you'll see the file uploading to your target, with an ETA (time left).


Sending works similarly, except you use the ./lsz binary and select "receive" from the minicom menu instead.