- Main menu refactored to reduce info levels. Old "tutorials" are now part
of the "More Information" (which already contained tutorials) on eLua
Internals
- Shell help command adapted to rw filesystems addition (ls lists all files
of all filesystems)
- Minor order and name changes on main menu sub-items
- Minor refinements in some doc pages
- FAT changed to support the new opendir/readdir/closedir mechanism, and to use lseek directly instead of ioctl (also fixed a bug in FAT's lseek that always returned 0 instead of file position).
- ET-STM32 console moved to UART2@19200bps (to allow RFS to run on UART0). If UART0 is needee for console, remember to disable RFS.
- freed 700+ bytes of RAM by changing the devman implementation to keep pointers instead of actual DM_DEVICE structures
- other minor code changes and fixes
- added some more documentation (not yet done)
- alternate uarts can be selected (boot mode defaults to console uarts)
- renamed "remote" references to "rpc" (may as well keep the original name)
- switch default error handler to luaL_error (presumably wasn't available for
old 4.x LuaRPC)
- tweaks to exception handling to make things more consistent (hopefully)
- disabled by default (enable on a target-by-target basis) so it shouldn't
cause much breakage for non-rpc users
- some modifications to the binary chunk reader which should allow reading of
chunks encoded on various platforms (with certain limitations like lualong
can't read float lua bytecode, one must generate lualong bytecode from a float
lua)
- other misc changes.
- adc_wait_samples now returns the actual number of samples available at the
time it returns. this simplifies a pattern where one would wait on samples
if blocking and then subsequently check the number of available samples.
- adc.insertsamples(id, table, idx, count) function now available to take
samples and insert them into a table. this is slightly slower than
assignment for single values in a table, but can avoid having to use
getsamples (returning new tables) for certain situations
idx: starting index in table where values will be inserted
count: number of samples to get from channel id
of flash space.
NOTE: getsamples function is disabled since this is dependant on having a
buffer to get more than one sample.
Side note: single sampling without the buffer is faster by about 5-10
us/channel. It should be possible to sidestep the buffer in certain
situations for buffer enabled mode and get a similar benefit at the cost of
some additional complexity.
- ADC adjusted to work with sequenced acquisition setups. It should now
accomodate both sequenced and non-sequenced approaches on the backend.
A few more adjustments should be made to handle multiple sequencers
but right now neither LM3S or STM32 platforms use more than one sequencer.
- Added adcpoll.lua to demonstrate a simple approach for using clocked
acquisition and displaying results as they become available.
- ADC now works for STM32 (all 16 channels!). This should receive more
extensive testing, but everything should be working at this stage.
- the build system now pays attention to changes in header files meaning that
if any headers change or if the romfs changes (since it is generated as a
header) these changes will get recompiled without having to do a clean.
- removed getsmoothing, setfreerunning, samplesready
- isdone has returned so that one can check if the reason why the buffer is
dry is because no more samples are being collected
- smoothing should support fairly large lengths now (as long as you have the
memory)
- added support to adc.sample to take a table as the first argument so that a
set of channels can be started at closer to the same time.
example:
adcchannels = {0,1,2,3}
adc.sample(adcchannels,8)
this should collect samples on all 4 channels starting nearly at the same
time.
- more comments added to elua_adc.c to describe behavior.
Misc
- remove rndpow2, not being used
- "building" page completely rewritten
- a new page about the toolchains used in eLua
- a graphical representation of the system architecture (doc/wb_img/elua_arch.png) that will be used in a soon to come page about the eLua architecture
Also:
- validate.h updated with some new tests (still needs more work)
- "arm-gcc-eabi" toolchain name changed to "codesourcery", since this is obviously way more intuitive :)
is full). Clock and sampling frequency have been moved to a separate function
from burst. There is now one function to initiate sampling called sample
which takes a channel and count. setclock takes a channel, clock_id, and
frequency. Adjustments should be made to make channel groupings somewhat
cleaner, but this is functional.
Suggestions are welcome for simplification :-)
I'll try and make some doc updates in the coming day or so to reflect
finalized adjustments.
Recommended only for systems with very low memory (Flash/RAM), and prefferably systems running only precompiled Lua (if you need to compile the code, you might get into stack overflows, and this allocator is much more sensitive to this kind of stuff than dlmalloc()). In fact, this allocator seems to suggest that one should set the stack to at least 4k for the Lua parser to run properly even on small programs. I won't do this just yet, rather I'll keep on trying to move the Lua parser data structures from stack to heap. For now we're OK with the current configuration.
The allocator can handle multiple memory spaces.
Enable with "allocator=simple" on the scons command line.
...oh yes, also added a newline to the end of elua_adc.c :) (to avoid some annoying warnings)
for me as memcpy did.
Check out inc/utils.h, since this Duff's device is implemented as a macro
which could be used for unrolling other loops selectively.
- new addition to the PIO module: now you can use pin ranges in PIO expressions. For example:
gpio.PA_3_6_DIR = gpio.OUTPUT -- make pins 3-6 from PORTA outputs
gpio.PB_0_30_PULL = gpio.PULLUP -- activate pullups on all but the last pin of PORTB
gpio.PB_3_6 = 11 -- set value 10 (1011) to pins 3-6 of PB (so PB.6 == 1, PB.5 == 0, PB.4 == 1, PB.3 == 1 )
value = gpio.PB_2_9 -- read the value of pins 2-9 of PB into 'value'
Of course, one can still specify a single pin instead of a range.
This is still tested, but seems to work fine for now.
- romfs/ samples updated to work with the new module name and syntax
- small fix to buf.c (in the BUF_MOD_INCR macro).
buf.c.
The smoothing buffer is still kept separate from the main buffering system,
but as samples come in via interrupt, they are placed into a "standard" elua
buf. The size of this buf is configured according to whether one is grabbing
a bunch of samples rapidly (burst), or singly in order to accommodate the
expected number of incoming samples. If smoothing is enabled, incoming
samples are claimed until the smoothing buffer is full, and then remaining
samples are left in the main buffer until they are collected. This means that
whether one is collecting single samples or samples at burst rate, and
smoothing is enabled, the filter will only be providing samples that have
enough history.
Added a function to manually flush both smoothing and main buffers.
This would be useful if you know your state has changed and you only want
fresh samples that are going to be collected after a flush.
Also, a lot of functionality moved into elua_adc.c and common.c
(boundaries for what belongs where, might be evaluated), reducing the number
of platform.c specific functions dramatically.
Basic functionality seems to be working, but some more testing should be done.
Also, given that there's now a dynamic buffer behind everything, a shift in
the way sampling is handled could be done:
sample and burst functions could be made to be non-blocking, and to never
return anything except for errors.
a separate getsamples function could be used for removing samples collected by
either function from the buffer.
Suggestions are welcome as it would be nice to keep usage paradigms stable
after the 0.6 release.
- complete rewrite of the PIO module. New usage:
pio.PA = 10 -- set the value of PA to 10
pio.PB_1 = 1 -- set the value of pin 1 of PB to 1
local value = pio.PB -- get the value of PB
local value = pio.PB_3 -- get the value of pin 3 of PB
pio.PA_DIR = pio.OUTPUT/pio.INPUT - set the direction of PA
pio.dir[ pio.PA ] = pio.OUTPUT/pio.INPUT - same as above
pio.PA_2_DIR = pio.OUTPUT/pio.INPUT - set the direction of pin 2 of PA
pio.dir[ pio.PA_2 ] = pio.OUTPUT/pio.INPUT - same as above
pio.PA_PULL = pio.PULLUP/pio.PULLDOWN/pio.NOPULL - set pulls on PA
pio.pull[ pio.PA ] = pio.PULLUP/pio.PULLDOWN/pio.NOPULL - same as above
pio.P0_3_PULL = pio.PULLUP/pio.PULLDOWN/pio.NOPULL - set pulls on pin 3 of P0
pio.pull[ pio.P0_3 ] = pio.PULLUP/pio.PULLDOWN/pio.NOPULL - same as above
- samples modified to use the new PIO syntax
- bugfix in AT91SAM7X256 UART int handler
- fixed yet another bug in AVR32's libc (actually replaced strcmp (which is broken on AVR32) with a custom version).
Code which was previously using buffer has been updated to work with the
changes.
API has also changed in accordance:
int buf_set(unsigned resid, unsigned resnum, u8 logsize, size_t dsize);
int buf_is_enabled( unsigned resid, unsigned resnum );
unsigned buf_get_size( unsigned resid, unsigned resnum );
unsigned buf_get_count( unsigned resid, unsigned resnum );
int buf_write( unsigned resid, unsigned resnum, t_buf_data *data, size_t dsize );
int buf_read( unsigned resid, unsigned resnum, t_buf_data *data, size_t dsize );
Essentially buf_rx_cb and buf_get_char have been renamed to buf_write and
buf_read. For these, one now passes a pointer to where the data is coming
from or going to, and a dsize parameter indicating how many bytes should be
copied. Also, buf_set takes this same dsize parameter, and keeps it in the
struct. This allows us to ensure that when data is read or written the
number of bytes matches the buffer element size.
I thought about maintaining compatibility functions to provide the original
buf_rx_cb and buf_get_byte API calls, however there weren't a large number
of uses of buf, so it wasn't hard to convert things.
One caveat: BUF_MOD_INCR assumes that byte counts for alternate type sizes
will be powers of 2.
Also, BUF_SIZE_xx's are assumed to refer to element counts.
- UART buffering enabled on LM3S
This doesn't include switching the ADC code over to using these buffers quite
yet.
I'm open to comments on these modifications if theres a better or simpler
approach. I've checked to make sure buffers work on LM3S, but I don't own any
other platforms to make sure there aren't unintended side-effects.
- now uses bitfields rather than HWREGBITW for keeping track of state
- started generalizing functionality for smoothing, state tracking etc... into
separate functions
- burst mode now works, including with smoothing enabled (only operates in a
blocking mode, non-blocking to come later)
channel. Smoothing support (rolling average) has been added. adcscope has
been updated to reflect these changes, and show output from 4 channels at
once.
- fix for typo in stm32/platform.c
the heap instead of the stack. Also, the stack size was bumped to at least
2048 bytes on all backends. Hopefully this will take care of most issues
related to stack overflows.
- new buffering system available. Originally I planned to make it fully
generic, but I came to the conclusions that this would take too much
development work and system resources (RAM/Flash) if done properly, so
currently it's only used on UART RX (although it could be easily extended
for other peripherals). For an example of use check the AT91SAM7X and
AVR32 backend (platform_init and associated interrupt handlers and also
platform_conf.h).
- new XMODEM implementation. Better, cleaner, bug fixed, and BSD instead of
GPL.
- AVR32 can use the huge (32MBytes) SDRAM on the board as system memory now.
- fixed an error in elua_sbrk/_sbrk_r (and revised the compilation options
for dlmalloc).
- added the CPU module and interrupt support on the STR9 platform.
- uart module changes: 'sendstr' is out, but the regular 'send' will send
strings instead of simple chars (which makes sense since Lua doesn't have
a "char" type). Also, the 'timer_id' and 'timout' parameters of the 'recv'
function are now optional.
- all eLua modules updated to work with LTR
- "cpu" module added to avr32, at91sam7x, str7
- "disp" module no longer generic (now stays in src/modules/lm3s). For this reason, the "disp" platform interface was also removed.
- the "modcommon" mechanism in STM32 (ROM loader) was depreciated in favour of the Lua Tiny RAM patch (and the "stm3210lcd" module from the STM32 backend now uses LTR).
- small bugfixes
- added virtual timers (on LM3S, AVR32 and AT91SAM7 for now)
- added interrupt handling code for AT91SAM7 and AVR32
- fixed two serious bugs that prevented the eLua image to run on both STR9 and LPC2888 (linker command file issues)
- fixed line endings (DOS->UNIX) in the STM32 library files
- fixed preprocessor errors (hopefully all of them) like #if ELUA_CPU == LM3S8962
- other minor or less than minor fixes :)
- ls shell command enhanced with column aligned file sizes and total size report
- New section on CHANGELOG for ongoing dev changes, to ease up next release
- pong.lua added to examples in romfs
- minor URL and e-mail updates, to reflect the new eluaproject.net domain
