Language Selection

English French German Italian Portuguese Spanish

Devices: Tizen, OpenZWave, and Ibase

Filed under
Hardware
Gadgets
  • Samsung Galaxy Watch, Running Tizen, is Launched

    Today, as expected, Samsung have launched a new smartwatch, the Samsung Galaxy Watch, yes, the name change is real (previously it has been known as the Gear S4). At the Samsung Unpacked event, we were given the Note 9 and the Galaxy Watch. The big headline for us is the watch will not be running Wear OS, as speculated once upon a time, but the Galaxy Watch will be running Tizen 4.0.

    We will have two models to choose from: 46mm available in silver and a 42mm black and rose gold versions. Samsung have realised that “one size does not fit all” and some might find a smaller watch face appealing.

  • Building a better thermostat with Home Assistant

    Next, I needed to look at software to use my hardware acquisitions as a thermostat. While all my devices were Z-Wave, and OpenZWave provides both C++ and Python interfaces I could use to access and control my devices, it was a bit too low-level for my taste.

    Instead, I decided to use the Home Assistant project, for a few reasons. First, I know a bunch of people who use it, hack on it, or both. Second, while all my current devices are Z-Wave, Home Assistant will let me branch out to use other kinds of devices if I want. Home Assistant supports a ton of different devices and services—you can look at the component list to see them all. For Z-Wave support, it leverages OpenZWave and provides a higher level interface that is a bit easier to deal with. Home Assistant is written in Python 3, which is very convenient for me since I do most of my programming in Python. It also has an active community that has been responsive and helpful.

    I installed Home Assistant on one of my servers and proceeded to configure its interface with my devices. There is a lot of detailed information available on setting up Home Assistant—you can refer to the official documentation for a starting point. For specific Z-Wave instructions, see the Z-Wave section in the Home Assistant docs.

    After setting up Home Assistant, I had a single web interface and API for controlling my new power switches and displaying data from the MultiSensor. But, I still didn't have a thermostat—just a pretty interface (that I could use remotely) for manually turning the AC on or off.

  • IP65 protected panel PCs feature Apollo Lake or Core-U chips

    Ibase announced three open-frame panel PCs with Linux support. The 15-inch, 1024 x 768 OFP-151-PC and 21-inch, 1920 x 1080 OFP-2100-PC run on the Pentium N4200 while the 21-inch OFP-2101-PC offers a choice of 7th Gen Core-U CPUs.

    Ibase, which last year launched an SE-102-N signage player, has now returned with a pair of fanless, open-frame touch-panel PCs that similarly run Linux 4.x or Windows 10 on an Intel Apollo Lake SoC. The 15-inch, 1024 x 768 OFP-151-PC and 21-inch, 1920 x 1080 OFP-2100-PC ship with a quad-core, 1.1/2.5GHz Pentium N4200 with 6W TDP.

More in Tux Machines

Testing Slax 10.2 beta1

Changes include disabling apparmor, which was preventing some programs from starting properly (eg. man), and fixing chromium by installing chromium-sandbox package. Also added was dummy 'sudo' command (so you can copy&paste sudo commands from internet and it will work as long as you are signed in as root). I will be happy if you let me know problems you encounter, either by email, or using slax-users google group, or by commenting to this blog post. Read more

GCC: OpenMP / OpenACC and Static Analysis Framework

  • The GCC 10 Compiler Lands OpenMP / OpenACC Offloading To AMD Radeon GPUs

    A few days ago I wrote about the OpenMP / OpenACC offloading patches for Radeon "GCN" GPUs being posted and seeking inclusion in the GCC 10 compiler that will be released in a few months. Those patches were successfully merged meaning this next annual update to the GNU Compiler Collection will feature initial OpenMP/OpenACC code offloading support to supported AMD GPU targets. After GCC 9 only had the initial AMD Radeon GCN target in place, GCC 10 in early 2020 will feature the initial offloading support using the modern OpenMP and OpenACC APIs, thanks to the merges this week. The libgomp port and associated bits for the AMD GCN back-end have landed thanks to the work done by Code Sourcery under contract with AMD.

  • RFC: Add a static analysis framework to GCC
    This patch kit introduces a static analysis pass for GCC that can diagnose
    various kinds of problems in C code at compile-time (e.g. double-free,
    use-after-free, etc).
    
    The analyzer runs as an IPA pass on the gimple SSA representation.
    It associates state machines with data, with transitions at certain
    statements and edges.  It finds "interesting" interprocedural paths
    through the user's code, in which bogus state transitions happen.
    
    For example, given:
    
       free (ptr);
       free (ptr);
    
    at the first call, "ptr" transitions to the "freed" state, and
    at the second call the analyzer complains, since "ptr" is already in
    the "freed" state (unless "ptr" is NULL, in which case it stays in
    the NULL state for both calls).
    
    Specific state machines include:
    - a checker for malloc/free, for detecting double-free, resource leaks,
      use-after-free, etc (sm-malloc.cc), and
    - a checker for stdio's FILE stream API (sm-file.cc)
    
    There are also two state-machine-based checkers that are just
    proof-of-concept at this stage:
    - a checker for tracking exposure of sensitive data (e.g.
      writing passwords to log files aka CWE-532), and
    - a checker for tracking "taint", where data potentially under an
      attacker's control is used without sanitization for things like
      array indices (CWE-129).
    
    There's a separation between the state machines and the analysis
    engine, so it ought to be relatively easy to add new warnings.
    
    For any given diagnostic emitted by a state machine, the analysis engine
    generates the simplest feasible interprocedural path of control flow for
    triggering the diagnostic.
    
  • GCC Might Finally Have A Static Analysis Framework Thanks To Red Hat

    Clang's static analyzer has become quite popular with developers for C/C++ static analysis of code while now the GNU Compiler Collection (GCC) might finally see a mainline option thanks to Red Hat. Red Hat's David Malcolm has proposed a set of 49 patches that appear to be fairly robust and the most we have seen out of GCC static analysis capabilities to date.

Reports From KDE Development and Lakademy 2019

  • This week in KDE: touchy and scrolly and GTK-ey and iconey

    There are some neat things to report and I think you will enjoy them! In particular, I think folks are really going to like the improvements to GNOME/GTK app integration and two sets of touch- and scrolling-related improvements to Okular and the Kickoff Application Launcher, detailed below:

  • KDE Plasma 5.18 Bringing Better GTK/GNOME App Integration

    Aside from tightening the GNOME/GTK integration with KDE, this week there has also been some Okular improvements, better touch support for the Kickoff Application Launcher, deleting files within the Dolphin file manager now uses a separate worker thread for the I/O, Spectacle can now integrate with OBS Studio as a new screen recording option, and other enhancements.

  • Lakademy 2019

    I’m now writing this post in the last hours of the Lakademy 2019 (and my first one). It was really good to be “formally” introduced to the community and it’s people, and to be in this environment of people wanting to collaborate to something as incredible as KDE. Althought I wanted to contribute more to other projects, I did some changes and fixes in the rocs, wrote my Season of KDE project and got some tasks that can help with the future of rocs.

today's howtos