Googles new fotos app seems to be pretty awesome, but if you are looking for the “find by person/face” tab like shown in the preview u’ll recognice that there is no person field in your listing.

This is most likely caused by country legislations: Face search is only allowed in a few countrys - in germany for example you wount be able to search for persons.

Code composer studio can be downloaded directly from ti. When u extract the zipped file u will get a readme and a *.bin file which u have to make executable.

sudo chmod +x ./*.bin #with a terminal session in the extracted folder

Once the file is executable u can run:

./filename.bin

, or double click one the binary.

Usually the installer should complain about missing libraries. To obtain these u can simply type

sudo apt-get install libgnomevfs2-0:i386 liborbit-2.0:i386 libusb-0.1:i386

So after installing the drivers and code composer studio itself the linux drivers are still missing. The driver installation has to be performed via terminal so u have to navigate to the ti folder u specified in the installation and execute the driver installation as root.

cd /home/username/ti/ccsv6/install_scripts
sudo ./install_drivers.sh

Regards,

Lukas

In recent days I connected a rs485 chip to the raspberry pi and programmed it via biicode and ssh(tutorial will follow). The great advantage with biicode is, that u don’t have to set up cross-compiling and stuff like than on your self because biicode manages this with some simple commands. Another important advantage is, that u can easily use the wiringpi library with a simple #include.

The problem was, that I had huge delay problems with rpi:send and spi:ssh (also with the usual ssh). The ssh connection was freakin slow and it needed seconds till the “enter password” prompt showed up.

A simple solution for this problem is, to edit the /etc/ssh/sshd_config on the raspberry-pi. Add the line:

UseDNS no

and everything should work as expected.

Regards,

Lukas

In recent days I worked on a android graph tool called BlueGraph which allows to monitor real time data of sensors. Therefore I used a ZS-040 sending data from an msp430 with a baud rate of 9600. The mobile phone receives this data and displays a nice graph containing the data ;)

The app expects the data to be in the following format:

(+|-)(d*)(delimiter)(+|-)(d*)...(\n)

Since the newer ubuntu versions u can simply install android studio via ubuntu-developer-tools-center.

sudo apt-get install ubuntu-developer-tools-center
udtc android

Can u? I got an error caused by a bug in the python script as reported on launchpad.

The fix is listed in one of the comments below but i’ll post it here, so u don’t have to dig for it. Open the python file with admin rights:

sudo nano /usr/lib/python3/dist-packages/udtc/frameworks/android.py

and change the following lines(57,58,87)

#replace 1st with 2nd
p = re.search(r'href="(.*)">', line)
p = re.search(r'href="(.*)"', line)

p = re.search(r'<td>(\w+)</td>', line)
p = re.search(r'<td>([0-9a-f]+)</td>', line)

return self.category.parse_download_link('id="linux-studio"', line, in_download)
return self.category.parse_download_link('id="linux-bundle"', line, in_download)

When using windows programs on linux there are always permission problems... and most often they are really simple to fix :)

When getting a:

Method name - openPort(); Exception type - Permission denied.

error while trying to upload programs the simple fix is to add the user to the dialout group like that:

sudo adduser username dialout

sudo chmod a+rw theport         #sth. like /dev/ttyACM0

Did u ever get a not found the error for Python.h while installing packages?

#include "Python.h"
                    ^
compilation terminated.

in most cases the reason is a missing package.

sudo apt-get install python2.7-dev libyaml-dev

should be the solution.

I tend to forget watering my plants, so I decided to create a own watering reminder. I thought it would be fun so simply turn on a led, when the ground is too dry. There are quite different soil meters which differ mostly in accuracy and current consumption. For simplicity I’ll stick with the one proposed by tiago as you can get it for around 1$ at aliexpress (in germany you wouldn’t even get the wires for this price).

Sadly I could not find any English datasheet and as my Chinese is pretty bad, but the setup i really straight forward. There is a VCC and GND pin which have to be connected as always. Additionally there is a A0 pin for analog output, and D0 for digital output. For plotting graphs and stuff we need the analog output, but as I only want to turn on a light the D0 is enough. D0 turns HIGH as soon as a threshold is exceeded.

So what i actually did is powering the sensor via a lithium-polymer battery with 3.7V, soldering a 1k resistor between D0 and the LED’s +. With this setup the light turns on when the threshold is exceeded. The threshold can be configured by rotating the blue screw.

Asset compression is a major concern for nearly every complex web framework. Interestingly most static page frameworks don’t care about this, cause server response rates are blazing fast so asset compression for css, js and image resources is not worth the effort.

This may be right in most cases, but especially in bad internet countries and even in suburban regions where the internet speed is reduced to dsl 1k and less it’s important to keep package size to a minimum.

In order to reduce server response time and package size i created a simple tinkerer extension, which can also be used for sphinx with slight adjustments. Is simply takes the generated resources and overwrites them with their minified versions

#Author: Lukas Strassel
#Extension for asset compression in tinkerer
#The proposed solution is based on http://swiftbend.com/blog/?page_id=79#.VTJTKOT7vtQ
from slimit import minify
from rcssmin import cssmin

import glob
import os


destPath = os.getcwd()+"/blog/html/_static"     #get path to static files(may be wrong for sphinx)
jsFiles = []            #container for js resources
cssFiles = []           #container for css resources

def minifyCSSProc(srcText):
    return cssmin(srcText, keep_bang_comments=True)

def minifyJSProc(srcText):
    return minify(srcText, mangle=True, mangle_toplevel=True)

def processFiles(minifyProc, sourcePaths):
    for srcFile in sourcePaths:
        with open(srcFile,'r+') as inputFile:           #open file
                srcText = inputFile.read()              #read file
                minText = minifyProc(srcText)           #minimize resources
                inputFile.close()                       #close file
                os.remove(destPath+"/"+srcFile)         #remove file

                file = open(destPath+"/"+srcFile, 'w+') #create new file
                file.write(minText)                     #write minimized content
                file.close()                            #close file

def jsMinification(files):
    return processFiles(minifyJSProc, files)

def cssMinification(files):
    return processFiles(minifyCSSProc, files)

def setup(app):
        app.connect("build-finished", asset_compression)#inject after build-finished to modify the generated(not original) resources

def asset_compression(app, exception):
        os.chdir(destPath)                              #change working directory
        jsFiles = glob.glob("*.js")                     #find all js files
        jsFiles.remove("disqus.js")                     #disqus wont't work minimized, cause the function names are used in the layout
        cssFiles = glob.glob("*.css")                   #find all css files
        jsMinification(jsFiles)                         #minify js
        cssMinification(cssFiles)                       #minify css

There’s a (not so)new star out in the endless wideness of open source software. GRT by Nick Gillian is a gesture recognition library with a rich collection of pre and post processing filter besides a huge variety of build in gesture recognition algorithms.

The GRT library itself is currently published on biicode, but the GRT-GUI isn’t cause it’s highly dependent on qt. So what we want to do now is creating a pipeline from Arduino to GRT-GUI.

The GRT-GUI was designed to communicate via OSC, but we usually use serial communication at arduino/hardware-side. This forces us to read from serial and forward via OSC to GRT.

The following program consists of 3 parts:

1. establishing a serial connection to your arduino
2. Continuously read data from serial
3. use GRT-GUI to read and process the data

#include <string>
#include <iostream>
#include <stdlib.h>
#include "david/serial_cpp/serial.h"
#include "Maria/oscpack/osc/OscOutboundPacketStream.h"
#include "Maria/oscpack/ip/UdpSocket.h"

#define ADDRESS "127.0.0.1"
#define PORT 5000
#define OUTPUT_BUFFER_SIZE 1024
#define COMPORT "/dev/ttyUSB0"
#define BAUDRATE 115200

using namespace std;

int main()
{
  //open udp socket for osc
  UdpTransmitSocket transmitSocket( IpEndpointName( ADDRESS, PORT ) );
  //open serialport for arduino communication
  //expects arduino messages in following form: $value1\tvalue2\tvalue2\n
  serial serialport('$', '\n', COMPORT, BAUDRATE);
  string input = "";
  while(1){
    input = serialport.read(); //read a message
    if (input != ""){
      //begin OSC message
      char buffer[OUTPUT_BUFFER_SIZE];
      osc::OutboundPacketStream p( buffer, OUTPUT_BUFFER_SIZE );
      p << osc::BeginBundleImmediate << osc::BeginMessage( "/Data" );


      char seps[] = "\t";
      char *token;
      //token points to &input
      token = strtok( &input[0], seps );
      while( token != NULL )
      {
        //add value inside token to osc message
        p << atof(token);
        //token points to next occurence
        token = strtok( NULL, seps );
      }
      //end osc message
      p << osc::EndMessage << osc::EndBundle;
      //send message via udp
      transmitSocket.Send( p.Data(), p.Size() );
    }
  }
  return 0;
}

Biicode leverages this process by reducing the pain of downloading and compiling external dependencies. With a simple:

bii find      #downloads dependencies
bii cpp:build #builds the project

we can start our program and you will hopefully see the data-stream in GRT-GUI.

Here’s a simple example video, where I used a boarduino with an mpu6050 which constantly streams the quaternion rotation data and the 3-axis acceleration data via serial to the pc.