Linux on dotnet.work

Raspberry Pi 4: usB first!

dotnet@oles.cloud (Ole Albers) — Wed, 27 May 2020 12:00:00 +0200

At the time of this writing the boot-from-usb has just been made available as a Beta feature for the Raspberry Pi 4.

There are a few tutorials on how to activate that feature but I had an additional requirement: Boot from USB first, then boot from SD which requires a few additional steps.

This document might still be useful if you just want the SD first approach. Just ignore the second last part in that case.

But before we begin:

Use at your own risk. We are writing data to the EEPROM here using beta contents and even manipulate configs for that. If something fails your pi might be bricked. Not even reinstall Linux will repair that.

Additional warning: Don’t try this on a N00bs install.

Still here? So let’s begin. (I will asume you use Raspbian Buster)

Updating the Pi

Before we start we should always have the most current Linux version installed. So make sure your internet connection works and enter

sudo apt-get update

followed by

sudo apt-get upgrade

and in addition

sudo rpi-update

to update the firmware on the sdcard

Switching to beta

now change rpi to switch to beta - state. (If you are reading this from the future: Hi there! Cars still a thing? And maybe you don’t need to switch to beta anymore)

do this by using your favourite editor like vi or nano to change the rpi-config:

sudo nano /etc/default/rpi-eeprom-update

change the release-status from critical to beta and save the file.

Flashing the EEPROM

Now check the most current version on your pi:

ls /lib/firmware/raspberrypi/bootloader/beta/pieeprom*.bin

At time of this writing the most current version there is 2020-05-15. So flash the eeprom with that version:

sudo rpi-eeprom-update -d -f /lib/firmware/raspberrypi/bootloader/beta/pieeprom-2020-05-15.bin

You will be thrown back to the prompt a while after. Now reboot your pi and hope nothing went wrong:

sudo shutdown - r now

now check if the version has been installed by typing

sudo vcgencmd bootloader_version

the response should display the date corresponding to your file. So something like May 15

Changing the boot order

By default now the boot order will be SD first, USB second. So if you just want to throw away your SD and boot grom USB: Ignore this chapter. If you need a “hardware multiboot” (boot from USB if attached but still have a fallback SD in place if not) follow these instructions:

First make sure I did not lie about the default order and display the current config:

sudo vcgencmd bootloader_config

this should display some information about the configuration. Most interesting for us is the last part called BOOT_ORDERwhich will contain the entry

BOOT_ORDER=0xf41

where 4=USB and 1=SD. More details like network boot can be found at the bootloader documentation.

While this might look like just how we want it you have to read this right to left. So it is SD (1) first and USB (4) second. But we are about to change that.

First it is highly recommend to not fiddle with the official ROM files but make a copy of that. Let’s do that:

sudo cp /lib/firmware/respberrypi/bootloader/beta/pieeprom-2015-05-15.bin pieeprom.bin

Now create a config from that rom:

sudo rpi-eeprom-config pieeprom-usbfirst.bin >bootconf.txt

You now created a config file containing the config-output which you can edit by nano again:

sudo nano bootconf.txt

and change the last line to:

BOOT_ORDER=0xf14

At the last step we now apply our changed config und update the eeprom again:

sudo rpi-eeprom-config --out pieeprom-usbfirst.bin --config bootconf.txt pieeprom.bin sudo rpi-eeprom-update -d -f ./pieeprom-usbfirst.bin sudo shutdown -r now

Finalizing the USB drive

Now our raspberry can boot from USB (and boot from there first) but the linux on our USB does not really know how to handle that. This part is simple:

First you need to flash a Raspbian image onto your USB-drive (just like you would to with an SD-card) . Then attach and mount the usb drive and copy the most current firmware files from the /boot - directory of the sdcard to the Usb drive. Alternatively you can select those files from the master-branch on github.

Have fun :)

Displaying Data from HomeMatic Actors on a WebInterface

dotnet@oles.cloud (Ole Albers) — Mon, 11 Jul 2016 12:00:00 +0200

This tutorial assumes that you already installed and configured FHEM and know how to use AngularJS.

As you might know I use my Raspberry PI to automate tasks at home. I already detect my SmartPhone, and my FitBit and also control my Webcam and Harmony remote using a raspberry and a web interface.

Now I also wanted to include actors from HomeMatic thermostats into my configuration and display it in a nice way.

Hardware used:

HomeMatic Wireless Configuration Adapter LAN (HM-CFG-LAN)
HomeMatic Thermostate HM-CC-RT-DN
Raspberry Pi V2.

Software used:

HTML/CSS
JavaScript
AngularJS
FHEM
PHP (optional)

Before we begin make sure you have already installed FHEM and the hardware for it. I will not discuss that here as there are a lot of good tutorials for that. A good (german) tutorial can be found in the FHEM Wiki. (If you got any english documentation, feel free to post it in the comments.)

I wrote a “general” PHP script to send commands and receive commands from FHEM. This can also be done without PHP and pure JavaScript-Code. I chose this solution because my configuration website is accessable through the internet, but my FHEM isn’t. So JS-Could (running on the client) would not work, but PHP (running on the server) does.

The PHP-Script:

<?php
 $host="http://192.168.178.36:8083/fhem?";

 $sensor= $\_GET\['sensor'\];
 $param= $\_GET\['param'\];
 $action= $\_GET\['action'\];

 if ($action=="get") {
 $get="detail=SENSOR&dev.getSENSOR=SENSOR&cmd.getSENSOR=get&arg.getSENSOR=param&val.getSENSOR=PARAM&XHR=1&addLinks=1";
 } else {
 $get="cmd=set%20SENSOR%20desired-temp%20PARAM&XHR=1";
 }

 $replaced=str\_replace("SENSOR",$sensor,$get);
 $replaced=str\_replace("PARAM",$param,$replaced);
 $total=$host.$replaced;
 
 $ch = curl\_init();
 curl\_setopt($ch, CURLOPT\_URL, $total);
 curl\_setopt($ch, CURLOPT\_RETURNTRANSFER, 1);
 $return = curl\_exec($ch);

 echo $return;

?>

The only thing you need to modify here is the IP-Adress (or hostname) and maybe the port from the $host - variable. As you can see, this is a simple GET-Request which could easily used through JavaScript (or even just inside a href) also.

You can test this script by simply calling it with some parameters:

http://yourserver/fhem.php?action=get&sensor={sensorname}_Clima&param=measured-temp

Replace “Sensorname” by the name of your sensor. You should receive the current temperature of the sensor as a result.

Now it is time to display this data in a fancy way in html. Create any HTML - Page using AngularJS. To use these nice Gauges you need ng-Google-Chart

Now lets see the HTML-Part containing the AngularJS-Directives to display and set the thermostate values:

<html><body ng-app="piApp">
  <div class="container" ng-Controller="heatController" ng-init="getStats()">
        <div class="row">
            <div class="box">
                <div class="col-lg-12">
                    <hr>
                    <h2 class="intro-text text-center">Heizungs
                        <strong>Einstellungen</strong>
                    </h2>
                    <hr>
                </div>
                <div class="col-md-12">
                    <div ng-repeat="heater in heaterSettings.allHeaters" class="heater">
                        <div class="battery"><i class="fa fa-4x fa-{{heater.battery.icon}} {{heater.battery.color}}"></i> </div>
                        <div google-chart chart="heater.gauge"  ></div>
                        <div class="caption">{{heater.name}}<br/>
                            <select ng-model="heater.ui.wish" ng-change="setTemperature(heater.id,heater.ui.wish)">
                                <option ng-repeat="option in availableTemperatures()" value="{{option}}">{{option}}</option>
                            </select>
                        </div>
                    </div>
                </div>

        </div>
    </div>
</div></body></html>

Some explanation:

piApp is the AngularJS - App for the website, getStats() loads the current Sensors using FHEM.php mentioned above directly from the start. This html uses Bootstrap (for repsonsive design) and Font Awesome to display the Battery indicator. Both use CSS to achieve this. (The Gauge-Display works without these libraries)

The Angular-Controller looks like this:

angular.module('piApp', \['googlechart'\])
    .controller('heatController', function($scope, $http) {
        $scope.url='fhem.php?';
        $scope.heaterSettings={
            allHeaters:\[
                {name:'Wohnzimmer', id:'Wohnzimmer\_Clima', ui:{},battery:{},gauge:{}},
                {name:'Schlafzimmer',id:'Schlafzimmer\_Clima',ui:{},battery:{},gauge:{}},
                {name:'Bad',id:'Bad\_Clima',ui:{},battery:{},gauge:{}}
            \]
        };

        $scope.getParamUrl=function(sensor,param) {
            return "action=get&sensor="+sensor+"&param="+param;
        };
        $scope.setParamUrl=function(sensor,param) {
            return "action=set&sensor="+sensor+"&param="+param;
        };

        $scope.getBattery=function(sensor, target) {
            $http.get($scope.url+$scope.getParamUrl(sensor,'batteryLevel'))
                .success(function(data) {
                    $scope.setBattery(target,data);
                });
        };

        $scope.getStats=function() {
            $scope.heaterSettings.allHeaters.forEach(function (heater) {
                // gauge:
                heater.gauge={};
                heater.gauge.type="Gauge";
                heater.gauge.options = {
                    width: 250,
                    height: 250,
                    redFrom: 20,
                    redTo: 30,
                    greenFrom: 0,
                    greenTo: 10,
                    yellowFrom: 10,
                    yellowTo: 20,
                    minorTicks: 10,
                    majorTicks: \['0','5','10','15','20','25','30'\],
                    max:30,
                    animation:{
                        startup: true,
                        duration: 1000,
                        easing: 'inAndOut'
                    }
                };

                // Gemessene Temperatur:
                $http.get($scope.url+$scope.getParamUrl(heater.id,'measured-temp'))
                    .success(function(data) {
                        $scope.setData(heater.gauge,data);
                    });
                $http.get($scope.url+$scope.getParamUrl(heater.id,'desired-temp'))
                    .success(function(data) {
                        $scope.setWish(heater.ui,data);
                    });
                $scope.getBattery(heater.name,heater);
            });
        };

        $scope.setTemperature=function(sensor, temperature) {
            $http.get($scope.url+$scope.setParamUrl(sensor,temperature))
                .success(function(data) {
                    console.log("Temperatur von "+sensor+" auf "+temperature+" Grad eingestellt");
                    //$scope.getStats();
                })
                .error(function(data) {
                    alert("Fehlgeschlagen");
                }
            );
        };

        $scope.availableTemperatures=function() {
            var available=\[\];
            for(var i=5;i<=30;i=i+0.5)  {
                var iasString= i.toString();
                if (Math.round(i)===i) {
                    iasString+='.0'
                }
                available.push(iasString);
            }
            available.push("on");
            available.push("off");
            return available;
        };

        $scope.setData=function(target,data) {
            var value=parseFloat(data.replace(/(\\r\\n|\\n|\\r)/gm,""));
            target.data=  \[ \['Label', 'Value'\], \['', value\]\];
        };

        $scope.setWish=function(target,data) {
            var value=data.replace(/(\\r\\n|\\n|\\r)/gm,"").trim();
            target.wish=value;
        };
     
        $scope.setBattery=function(target,value) {
            var value=parseFloat(value.replace(/(\\r\\n|\\n|\\r)/gm,"").trim());
            var color='green';
            var icon='battery-full';
            if (value<2.1) {
                color="red";
                icon='battery-empty';
            } else if (value<2.3) {
                color="red";
                icon='battery-quarter';
            } else if (value<2.6) {
                color="yellow";
                icon='battery-half';
            }
            target.battery={
                value:value,
                color:color,
                icon:icon
            }
        };

    })

Explanation:

“googlechart” in the module-configuration allows to paint those fancy gauges.

in $scope.heaterSettings.allHeaters you have to modify the Names of your Sensors. Enter as many sensors as you want.

All other functions communicate with fhem.php or display values.

Detecting Smartphone via Bluetooth on Linux (Raspberry Pi 2)

dotnet@oles.cloud (Ole Albers) — Sat, 27 Feb 2016 12:00:00 +0100

After detecting my phone using WiFi (which does only work under Marshmallow while the phone is loading or the display is enabled) and detecting the fitbit device I came back to my original task to detect my phone using Bluetooth.

While there are many documents out there that describe this on different Linux and even raspberry variants none of those really worked for me. The raspberry 2 (Debian Jessie) seem to be a bit different there.

First of all you need a Bluetooth USB dongle. I buyed the Logilink BT00015 (available at amazon.com, amazon.de or elsewhere). I would expect that others work, too. But as always: On Linux, drivers can be tricky and it’s always good to know working hardware.

Before installing drivers it is always a good idea to update everything:

sudo apt-get update
sudo apt-get upgrade

Then install the libraries needed for bluetooth

sudo apt-get install –no-install-recommends bluetooth

I received an error that some dependencies could not be resolved. I fixed that by entering the following commands:

sudo dpkg --configure -a
sudo apt-get install -f
`Now insert the USB dongle and restart the raspberry`
sudo shutdown -r now

To check if the USB-dongle is detected, enter the following command:

lsusb

This lists all USB devices. There should be one offering Bluetooth - services

Now lets check if the Bluetooth itself works:

/etc/init.d/bluetooth status The response should now contain the word “Running”:

pi@raspberrypi:~ $ /etc/init.d/bluetooth status
● bluetooth.service - Bluetooth service
 Loaded: loaded (/lib/systemd/system/bluetooth.service; enabled)
 Active: active (running) since Sat 2016-02-27 19:31:45 UTC; 17min ago
 Docs: man:bluetoothd(8)
 Main PID: 7841 (bluetoothd)
 Status: "Running"
 CGroup: /system.slice/bluetooth.service
 └─7841 /usr/lib/bluetooth/bluetoothd
`Now it's time to check for devices. Do nothing with your phone right now and enter:`
hcitool scan
`This should display all Bluetooth-devices in Range. As you haven't done anything with your phone yet it should not be displayed there. The output should be something like this:`
Scanning ...
 7C:2F:BE:EF:FA:CE Ole
 00:04:BE:EF:FA:CE SHIELD
 B8:86:BE:EF:FA:CE Fette Glotze
 88:53:BE:EF:FA:CE TOMATO-PC
 48:44:BE:EF:FA:CE TVBluetooth

(I modified the MAC addresses. I am not absolutely sure if anyone could do evil things using the MACs, but I prefer not to find that out :) )

Now put your phone into discovery mode. On Android Marshmallow you just have to enter your Bluetooth-settings for this. Then re-scan your devices. There should be one more, now:

hcitool scan

7C:2F:BE:EF:FA:CE Ole
00:04:BE:EF:FA:CE SHIELD
B8:86:BE:EF:FA:CE Fette Glotze
88:53:BE:EF:FA:CE TOMATO-PC
48:44:BE:EF:FA:CE TVBluetooth

F8:95:C7:H0:0H:0H G4

Now just note your Mac-Address. We will not pair our device. That takes a few steps and additional packages and additional problems. Pairing is not needed once we know the mac-address.

Now we cam just check the presence by using the info command. Simply leave your Bluetooth-settings on the phone and enter sudo hcitool info F8:95:C7:H0:0H:0H Event though your phone isn’t in discovery-mode anymore you will get some status information like the device name:

Requesting information ...
 BD Address: F8:95:C7:H0:0H:0H
 Device Name: G4
 LMP Version: 4.1 (0x7) LMP Subversion: 0x6109
 Manufacturer: Broadcom Corporation (15)
`if you turn off Bluetooth on your phone and re-enter that command you will receive a different response:`
Requesting information ...
Can't create connection: Input/output error
`So that's it. Just use the good old grep in your bash-script to check whether the phone is there or not:`
if hcitool info F8:95:C7:H0:0H:0H | grep -q 'Device Name'; then
 // Do whatever you like if you found it
fi

Again: Have fun :)

Tracking fitbit presence under Linux (Raspberry Pi 2)

dotnet@oles.cloud (Ole Albers) — Sat, 27 Feb 2016 12:00:00 +0100

As I wrote before I track the presence of my smartphone using WiFi. Since Android Marshmellow this doesn’t work anymore, because when switching to idle mode, the WiFi is disconnected. The easiest way to get around this issue would be to use Bluetooth instead. And in fact: I already decided to go that way. But then my company gave me a nice present: A “Fitbit Charge HR”. While my company assured, that the HR is not for Human Resource and does not try to track if I am programming enough I decided to give this a try.

Being a nerd I am not that much into that “fitness”-area. But I like the device as a small watch and the vibration alarm is nice too. I will surely sync this with my Appointments lateron. Getting some information about how many steps it takes to get the beer out of the cellar or the chips out of the kitchen is a nice benefit. Not really useful. But at least nerdy :)

So I plan to wear this device for a while. So it should be a good idea to use it for tracking my presence. Maybe in combination with a phone-detection as a fall-back. First I tried to use a standard USB-dongle to detect it. But as this device works on Bluetooth Low Energy (BLE) it cannot be detected with normal Bluetooth-Dongles. So hcitool scan or even hcitool lescan did not receive any results. Luckily the Fitbit ships with an USB-dongle. And even better, there is a package called “galileo” which purpose is to sync the fitbit. Installation is easy:

sudo apt-get install python-usb python-requests
sudo pip install galileo

Now install the dongle and restart the raspberry.

If you enter the following command sudo galileo -v you should see something like

2016-02-27 16:28:21,875:INFO: 1 trackers discovered All you have to do now to check if the fitbit is in range automaticly is some bash-magic:

if galileo -v | grep -q '1 trackers'; then
  // Do whatever you like if you found it
fi

Control your Harmony Hub with a Raspberry Pi (Linux)

dotnet@oles.cloud (Ole Albers) — Fri, 15 Jan 2016 12:00:00 +0100

So my surveillance cam now only records when I am not at home. But what if I forget to turn off the TV? That should happen automaticly, too! But fear not: There is a solution - at least if you own a harmony hub. With the help of the “HarmonyHubControl” - tool (written in c++) this is done quite easily.

First of all you need to put the source onto the Raspberry. Don’t be afraid. No rocket science here. All needed tools should be already on your Linux distribution. The easiest way would be to clone the source via git: git clone git://git.code.sf.net/p/harmonyhubcontrol/code harmonyhubcontrol-code If you prefer you may - of course - also use the long way and download those files in a zip file.

Now after you have the source code on your Pi you have to compile it. Done with ease. Just a single

make and you created the file “HarmonyHubControl” in that directory. Now all you need to know is the IP-address from your hub. You usually can find it in your WiFi-Router under the name “HarmonyHub”

Let’s try if the connection works:

./HarmonyHubControl \[Login\] \[Password\] \[Ip\] Warning! Double-check your password. If you enter a wrong one, you can still stert the activities, but on the next login in your “MyHarmony”-application you will be thrown out for a while. Don’t ask why this works this way. Better ask Logitech instead.

The Login is your email-address. If username and password are right you should see the following result:

So let’s list all activities: ./HarmonyHubControl \[Login\] \[Password\] \[Ip\] list\_activies As you can see there is an activity with the id “-1”. This activity shuts down all devices. For testing let’s just start an activity: ./HarmonyHubControl \[Login\] \[Password\] \[Ip\] start\_activity 15231836 does start the FireTV in my case, ./HarmonyHubControl \[Login\] \[Password\] \[Ip\] start\_activity -1 does shut em all down.

If you want to, do some fancy stuff with that possibilities. Use your stereo as an alarm clock? Have fun! (your neighbours, too, btw) :)

Switching the LED of a surveillance cam on and off using Linux

dotnet@oles.cloud (Ole Albers) — Fri, 15 Jan 2016 12:00:00 +0100

I already wrote a script on my Raspberry that starts and stops the surveillance mode of my camera using the “Surveillance Station” on the Synology DiskStation. Now I wanted to extend that tool and light the LEDs of the cam when it is recording and turning them off if it isn’t.

This has two reasons: First: I do not want to use the cam for “secret recordings”, damaging the private spheres of my visitors. Second: I can easily see if the cam is working as expected. Now my cam has the option to activate the LEDs or deactivate from a web interface, but it is all-or-nothing. It does not depend if it is recording or not. Which isn’t a surprise as the camera does not trigger the recordings itself but this is done by the Surveillance Station.

I own (and use) the “Robocam 4”, sold by 7Links. But this hardware is quite common and used under different names, too.

Finding out the right commands is quite straight-forward: Open the webinterface and listen what happens there using the developer console in Chrome:

The “Request URL” and “Form Data” are the most interesting informations here. Before entering that stuff into the Linux-shell let’s test this with a more “comfortable” interface. The chrome extension “Postman” offers a nice way to play around with POST-Requests. The setting should be “x-www-form-urlencoded” here:

If everything works as desired it is time to put that command to Linux using shell commands. Especially easy if the come does not only accept POST-requests, but GET-requests, too.

http://192.168.0.88/admin/system.cgi?led=2

worked like a charm in my case.

The only thing that’s left is the authentifivcation. If you receive a classic login-screen like from a .htaccess password-protection it can be easily added to the url. So wget http://username:password@192.168.0.88/admin/system.cgi?led=2 turns on the LEDs wget http://username:password@192.168.0.88/admin/system.cgi?led=0 turns them off

(0=off, 1=on, 2=blinking)

Just add these lines to your existing script and the LEDs should be work just like needed :)

Automate your Synology Surveillancestation with some simple Linux - commands

dotnet@oles.cloud (Ole Albers) — Thu, 07 Jan 2016 12:00:00 +0100

I own a Synology diskstation which has the “surveillance station” on board which records content from any LAN (or WiFi)-enabled webcam and sends an alarm when someone is moving at my home. It is possible to enter time schedules when the camera should be enabled and when it shouldn’t. But that does not really work the way I wanted. When I come home earlier or even have a day off I have to disable the camera manually.

So I decided that I want to use my smartphone to trigger the surveillance mode. Like most of us I always carry the phone with me. So it should be easy: If the phone is at home, I am, too. So the camera should be off. The same way when I am not at home.

The solution for this was surprisingly simple: A small bash-script first checks if the phone is in the network. The Surveillance station cam gets enabled or disabled according to this one condition.

But first things first. First of all, you should go to your routers admin interface and make sure, your phone will always have the same IP in your local WiFi. This works different on any reouter. On TP-Link it is called “reserve Ip”:

Now all you need is a Linux machine. I took a fresh Raspberry for this goal. Any simple distribution should be fine. We won’t need any special libraries.

After you connected to your Raspberry (or other Linux) create the following shell script via vi (or any other tool you prefer):

user='pi'
pass='circle'
server='sauger:5000'
phone='192.168.0.7'

dt=$(date '+%d/%m/%Y %H:%M:%S');
cd $(dirname $0)
touch lgstate.txt
read oldValue < lgstate.txt
if ping -c 3 ${phone} | grep 'bytes from'; then
  if \[ $oldValue != 'isda' \]; then
    echo \[${dt}\] 'stop recording'
    echo 'isda' >lgstate.txt
    #login
    wget -q --keep-session-cookies --save-cookies cookies.txt -O- "http://${server}/webapi/auth.cgi?api=SYNO.API.Auth&method=Login&version=3&account=${user}&passwd=${pass}"
    #disable
    wget -q --load-cookies cookies.txt -O- "http://${server}/webapi/entry.cgi?api=SYNO.SurveillanceStation.Camera&method=Disable&version=3&cameraIds=1" >dev>null
    #logout
    wget -q --load-cookies cookies.txt -O- "http://${server}/webapi/auth.cgi?api=SYNO.API.Auth&method=Logout&version=3" >dev>null
  else
    echo \[${dt}\] 'still there...'
  fi
else
  if \[ $oldValue != 'iswech' \]; then
    echo \[${dt}\] 'start recording'
    echo 'iswech' >lgstate.txt
    #login
    wget -q --keep-session-cookies --save-cookies cookies.txt -O- "http://${server}/webapi/auth.cgi?api=SYNO.API.Auth&method=Login&version=3&account=${user}&passwd=${pass}"
    #enable
    wget -q --load-cookies cookies.txt -O- "http://${server}/webapi/entry.cgi?api=SYNO.SurveillanceStation.Camera&method=Enable&version=3&cameraIds=1" >dev>null
    #logout
    wget -q --load-cookies cookies.txt -O- "http://${server}/webapi/auth.cgi?api=SYNO.API.Auth&method=Logout&version=3" >dev>null
  else
    echo \[${dt}\] 'still noone at home'
  fi
fi

Change “user” and “pass” in the beginning of the script with your user credentials. You can create a new user for this or use the “admin” - user. The user has to have admin rights sadly so don’t use this script on any machine that can be accessed by anyone but you.

“server” is your server address enter the hostname (or ip) and port there

“phone” is your phone’s IP-address

So what does this script do?

First it tries to ping your smartphone. If this is successful, it checks if this is the first time that works. If it isn’t the first time, nothing has to be done. But if the phone wasn’t accessable before it logs onto the synology and disables the camera using the web api.

The same way it enables the camera if the phone cannot be contacted anymore.

The script does only minimum outputs. If you run into problems, just remove the “>dev>null” part on any line to get more information.

Before you can start the script you should create an empty file where the state is saved by entereing touch lgstate.txt You can run that script by entering “./pingPhone.sh” on the command line. You can watch the changes live in the Surveillance Station -View of the Synology. Changes are displayed instantly. You do not need to refresh the page.

If you have more than one camera change the value of “cameraIds” to another value that is needed. You also can select multiple cameras by using commas: “&cameraIds=1,4,5”

Finally if you want to run this script automaticly you can create a simple cronjob for it

open crontab -e and enter the following line: \*/15 \* \* \* \* /home/pi/pingPhone.sh >>/home/pi/pingPhone.log (of course the path may differ on your system)

Now the presence will be checked every 15 minutes and the cameras will enabled or disabled accordingly. Now all you have to do is to modify your time schedule in the surveillance station that the camera is always in detection mode.