Do you want to use your compiled C function in Lua, or do you want to convert a C procedure into its equivalent in Lua? If the latter, it depends on how complex the code in question is: mathematic operations can be copied and pasted with no changes, but things such as pointer arithmetic will require heavy re-architecting of the code's design. (This software works with AVR and ESP8266 architecture) This is a tool help to convert Arduino C/C code to Assembly code.Step 1: Choose the Arduino.elf file (generated when you compile C/C code in the IDE, usually located in Temp folder). Step 2: Choose the output txt file, the assembly code will be written to this file. Step 3: Click Convert.

As some of you know I have a 32x32 led matrix, and making graphics for it could be a tedious process. For my original 2 bitmaps I drew them using the gimp saved them as ASCII formatted pbm files and formatted them by hand into arrays, yay fun!

so moving forward I decided to make a hacky little lua script that converts *.pbm files into C arrays

goal: convert this

into this

without having to touch any of it

Script:
this is a lua script, so you need a lua interpreter installed, doing a google search for lua.exe (windows) the first result turns up version 5.0.2, this is or at least was the default version included with different linux distros, so this script is compatible with lua 5.0.2 or newer

Images MUST be a power of 2 in their X dimension (width must be 8, 16, 32, 64 etc), Y (height) really does not matter much, so if you made a custom 16x9 matrix this should work, the following resolutions have been tested to work

8x8
16x8
32x32
1024x1024 (and it took like 6 min on a dualcore 2.8ghz pc)

Usage:
Make an monochrome image in the gimp, save it as a pbm file and save it in ASCII format

copy the image to the same folder as script (on windows I have my script and images saved in the same folder as lua so I don’t have to fiddle around with environment stuff)

edit the script, changing the file name to which ever image you want to convert, save and close

open a command line, goto the folder where everything is and run the script (lua pbm2C.lua)

and there you go

have fun ;D

This page describes the API functions provided by the FFI library indetail. It's recommended to read through theintroduction and theFFI tutorial first.

Glossary

cdecl — An abstract C type declaration (a Luastring).
ctype — A C type object. This is a special kind ofcdata returned by ffi.typeof(). It serves as acdataconstructor when called.
cdata — A C data object. It holds a value of thecorresponding ctype.
ct — A C type specification which can be used formost of the API functions. Either a cdecl, a ctype or acdata serving as a template type.
cb — A callback object. This is a C data objectholding a special function pointer. Calling this function fromC code runs an associated Lua function.
VLA — A variable-length array is declared with a? instead of the number of elements, e.g. 'int[?]'.The number of elements (nelem) must be given when it'screated.
VLS — A variable-length struct is a struct Ctype where the last element is a VLA. The same rules fordeclaration and creation apply.

Declaring and Accessing External Symbols

External symbols must be declared first and can then be accessed byindexing a C librarynamespace, which automatically binds the symbol to a specificlibrary.

`ffi.cdef(def)`

Adds multiple C declarations for types or external symbols (namedvariables or functions). def must be a Lua string. It'srecommended to use the syntactic sugar for string arguments asfollows:

The contents of the string (the part in green above) must be asequence ofC declarations,separated by semicolons. The trailing semicolon for a singledeclaration may be omitted.

Please note that external symbols are only declared, but theyare not bound to any specific address, yet. Binding isachieved with C library namespaces (see below).

C declarations are not passed through a C pre-processor,yet. No pre-processor tokens are allowed, except for#pragma pack. Replace #define in existingC header files with enum, static constor typedef and/or pass the files through an externalC pre-processor (once). Be careful not to include unneeded orredundant declarations from unrelated header files.

`ffi.C`

This is the default C library namespace — note theuppercase 'C'. It binds to the default set of symbols orlibraries on the target system. These are more or less the same as aC compiler would offer by default, without specifying extra linklibraries.

On POSIX systems, this binds to symbols in the default or globalnamespace. This includes all exported symbols from the executable andany libraries loaded into the global namespace. This includes at leastlibc, libm, libdl (on Linux),libgcc (if compiled with GCC), as well as any exportedsymbols from the Lua/C API provided by LuaJIT itself.

On Windows systems, this binds to symbols exported from the*.exe, the lua51.dll (i.e. the Lua/C APIprovided by LuaJIT itself), the C runtime library LuaJIT was linkedwith (msvcrt*.dll), kernel32.dll,user32.dll and gdi32.dll.

`clib = ffi.load(name [,global])`

This loads the dynamic library given by name and returnsa new C library namespace which binds to its symbols. On POSIXsystems, if global is true, the library symbols areloaded into the global namespace, too.

If name is a path, the library is loaded from this path.Otherwise name is canonicalized in a system-dependent way andsearched in the default search path for dynamic libraries:

On POSIX systems, if the name contains no dot, the extension.so is appended. Also, the lib prefix is prependedif necessary. So ffi.load('z') looks for 'libz.so'in the default shared library search path.

On Windows systems, if the name contains no dot, the extension.dll is appended. So ffi.load('ws2_32') looks for'ws2_32.dll' in the default DLL search path.

Creating cdata Objects

The following API functions create cdata objects (type()returns 'cdata'). All created cdata objects aregarbage collected.

`cdata = ffi.new(ct [,nelem] [,init...]) cdata = ctype([nelem,] [init...])`

Creates a cdata object for the given ct. VLA/VLS typesrequire the nelem argument. The second syntax uses a ctype asa constructor and is otherwise fully equivalent.

The cdata object is initialized according to therules for initializers,using the optional init arguments. Excess initializers causean error.

Performance notice: if you want to create many objects of one kind,parse the cdecl only once and get its ctype withffi.typeof(). Then use the ctype as a constructor repeatedly.

Please note that an anonymous struct declaration implicitlycreates a new and distinguished ctype every time you use it forffi.new(). This is probably not what you want,especially if you create more than one cdata object. Different anonymousstructs are not considered assignment-compatible by theC standard, even though they may have the same fields! Also, theyare considered different types by the JIT-compiler, which may cause anexcessive number of traces. It's strongly suggested to either declarea named struct or typedef with ffi.cdef()or to create a single ctype object for an anonymous structwith ffi.typeof().

`ctype = ffi.typeof(ct)`

Creates a ctype object for the given ct.

This function is especially useful to parse a cdecl only once and thenuse the resulting ctype object as a constructor.

`cdata = ffi.cast(ct, init)`

Creates a scalar cdata object for the given ct. The cdataobject is initialized with init using the 'cast' variant ofthe C type conversionrules.

This functions is mainly useful to ov

Glossary

Declaring and Accessing External Symbols

ffi.cdef(def)

ffi.C

clib = ffi.load(name [,global])

Convert From Lua To C