atmel-studioavr-gcc
I'm new with Atmel Studio and I'm playing with ATtiny13. This mcu has 1K Bytes of Flash, 64 Bytes of EEPROM and 64 Bytes of SRAM.
I would like to know how much memory (flash, eeprom and sram) my code takes.
This is a piece of my compilation output.
I think my code takes 882 bytes of Flash and 15 bytes of EEPROM. Is that right?
Thanks in advance.
There are plenty of ways you could do something like this. Assuming you're using AVR gcc, you could use the utility functions in util/delay.h, specifically _delay_ms() would be applicable for your requirement. You can find the documentation at www.nongnu.org/avr-libc/user-manual/group_util_delay.html. Note, however, that there is a maximum delay that you can generate using these functions, depending on your clock speed. If you want to delay for longer, then you'll have to use some sort of a loop that calls it repeatedly. The typical way to use it in your case would be to do what your function has, then delay, and then disable your motors and such. There are some disadvantages to using this method, though. First, these delays are essentially for loops simply looping around for some number of iterations. This means that they aren't exactly accurate. Also, any interrupts that may be happening will cause this time to stretch.
When writing firmware it is often best to avoid using these kinds of delays. Not only are they inaccurate, they are also blocking calls. For the duration of the delay, the processor can't run any other code (unless from within an interrupt, which throws off the delay). There are better ways to solve your problem, but they do need more work. One way is to configure a timer to interrupt after the time you require, and then use code that is called by the interrupt handler to stop the motor. The 'good' way to do this would be to set a flag inside the interrupt and have the main loop check for this flag. This way, the main loop can keep tabs on multiple things in parallel and execute code at the correct time.
More complicated systems could use an RTOS to do this, but they often come with more baggage than is worthwhile unless you really need high precision and have many different things that have to happen in parallel.
Check out Tools-Device Programming. That should bring up the following dialog...
...which lets you directly read/program the eeprom to/from a file.
Best Answer
The amount of memory your program uses has already been answered in the comments, but I would like to clarify how these different types of memory are used.
Flash is used to store the machine code that the CPU executes. It is nonvolatile, and is generally not modified at run-time (i.e. the flash is written once during upload, but it is not modified later by the CPU).
SRAM is where variables are stored. It is volatile, so the nothing is written into SRAM while the code is being uploaded. Rather, it is only modified by the CPU while it is running.
EEPROM is nonvolatile, but can also be modified by the CPU while it is running. The only way to access it is with special EEPROM registers such as EEDR, the EEPROM data register, EECR, the EEPROM control register, EEAR, the EEPROM address register, and several others. In order to read a byte of EEPROM for example, you must load the address of the byte you want into EEAR, then read the byte from EEDR. It is thus much slower to access EEPROM than SRAM. There is really no reason to use EEPROM except when you have modifiable data that you want to keep even when the ATtiny is unplugged.
By default, the compiler does not store any data in EEPROM, though it can be configured to do so.