<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>The all new eggers-club.de</title>
    <link>https://www.eggers-club.de/</link>
    <description>Recent content on The all new eggers-club.de</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>&amp;copy; Daniel Egger</copyright>
    <lastBuildDate>Thu, 31 May 2018 13:31:51 +0200</lastBuildDate>
    
	<atom:link href="https://www.eggers-club.de/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>Rust on the micro:bit 101 part 1</title>
      <link>https://www.eggers-club.de/blog/2018/05/31/rust-on-the-microbit-101-part-1/</link>
      <pubDate>Thu, 31 May 2018 13:31:51 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2018/05/31/rust-on-the-microbit-101-part-1/</guid>
      <description>About this tutorial/guide Motivation In this issue on my github repository for the Micro:bit Rust board support crate I&amp;rsquo;ve been asked to provide a tutorial or howto about how to get started with using the crate and starting to program the BBC Micro:bit (which is a rather cool and cheap fully equipped micro controller board meant for teaching computer science to kids in school). Since there&amp;rsquo;re not really a tutorial covering everything from 0 to a working application, this is my attempt on providing that based on an available and affordable kit.</description>
    </item>
    
    <item>
      <title>About Me / Impressum</title>
      <link>https://www.eggers-club.de/about/</link>
      <pubDate>Sun, 20 May 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.eggers-club.de/about/</guid>
      <description>Hey, my name is Daniel Egger. I&amp;rsquo;m a software engineer and evangelist living and working in Bavaria (which is a federal state of Germany, in case you wondered).
I do lots of stuff, obviously designing and programming software in variety of languages, but also reverse engineering hardware and protocols and doing little new hardware projects myself.
Time for those project is a scarse resource though since I&amp;rsquo;m spending much of my spare time with my partner and our two lovely kids plus there&amp;rsquo;s always something do around my house as well; so efficiency is an absolute must in everything I do.</description>
    </item>
    
    <item>
      <title>Changes in Rust macro re-exporting</title>
      <link>https://www.eggers-club.de/blog/2018/05/06/changes-in-rust-macro-re-exporting/</link>
      <pubDate>Sun, 06 May 2018 15:47:40 +0000</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2018/05/06/changes-in-rust-macro-re-exporting/</guid>
      <description>The changes in recent Rust This commit to the Rust ecosystem removed the previous macro re-export functionality which is now subsumed by a cleaner mechanism which is also going to be stabilised in the end, this is tracked by this issue.
Unfortunately the previous re-export mechanism was used quite a lot in the embedded field, causing quite a few crates to break when compiled with rustc versions from the beginning of May 2018, which is especially frustrating when pulling in broken dependencies since those can not be easily (and permanently) addresses locally.</description>
    </item>
    
    <item>
      <title>The untold truth about the OpenSDA messup</title>
      <link>https://www.eggers-club.de/blog/2017/10/08/the-untold-truth-about-the-opensda-messup/</link>
      <pubDate>Sun, 08 Oct 2017 21:10:00 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2017/10/08/the-untold-truth-about-the-opensda-messup/</guid>
      <description>Introduction Recently I came in need for a CMSIS-DAP compliant programmerdebugger to revive a locked-up ATSAMD20 MCU. While I do have plenty of programmers and debugging interfaces here, the ATSAMD20 requires a very special procedure called &amp;ldquo;cold-plugging&amp;rdquo; which (in an open source world) only CMSIS-DAP compliant interfaces seem to be capable of in addition to necessary manual patching, cf. this post.
So while I do have Cypress eval boards here which come with a KitProg programmer which is CMSIS-DAP compliant, the implementation is somewhat pedestrian and in addition Cypress decided to swim against the current by making their kit use 5V instead of the nowadays more common 3V3 which complicates things a bit.</description>
    </item>
    
    <item>
      <title>Embedded debugging with LLDB? Sure!</title>
      <link>https://www.eggers-club.de/blog/2017/07/01/embedded-debugging-with-lldb-sure/</link>
      <pubDate>Sat, 01 Jul 2017 23:16:51 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2017/07/01/embedded-debugging-with-lldb-sure/</guid>
      <description>LLDB? You haven&amp;rsquo;t heard about LLDB? In a nutshell it&amp;rsquo;s new debugger, part of the ubiqitious LLVM project, aiming to replace the venerable GDB which is used everywhere. It has tons of interesting features, some of which also found their way into GDB by now, and is the standard debugger on macOS, though many people will not even know due to the very nice integration into XCode. It is very actively supported and developped, especially by Apple and Google.</description>
    </item>
    
    <item>
      <title>My simple LED strip controller, Part 3</title>
      <link>https://www.eggers-club.de/blog/2017/05/08/my-simple-led-strip-controller-part-3/</link>
      <pubDate>Mon, 08 May 2017 20:19:19 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2017/05/08/my-simple-led-strip-controller-part-3/</guid>
      <description>The software The main idea driving the hardware was to keep it as simple as possible on the software side. Simple can mean a lot of things but in the microcontroller world the word is mostly associated with Arduino which is what we&amp;rsquo;re also using here.
Light sensor We only want to turn on the light if it is sufficently dark outside. For this we&amp;rsquo;re using a light detecting resistor in a voltage divider setup connected to an analog digital converter at the MCU.</description>
    </item>
    
    <item>
      <title>My simple LED strip controller, Part 2</title>
      <link>https://www.eggers-club.de/blog/2017/04/25/my-simple-led-strip-controller-part-2/</link>
      <pubDate>Tue, 25 Apr 2017 20:22:17 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2017/04/25/my-simple-led-strip-controller-part-2/</guid>
      <description>The hardware To keep it all nice and tidy (and to test another new PCB manufacturer ;) ) the whole project was designed as a small 2-layer PCB in KiCad with some through-hole components for those parts which are either incredibly expensive or hard to source as SMD parts. Of course a decent (even LED) light does require quite a bit of juice so the hardware should be capable of handling 12V and at least 3A with ease.</description>
    </item>
    
    <item>
      <title>My simple LED strip controller, Part 1</title>
      <link>https://www.eggers-club.de/blog/2017/04/24/my-simple-led-strip-controller-part-1/</link>
      <pubDate>Mon, 24 Apr 2017 20:20:12 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2017/04/24/my-simple-led-strip-controller-part-1/</guid>
      <description>Introduction I have this nice dark and narrow alley at my place between the garage and my front door. To shy away dubious creatures and to see not only where I&amp;rsquo;m going but also whether there&amp;rsquo;s something in my mailbox I want to have some motion activated light in there. Since it is long and narrow and has a not-to-high flat roof on top using one of the typical motion activated spots is not a good fit.</description>
    </item>
    
    <item>
      <title>Wrapping C &#39;objects&#39; in tables</title>
      <link>https://www.eggers-club.de/blog/2016/07/03/wrapping-c-objects-in-tables/</link>
      <pubDate>Sun, 03 Jul 2016 21:32:40 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2016/07/03/wrapping-c-objects-in-tables/</guid>
      <description>The problem Let&amp;rsquo;s say you&amp;rsquo;re managing all your primary data in C. You&amp;rsquo;ll probably have some C structures (called objects here for brevity) wrapped nicely in userdata proxy objects for access in Lua. But how do you easily get access to the data? Well, there&amp;rsquo;re a lot of different possibilies here:
 You can have functions to find and return individual objects If your data organisation allows (e.g. if you have lists or trees) you can wrap those data organisation structures as well  &amp;hellip;</description>
    </item>
    
    <item>
      <title>Access to C data from Lua</title>
      <link>https://www.eggers-club.de/blog/2016/06/20/access-to-c-data-from-lua/</link>
      <pubDate>Mon, 20 Jun 2016 00:24:07 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2016/06/20/access-to-c-data-from-lua/</guid>
      <description>The problem If you&amp;rsquo;d like to combine your C program code to Lua code you&amp;rsquo;ll always face the challenge of having to interface data already available in the C part from Lua. Now as we know there&amp;rsquo;s no general way to pass along C pointers from anywhere you&amp;rsquo;d like, especially not from Lua code, so instead you&amp;rsquo;ll have to store the information somewhere else and figure out a way to retrieve it or you&amp;rsquo;ll need to create Lua structures acting as a proxy.</description>
    </item>
    
    <item>
      <title>LUA_PATH</title>
      <link>https://www.eggers-club.de/blog/2016/06/14/lua_path/</link>
      <pubDate>Tue, 14 Jun 2016 21:10:45 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2016/06/14/lua_path/</guid>
      <description>LUA_PATH my new friend Have you heard about LUA_PATH? No? Then let me tell you what that is: In essence it&amp;rsquo;s an environment variable used by any Lua interpreter used to determine where to find additional modules execute code tries to load using require.
Now rather than the usual well-known PATH environment variables (which are used to set the search paths for binaries executed on a Unix-ish system, in case you didn&amp;rsquo;t know) &amp;ndash; of course &amp;ndash; Lua had to do it slightly differently:</description>
    </item>
    
    <item>
      <title>Storing information for later use</title>
      <link>https://www.eggers-club.de/blog/2016/06/10/storing-information-for-later-use/</link>
      <pubDate>Fri, 10 Jun 2016 01:10:13 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2016/06/10/storing-information-for-later-use/</guid>
      <description>The problem Let&amp;rsquo;s say you&amp;rsquo;d like to store some information in Lua for later use. As we&amp;rsquo;ve discussed in this post everything in lua has to go on the Lua state and thus on the stack somehow: If it&amp;rsquo;s not on the stack it doesn&amp;rsquo;t exit. So how can you push information on that stack so that it can be retrieved easily for use at any later point in time?</description>
    </item>
    
    <item>
      <title>Calling back into Lua from C code</title>
      <link>https://www.eggers-club.de/blog/2016/06/08/calling-back-into-lua-from-c-code/</link>
      <pubDate>Wed, 08 Jun 2016 00:49:29 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2016/06/08/calling-back-into-lua-from-c-code/</guid>
      <description>The problem One thing I found incredibly hard when adapting a large C codebase with Lua code was the problem of calling back from C code into Lua callback when there&amp;rsquo;s no auxiliary passed around void * pointer available to also pass the current lua_State.
Of course it would always be possible to just create a new state on-the-fly but if you do you won&amp;rsquo;t have access to any of the already setup Lua environment so your Lua callbacks might end up to be very complicated and heavy.</description>
    </item>
    
    <item>
      <title>Lua stacks in C</title>
      <link>https://www.eggers-club.de/blog/2016/06/06/lua-stacks-in-c/</link>
      <pubDate>Mon, 06 Jun 2016 19:21:40 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2016/06/06/lua-stacks-in-c/</guid>
      <description>Retrospective In this post we looked a little bit at how Lua uses stacks for a lot of things internally. Now we can look at how we need to explicitely work with the stacks in C when implementing a Lua interface.
The almighty Lua state When combining C code with Lua there&amp;rsquo;s exactly one essential piece of information passed from call to call: The Lua state. It is once created and then updated to reflect the current state, you probbaly guessed it: it&amp;rsquo;s a stack; there&amp;rsquo;re ways to split the state and of course one can have several states at the same time but in essence there&amp;rsquo;s supposed to be exactly one and a linear usage.</description>
    </item>
    
    <item>
      <title>Lua stacks in Lua</title>
      <link>https://www.eggers-club.de/blog/2016/06/05/lua-stacks-in-lua/</link>
      <pubDate>Sun, 05 Jun 2016 15:09:29 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2016/06/05/lua-stacks-in-lua/</guid>
      <description>Preamble In case you didn&amp;rsquo;t know, Lua (http://lua.org) is a very simplistic open source scripting language. Its simplicity is also a reason for its incredible flexibility and hence a perfect candidate for embedding in anything ranging from tiny (like http://www.nodemcu.com/ microcontrollers) to huge desktop applications like Adobe Lightroom.
However the base concept of Lua is both curse and blessing at the same time and it&amp;rsquo;s imperative to understand how it works to use this language: stacks.</description>
    </item>
    
    <item>
      <title>Welcome</title>
      <link>https://www.eggers-club.de/blog/2016/06/05/welcome/</link>
      <pubDate>Sun, 05 Jun 2016 10:10:18 +0200</pubDate>
      
      <guid>https://www.eggers-club.de/blog/2016/06/05/welcome/</guid>
      <description>Welcome to my nth attempt (I think it&amp;rsquo;s the fourth, but I don&amp;rsquo;t exactly remember) of building a homepage / blog. ;)
This time I&amp;rsquo;ve chosen a far more lightweight approach which is far closer to my style of work (i.e. using the command line) to reduce the pain of writing up new stuff.
Please enjoy&amp;hellip;</description>
    </item>
    
  </channel>
</rss>