Adam Heinrich

Parametric stand for synthesizers in OpenSCAD

2020-11-28T00:00:00+01:00

When looking for a suitable stand for my beloved Vector synthesizer on Thingiverse and other repositories, none of them suited my needs. Most importantly I was not impressed by the traditional construction of stands made of two pieces connected by threaded rods – the stand had to be able to fit the limited space of my drawer when not being used.

Therefore I designed yet another parametric stand which consists of two identical parts. Because the parts are wide enough, they can stand upright on they own and do not require any supporting hardware in between. The stand also has rubber feet both on the bottom of the stand and on the hypotenuse to increase friction.

Although the stand is designed to be printed on a 3D printer (for this particular print I used the awesome transparent red PETG by Plasty Mladeč with 3 perimeters for increased strength and equalized number of top and bottom layers for consistent transparency), it is also possible to generate a 2D cross-section which can be used for manufacturing by other means.

The GPL-licensed OpenSCAD source code and detailed instructions can be found on GitHub. The model is parametric so it is possible to change the dimensions, angle or the geometry of the rubber feet used.

C cheatsheet

2018-02-25T00:00:00+01:00

This is a short collection of notes on the C language which are important especially when dealing with hardware.

Data types

Type sizes

The exact size of integer data types is implementation-specific. Only minimum ranges are defined (§5.2.4.2.1):

Type	Signed range	Unsigned range	Size*
`char`	±127	0 to 255	8 bits
`int`, `short`	±32767	0 to 65535	16 bits
`long`	±2147483647	0 to (2³²-1)	32 bits
`long long`	±(2⁶³-1)	0 to (2⁶⁴-1)	64 bits

Important notes:

Whether a char is treated as signed char or unsigned char is up to the implementation (see “Implementation-defined behavior”).
The size in bits is not defined by the standard (ditto).
There is no implicit assumption that negative numbers are represented by two’s complement (which is the most common case). Consequences:
- Range is ±(2^(N-1) - 1) rather than -2^(N-1) to 2^(N-1) - 1.
- Undefined behavior for signed overflow.

The int type usually represents the natural processor word. However, this is not the case for 8-bit architectures or for some 64-bit systems.

To write portable code, use types defined in <stdint.h> (e.g. uint32_t) where size matters.

The sizeof operator

The sizeof operator (not a function) gives object size in “bytes” (§6.5.3.4). However, because the standard mandates that sizeof(char) equals to 1, the term “byte” is not understood as an octet (8 bits) – simply because a char can be represented by more than 8 bits. To get size in bits, multiply the result of the sizeof operator by CHAR_BITS (defined in <limits.h>).

Its result is an unsigned integer of type size_t (defined in <stddef.h>). Therefore, the size_t type is guaranteed to hold size of any possible object including arrays. This makes it useful for portable array indexing.

Integer promotion

The following code prints c != 0xff given that it is compiled on a platform where char is treated as signed:

char c = 0xff;
if (c == 0xff)
    printf("c == 0xff\n");
else
    printf("c != 0xff\n");

This is the effect of integer promotion (§6.3.1.1):

If an int can represent all values of the original type, the value is converted to an int; otherwise, it is converted to an unsigned int. These are called the integer promotions. All other types are unchanged by the integer promotions.

The value 0xff (255 in decimal) assigned to c is outside the range ±127 defined for signed char; given that the machine uses two’s complement representation, the value of c is interpreted as -1.

Because all values of signed char are representable in int, both operands of the comparison (c == 0xff) are promoted to int. While the 0xff literal is represented by 0x000000ff on a machine with 32-bit int, the negative value of c will be represented as 0xffffffff after the promotion. And obviously, 0x000000ff and 0xffffffff do not match.

Possible fixes to print c == 0xff:

Declare c as unsigned char or uint8_t. In this case, both operands are interpreted as 255 and 0x000000ff will be compared to 0x000000ff.
Cast 0xff to char in the comparison: (chat)0xff. In this case, both operands are interpreted as -1 and 0xffffffff is be compared to 0xffffffff.

Structures

General rules:

The address of the structure is the address of its first member, i.e. the first member’s offset is always 0.
Ordering of members is preserved in memory, i.e. a member’s offset is greater than offset of previously declared members.
The compiler might add padding between two consecutive members or at the end of the structure.

Designated initializers

It is often desirable to only set a subset of structure members and zero the others (e.g. for structures with automatic storage which are allocated on stack or for compatibility with future versions of APIs).

A common approach is to use memset() from <string.h> to clear the structure before assigning individual members:

struct foo {
    int f1;
    int f2;
} s;

memset(&s, 0, sizeof(s));
s.f1 = 1;

However, a better option is to use a designated initializer. In this case, members not assigned by the initializer will be automatically initialized to zero:

struct foo s = { .f1 = 1 };

Or, when assigning a new value:

s = (struct foo) { .f1 = 1 };

Behavior

The following lists present the most important examples or undefined behavior, unspecified behavior and implementation-defined behavior. For a complete list, refer to annex J of the C standard.

Undefined behavior

Using uninitialized variables with automatic storage which never had its address taken (§6.3.2.1). If the address has been taken, the value is “just” indeterminate
Using object outside its lifetime (§6.2.4)
Signed integer overflow
Buffer overflow (accessing array elements outside bounds)
Dereferencing NULL pointer (§6.3.2)
Modification of string literals (§6.4.5) and const objects (§6.7.3)
Left shifting past bit-width (e.g. 1UL << 32 for 32-bit int)

Moreover, shifting value into or past the sign bit is also undefined behavior. More precisely, it happens the resulting value is not representable in result type (because signed integer overflow is undefined). This is the case when shifting signed positive value by 31 bits on an architecture with 32-bit int (and two’s complement representation of signed integers):

int foo = (1 << 31); /* Undefined behavior */

To avoid undefined behavior when left-shifting, use unsigned literals and do not exceed result type size:

uint32_t bar = (1UL << 31);

Implementation-defined behavior

The number of bits in char, defined in CHAR_BITS (§3.6)
Whether char is treated as signed char or unsigned char (§6.2.5)
Expansion of the NULL macro (§3.6) – it doesn’t have to be ((void*)0). However:
- Using if (!ptr) to check for a null pointer is correct because an expression with value 0 cast to void * is a null pointer constant (§6.3.2.3)
- It is safe to assume that static char *str will be initialized to a null pointer (§6.7.8)
Representation of signed integer types (§6.2.6.2)
Can be either sign and magnitude, one’s complement or two’s complement
However, intN_t types from <stdint.h> have to represent integers with two’s complement representation (§7.18.11.1).
Right-shifting negative values (§6.5.7)
Endianness

Unspecified behavior

Evaluation order of operands except for &&, ||, ?: and , (§6.5)
- The exception is handy for constructions like if (str != NULL && *str != '\0').
Evaluation order of function arguments (§6.5.2.2)

Function prototypes

Prototype void foo(void) declares a function which takes no arguments, whereas prototype void foo() declares a function accepting any number of arguments.

Prototype for the main function can be either int main(int argc, char *argv[]) or int main(void) (§5.1.2.2.1). Moreover, it is not necessary to explicitly return a value from main (§5.1.2.2.3):

If the return type of the main function is a type compatible with int, a return from the initial call to the main function is equivalent to calling the exit function with the value returned by the main function as its argument; reaching the } that terminates the main function returns a value of 0.

Therefore, the following construction is perfectly legal:

int main(void)
{
    printf("Hi there\n");
}

Useful GCC flags

Apart from -Wall -pedantic:

-Wextra
-Wconversion
-Wcast-align
-Wdouble-promotion
-Wfloat-conversion
-ftrapv traps signed integer overflow by calling abort()

References

All references in the text refer to the N1256 draft of the C99 standard (ISO/IEC 9899:1999).

Useful links:

Context Switch on the ARM Cortex-M0

2016-07-28T00:00:00+02:00

I have written a simple round-robin scheduler (available on GitHub) for the ARM Cortex-M0 (ARMv6-M) CPU to understand the context switch mechanism. This article is a short summary of its principle.

The same approach is used by many RTOSes and is well described in The Definitive Guide to ARM® Cortex®-M0 and Cortex-M0+ Processors by Joseph Yiu.

Background

The processor has two separate stack pointer which can be accessed through banked SP register: Main Stack Pointer (MSP) which is the default one after startup and Process Stack Pointer (PSP) which can be optionally used.

The processor supports multiple modes:

The default mode is the Privileged Thread Mode. It is possible to switch stack to PSP in this mode
The Privileged mode can be switched to Unprivileged Thread Mode which has certain register and memory access restrictions
Exceptions and interrupts are handled in the Handler Mode which uses the MSP stack.

In this application, tasks run in the Unprivileged Thread Mode with PSP and kernel runs in the Handler Mode with MSP. This allows stack separation between the kernel and tasks (which simplifies the context switch procedure) and prevents tasks from accessing important registers and affecting the kernel.

Context Switch

The context switch happens in an interrupt handler. Once an interrupt occurs, the NVIC hardware automatically stacks an exception frame (registers xPSR, PC, LR, r12 and r3-r0) onto the Process Stack (PSP) and branches to the interrupt handler routine in Handler Mode (which uses the Main Stack).

The context switch routine has to:

Manually stack remaining registers r4-r11 on the Process Stack
Save current task’s PSP to memory
Load next task’s stack pointer and assign it to PSP
Manually unstack registers r4-r11
Call bx 0xfffffffD which makes the processor switch to Unprivileged Handler Mode, unstack next task’s exception frame and continue on its PC.

Exception frame saved by the NVIC hardware onto stack:

Registers saved by the software:

Performing the Context Switch

The context switch could be performed by the SysTick_Handler with a SysTick timer configured to fire interrupts periodically:

This approach would however not work with other interrupts (peripheral interrupt for example). The SysTick_Handler would stack registers affected by the peripheral IRQ handler and unstack task’s registers, resulting in undefined behavior of both tasks and peripheral interrupt handler:

The solution is simple - the SysTick_Handler with the highest priority only selects the next task to be run and triggers PendSV interrupt. The PendSV_Handler with the lowest priority performs the actual context switch once all interrupt requests with higher priority have been handled:

The PendSV_Handler is written in pure assembly. The code relies on a fact that the task’s stack pointer is the first element of the os_task_t structure - the structure’s address corresponds to the address of its first element according to C language specification.

Task Initialization

Each task is defined by its handler function and stack. The initialization phase of task’s stack must ensure that the first 64 bytes (16 words) form a valid exception frame. It is neccessary to store at least the default value of three registers:

xPSR to 0x01000000 (the defaul value)
PC to the handler function
LR to a function to be called when the handler function finishes (otherwise the CPU would jump to invalid location, causing HardFault or undefined behavior)

The actual function os_task_init stores values for registers r0-r12 as well for debugging purposes.

Startup

The startup phase has to configure SysTick and PendSV interrupt levels, initialize the SysTick timer to fire interrupts periodically and start the first task.

As the microcontroller starts in Privileged Thread Mode with Main Stack it is neccessary to switch to Unprivileged mode with Process Stack. This is done by writing to the CONTROL register followed by ISB instruction.

The os_start function is written without inline assembly thanks to functions and intrinsics provided by the CMSIS library.

Example

An example runs three tasks (which are switched every second). All tasks blink the onboard LED with different frequency.

The example can be run on STM32F030R8 Nucleo board and requires STM32Cube software pack which has to be present in the lib directory.

The provided Makefile requires GCC compiler and OpenOCD. See README for more information about compilation and flashing.

Compatibility

The SysTick timer and Privileged mode are optional features of the ARMv6-M architecture. They are however supported by vast majority of microcontrollers.

The code relies on standard CMSIS library by ARM which is usually distributed by microcontroller vendors. The library provides functions and intrinsics for accessing features of the ARM Cortex-M core.

Comments

The comments have been archived from Disqus.

23ars on 2017-04-02:

I took a look through the code and saw that you handle the PendSv interrupt in assembly. Couldn't be used a naked interrupt and only the context switch to be made in assembly? I mean, some inline functions for context save/load.

Interesting article!

Adam Heinrich on 2017-04-04:

Hi, thank you and sorry for the delay. Yes, it could be also written as a naked interrupt (GCC: __attribute__((naked))) with inline assembly and the __get_PSP()/__set_PSP() intrinsic functions provided by CMSIS.

I usually tend to split the code into "pure C" and "pure assembly" functions as it is quite complicated to write a compiler-agnostic code with all the required function attributes and inline assembly.

Also, one has no control over the produced code and the compiler could in theory insert some instructions modifying registers before the inline assembly section (although this is not very likely).

The downside of my solution is that the assembly code has to access variables os_curr_task/os_next_task from os.c and that the structure os_task_t must keep field sp as its first element.

grapherd on 2017-08-28:

Thank for your post, the picture were great!

Ken on 2019-06-21:

Got a question about the final example with PendSV, where the execution flow looks like:

Task 1 -> Peripheral interrupt -> Systick -> IRQ -> PendSV -> Task2.

When Task 1 goes to the Peripheral interrupt, the exception frame gets pushed onto PSP. But what about R4-R11? Wouldn't this information get lost by the time PendSV tries to store Task 1's R4-R11 onto PSP? Is the Peripheral interrupt supposed to store R4-R11 onto the PSP?

Adam Heinrich on 2019-06-21:

Hi, good question!

If any interrupt service routine uses r4-r11 itself, it pushes them on stack "manually" on entry (the ISR code is responsible for that) and pops them on exit.

If no ISR uses r4-r11, the registers simply keep their content.

In both cases, r4-r11 contain Task 1's values when PendSV fires so the values stored are valid.

Ken on 2019-06-21:

I see! Does the ISR push the registers onto MSP or PSP? I wanna say it's MSP since it's safer (e.g. what if the PSP was able to overflow).

Adam Heinrich on 2019-06-21:

The NVIC stacks exception frame to MSP (ISR is the user code which optionally stacks the registers which are not part of the exception frame already stacked by HW).

The only time when NVIC stacks to PSP is when an exception (e.g. interrupt) happens + the CPU is in a Thread mode (i.e. not in ISR) + the CPU has been configured to use PSP in the thread mode (this is not the default behavior but the code presented here does it as part of its initialization).

Acrylic Case for the Intel Edison Breakout Board

2016-05-31T00:00:00+02:00

Last year I bought the Intel Edison Breakout Board for some experiments. I was afraid to carry it around in my bag so I have decided to design a simple laser-cut acrylic case.

The case is made of five parts cut from 3 mm thick acrylic. Blue are inner spacers (one of them does have a hole for both micro USB connectors), black is the top plate (with holes for jumpers and reset button) and red is the bottom plate:

You can choose from two options for the bottom plate - with or without a cutout exposing breakout board’s GPIO pins.

Recommended material:

3 mm thick acrylic
4× 6 mm M3 nylon screws (top)
4× 8 mm M3 nylon screws (bottom)
4× 6 mm M3 nylon standoffs (between top plate and PCB)
4× M3 nylon washers (between bottom plate and PCB)
(optional) 2× M1.6 standoffs with shorter screw (see below)
(optional) 2× M1.6 nuts to replace the original ones

The original M1.6 standoff’s screw is too long so it does not fit the case. As you can see on photos, I’ve just cut the original screws and left the module without any nuts.

It’s generally a good idea to buy more nylon screws - mine crack easily. The case does also look god with metal inbus (hex) screws.

You can download the drawing here (Inkscape SVG and PDF). It is licensed under CC BY-SA 4.0.

Many thanks to Michal Neoral for beautiful photos!

Converting Excel (Calc) Spreadsheet to Code

2013-10-20T00:00:00+02:00

A few months ago I needed to convert quite complex (kind of black box) computation from Excel spreadsheet to C code. At first I manually copied expressions from all cells but this was not simple as I had to check cells mentioned in expressions (formulas). It took long time and energy and the code didn’t work properly - results calculated by the spreadsheet differed from my program’s result.

Therefore I decided to save the Excel spreadsheet in ODF format (OpenOffice.org Calc) and write a little helper called SpreadsheetToCode. It’s a command-line utility that does the following steps:

Load OpenDocument Spreadsheet file (.ods) because it's basically XML file wrapped in ZIP and therefore super easy to handle
Pick all cells which contain numerical values (inputs, parameters) or expressions with them (formulas)
Print C-like source code with the spreadsheet's functionality expressed in lines of code

As this is just helper and not fully equipped Excel-to-EXE converter, so that your task is to rename variables to something meaningful (instead of G42), maybe merge some lines of code or remove redundant steps and incorporate the resulting code in your own program. Converter’s greatest help is that it checks for dependencies which means that code

double C2 = C10/3;

will be placed after

double C10 = C5+C1;

because C10 mustn’t be used before its declaration/definition.

Usage

To illustrate the usage I created simple spreadsheet (the original complex spreadsheet can not be disclosed) for calculating resistive voltage divider. It calculates V2 from V1, R1 and R2:

Of course this is a trivial task but I couldn’t think up anything better that wouldn’t take long minutes to create (Excel calculations aren’t my style, I use it just for painting tables). Many thanks to Wikipedia for the File:Resistive_divider.png.

For the conversion just download SpreadsheetToCode.jar and run it:

java -jar SpreadsheetToCode.jar resistive_divider.ods

The resulting code will be:

/* Constants: */
double C5 = 22.0;
double C6 = 20.0;
double C7 = 3.0;

/* Formulas: */
double C10 = C6+C7;
double C11 = C7/C10;
double E5 =  C5*C11;

The only thing you need is to wrap it into some function and look into spreadsheet what cells are inputs (C5, C6, C7: they are listed in Constants section) and which are results (E5 in our case). Problem solved!

Source code and limitations

Full Java source code is available in source.zip. As this was an one-hour project the code is not ideal (but I tried to keep it understandable) and there are some known limitations (or features) I didn’t want to solve:

The resulting code is always C-like (with statements ended by a semicolon). You can change this in Cell.getGeneratedCode() method.
Your task is to decide what cells are inputs and which are outputs. The easiest way is to wrap generated code in function and fill input cells with function arguments.
Formulas containing IF or mathematical functions are not converted to valid C code (but from the generated code it's quite obvious is it supposed to do). Your task is to change function names to something meaningful and replace IF with ternary operator.
Cells with column indexes higher than Z (AA1, AB1, ...) are not correctly represented. You can modify the cell name assignment in Cell.setName(int row, int column) method if you need this. It should be a few lines of code.

Result

This utility saved me hours of boring copy&paste in Excel and ordering lines of code because of dependencies. Instead I spend the time coding this utility which was more fun:-) It is placed online so that it can help someone else. Enjoy!

How to Load Native JNI Library from JAR

2012-12-09T00:00:00+01:00

The JNI (Java Native Interface) is a framework that provides a bridge between Java and native applications. Java applications can define native methods which are implemented in dynamic library written in other languages such as C or C++. The dynamic library is able to call both static and dynamic methods. More information about JNI can be found on Wiki or in tutorial Beginning JNI with NetBeans (for Linux).

The problem is that for loading such a dynamic library you have to call method System.load(String filename) which requires an absolute filename. This approach is just fine if you have dynamic library outside the application’s JAR archive, but when bundling dynamic library within the JAR it is necessary to extract the library into filesystem before loading it. And that’s exactly what my code does.

Our simple JNI class could look like this:

public class HelloJNI {
    static {
        System.load("/path/to/my/library.so");
    }

    public native void hello();
}

To extract the library before loading it it’s necessary to add some code into the static section. I wrapped it into a static method inside simple class called NativeUtils. I decided to put it into separate class in order to have space for adding more features (like choosing the right dynamic library for host OS and architecture). The class can be found on my Github.

The code is commented and self-explaining, so I don’t have to write too much about it. Just three notes:

The file path is passed as string, not as instance of File. It is because File transforms the abstract path to system-specific (absolute path decision, directory delimiters) one, which could cause problems. It must be an absolute path (starting with '/') and the filename has to be at least three characters long (due to restrictions of File.createTempFile(String prefix, String suffix).
The temporary file is stored into temp directory specified by java.io.tmpdir (by default it's the operating system's temporary directory). It should be automatically deleted when the application exits.
Although the code has some try-finally section (to be sure that streams are closed properly in case an exception is thrown), it does not catch exceptions. The exception has to be handled by the application. I belive this approach is cleaner and has some benefits.

Final usage is pretty simple. :-) Just call method loadLibraryFromJar and handle exception somehow:

import cz.adamh.NativeUtils;
public class HelloJNI {
  static {
    try {
      NativeUtils.loadLibraryFromJar("/resources/libHelloJNI.so");
    } catch (IOException e) {
      e.printStackTrace(); // This is probably not the best way to handle exception :-)
    }
  }

  public native void hello();
}

Edited 2013-04-02: Lofi came with a workaround to release and delete our DLL from temporary directory on Windows.

Get the whole code from my Github!

Comments

The comments have been archived from Disqus.

davs on 2012-12-27:

The article is great.
One little remark ..

Lines 60-61:
// Prepare temporary file
File temp = File.createTempFile(prefix, suffix);

in your case suffix contain only extension (without '.' before) .. And I was getting the error of FileNotFound in line 91.

Changing Line 61 to
File temp = File.createTempFile(prefix, "." + suffix);
fixed my issue .. maybe not only mine :)

Cheers,
Davs

Adam on 2012-12-27:

Thank you, davs. Sorry for my fault, the temporary file was really "libraryso" instead of "library.so". But I didn't have any problems caused by the FileNotFound with my code, maybe it was some OS-specific issue (I run application using this code on Linux).

I modified line 52 from suffix = (parts.length > 1) ? parts[parts.length - 1] : null; to suffix = (parts.length > 1) ? "."+parts[parts.length - 1] : null;, because the File.createTempFile(prefix, suffix) method uses ".tmp" as default extension if suffix is null.

I also changed split() on line 50, it is now limited to 2 items.

Eveything should be OK now :-)

Adam on 2013-02-07:

Hello, this is interesting. Look at nice explanation at http://kalblogs.blogspot.cz..., maybe the $LD_LIBRARY_PATH variable could be the way to go.

Some people wanted to do the same thing (embed JNI library that depends on some shared libs into JAR), after some searching I found only this crazy solution: http://stackoverflow.com/a/......

Lars Nielsen on 2014-08-05:

Hey I am trying this with a folder tructure
/demo
--/src
----- App.java
----- /com.core
----- NativeUtils.java
--/Libs
----- libs.jar

with the App.java looking like this:
import java.io.IOException; import com.core.NativeUtils; public class App { public static void main(String[] args) { try { NativeUtils.loadLibraryFromJar("/lib/lib_fifi.so"); System.out.println("Library Loaded - Loaded from jar"); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
But it does not work any ideas I get: File /lib/lib_fifi.so was not found inside JAR

Adam on 2014-08-09:

Hello, it looks like you didn't include the file (I don't see any /lib/lib_fifi.so in your folder structure).

Aurélien on 2014-01-29:

Thanks, useful trick

Baruch Youssin on 2014-06-24:

A great solution, very simple, much simpler than all the competing solutions posted on the net.
There is one thing in this article that I do not understand: the issue of "absolute path (starting with ‘/’)".
This refers to the
path
parameter in the code, which indicates the native library as a resource inside the jar.
This far, I have worked only with audio files as resources, and their paths should not start with a slash / .
In fact, I have tried to specify audio files by a path starting with a slash, as /com/...; here com was the name of the top-level directory in the jar, and the rest of the path pointed to the file-resource. This did not work out (java could not find the resource), neither on Windows XP nor on Linux Ubuntu 12.04, both running a most recent java from Oracle.
Removing the initial slash resolves the problem: java finds the audio file.
I am going to try both ways with the native library; but what is the rule here?

Baruch Youssin on 2014-06-26:

I have found the answer:
loadLibraryFromJar calls java.lang.Class.getResourceAsStream(String) method while for audio files I use a different method, javal.lang.ClassLoader.getResource(String).
These two methods have different rules for path name resolution, and for this reason in getResource(..) I must use the path without the leading / while in getResourceAsStream(..) I must use the leading /.
Thanks for the nice code, it works!

Lofi on 2013-03-28:

Thank you very much for sharing this! However, there's a slight hickup in the solution: The temporary library won't get deleted on windows because the JVM still has a lock on it when it shuts down and invokes deleteOnExit(). The library should be "unloaded". Unfortunately that's currently not possible in Java.

In case anyone else runs into this issue of having their temporary folder flooded with DLLs, I came up with this workaround:

* in additon to the temporary DLL, also create a .lock file on which you also issue a deleteOnExit(). This file will get deleted when the JVM shuts down

* during startup search for all .dll files and delete those which don't have an accompanying ".lock" file

Not quite the proper solution, but unless this is fixed internally in Java it may be some workaround :-)

Here's some code in case someone wants to use it, just put it at the bottom of the loadLibraryFromJar method:

        final String libraryPrefix = prefix;
        final String lockSuffix = ".lock";
        
        // create lock file
        final File lock = new File( temp.getAbsolutePath() + lockSuffix);
        lock.createNewFile();
        lock.deleteOnExit();
     
        // file filter for library file (without .lock files)
        FileFilter tmpDirFilter =
          new FileFilter()
          {
            public boolean accept(File pathname)
            {
              return pathname.getName().startsWith( libraryPrefix) && !pathname.getName().endsWith( lockSuffix);
            }
          };
          
        // get all library files from temp folder  
        String tmpDirName = System.getProperty("java.io.tmpdir");
        File tmpDir = new File(tmpDirName);
        File[] tmpFiles = tmpDir.listFiles(tmpDirFilter);
        
        // delete all files which don't have n accompanying lock file
        for (int i = 0; i < tmpFiles.length; i++)
        {
          // Create a file to represent the lock and test.
          File lockFile = new File( tmpFiles[i].getAbsolutePath() + lockSuffix);
          if (!lockFile.exists())
          {
            System.out.println( "deleting: " + tmpFiles[i].getAbsolutePath());
            tmpFiles[i].delete();
          }
        }

Adam on 2013-04-02:

Lofi, thank you for this workaround, it will be useful!

Blackshues on 2015-01-25:

This workaround is very clean, and worked for me right out of the box. Thank you sir.

Harbour Porpoise on 2018-04-26:

Thanks so much, this saved the day!

Víctor Vanaclocha Cebrián on 2019-09-18:

I'm trying use this class in a Maven project.

-src/main/java
----app.java
..src/main/resources
----libraries
--------win32-x86-64
------------jni.dll

I'm calling the "loadLibraryFromJar()" method and I try this:

NativeUtils.loadLibraryFromJar("/resources/libraries/win32-x86-64/jni.dll");
NativeUtils.loadLibraryFromJar("/libraries/win32-x86-64/jni.dll");

The exception is as follows:
java.io.FileNotFoundException: File /resources/libraries/win32-x86-64/jni.dll was not found inside JAR.

I am generating a jar with the libraries inside the maven jar-project so that I only have one jar application. the libraries go inside the resources directory of the maven structure.

Any idea what is happening?
In my project there are the dll inside the jar and in my eclipse project.

Decimal Comma in Matlab Plots

2012-12-01T00:00:00+01:00

A lot of languages (not only the European ones) use decimal comma instead decimal point to separate the whole and the fractional part of a number in decimal form. Matlab (like other programs) uses decimal point for this purpose. This is okay when using it for computations but it is better to use decimal comma in graphs embedded in documents written in some European language.

This approach also works in GNU Octave which is available for free. ;-)

Basic plotting in Matlab is done by the plot function:

% Define function
x = -1:0.1:1;
y = x.^3;

% Open graph window and plot the function
figure;
plot(x, y);

% Label axes, show grid and title
grid on;
title('Simple plot');
ylabel('y=x^3');
xlabel('x');

To change decimal point to decimal comma I used simple approach: Function get(gca, ‘XTick’) returns the tick of X asix. In our case it is a vector -1:0.01:1. Another function set(gca, ‘XTickLabel’) sets a label for X axis. This label contains cell array of strings. The only necessary step between calling these functions is to change decimal points to commas using the strrep function.

I wrapped this code into a simple function decimal_comma with a few arguments:

axes_handle is handle of axes to be changed. Just enter gca for current plot.
axis_name is the name of axis to be changed: 'X', 'Y' or 'XY' for both axes.
formatstr (optional) is simple sprintf-like format string, e.g. '%2.2f'

Just copy the code below and save it into new script file named decimal_comma.m or clone the whole Github repository:

function decimal_comma(axis_handle, axis_name, varargin)
%DECIMAL_COMMA - decimal comma in 2-D plot
%
%   A simple function to replace decimal points with decimal commas (which
%   are usual in Europe) in Matlab or Octave plots.
%
%   DECIMAL_COMMA(axis_handle, axis_name) changes decimal point to decimal
%   comma in a plot. Use gca for current axes handle and one of 'X', 'Y' or
%   'XY' for axis_name.
%
%   DECIMAL_COMMA(axis_handle, axis_name, formatstr) changes decimal point
%   to decimal comma in a plot. Number format is specified by formatstr
%   (see SPRINTF for details).

% (c) 2012 Adam Heinrich <adam@adamh.cz>. Published under the MIT license.

    if (nargin < 2 || nargin > 3)
        error('Wrong number of input parameters.');
    end

    switch axis_name
        case 'XY'
            decimal_comma(axis_handle, 'X', varargin{:});
            decimal_comma(axis_handle, 'Y', varargin{:});

        case {'X', 'Y'}
            tick = get(axis_handle, strcat(axis_name, 'Tick'));

            n = length(tick);
            labels = cell(1,n);

            for i = 1:n
                label = num2str(tick(i), varargin{:});
                labels{i} = strrep(label, '.', ',');
            end

            labels{1} = '';
            labels{n} = '';

            set(axis_handle, strcat(axis_name, 'TickLabel'), labels);

        otherwise
            error('Wrong axis name! Use one of X, Y or XY.');
    end
end

Usage for our example function y=x³:

x = -1:0.1:1;
y = x.^3;

figure;
plot(x, y);

grid on;
title('Simple plot');
ylabel('y=x^3');
xlabel('x');

decimal_comma(gca, 'XY');

If you like to hide numbers on the left and right, just add this line before set(axis_handle, …):

labels{1} = '';
labels{n} = '';

The plot will then change to:

Get the whole code from my Github!

Comments

The comments have been archived from Disqus.

Janek on 2013-08-30:

Again, nice work, but I would modify 14nth line of the code from:

label = sprintf(strcat(formatstr, '|'), tick);

to:

label='';
for i=1:length(tick)
label=[label num2str(tick(i)) '|'];
end

With the above loop we avoid additional zeros (for example I had on my plot 0,10000).

Adam on 2013-10-04:

Thank you for the comment, the function works much better now. I'm sorry for not mentioning it in the article earlier.

Don-Umbro on 2013-09-19:

This hint from Janek is very useful!
Maybe you can add this to your explanations - I didn't read the comments at first.
By the way: With Janek's solution, you don't need line 15 anymore. My alternative version would be:

function [ ] = plotUseDecimalComma( axis_handle, axis_name) % PLOTUSEDECIMALCOMMA changes decimal point to decimal comma in a plot. % Parameters are: % axis_handle: Axes handle to work with (use gca for current axes handle) % axis_name: Name of axis to be changed ('X', 'Y' or 'XY' for both axes) if(nargin~=2) error('Wrong number of input parameters.'); end; switch axis_name case 'XY' plotUseDecimalComma(axis_handle, 'X'); plotUseDecimalComma(axis_handle, 'Y'); case {'X', 'Y'} tick = get(axis_handle, strcat(axis_name, 'Tick')); label=''; for i=1:length(tick) label=[label num2str(tick(i)) '|']; %#ok end label = strrep(label, '.', ','); set(axis_handle, strcat(axis_name, 'TickLabel'), label); otherwise error('Wrong axis name! Use one of X, Y or XY.'); end; end

janek on 2013-08-11:

You saved my day!

Antonio on 2013-10-28:

Thank you very much!

I had to translate an english technical report to spanish, I had assumed to leave the points in the figures but finding your function it has been a present from heaven

thanks

alexandre on 2013-04-11:

Good work!

Lukasz on 2015-02-24:

Thank you, it is very good code, but it doesn't work on Matlab 2014b. Graphic engine was changed. Everything works fine when you run it on Matlab 2014a or lower version.

Adam Heinrich on 2015-06-13:

Hi Lukasz, thank you for finding the bug and sorry for my late response.

I've just changed ( https://github.com/adamhein... ) the code to use the newer engine. It seems to work in older versions as well (tested on R2012).

Dmitry 🔴 on 2019-07-19:

Thank you so very much! A most helpful function that works just awesome!