The words “just”, “easy”, and “simply” tend to oversimplify and trivialize complex issues or processes, and in doing so, can inadvertently discount another person’s experiences or knowledge. By saying “it’s easy” or “just do this”, we may not realize that we are implicitly undermining the intricacies, challenges, and the depth of the topic or problem at hand.

Consider a situation where a seasoned engineer tells a novice, “It’s easy, just follow these steps”. What’s easy for the engineer, with years of experience, may be overwhelming for the beginner. By using “just” or “easy”, the veteran inadvertently trivializes the breadth of their own experience and knowledge while potentially discouraging the novice who may be struggling to understand.

From a psychological perspective, this kind of language usage can be discouraging and disheartening. It can create a barrier to effective learning and growth. When someone hears that something is “easy” or they should “just” do something, they may internalize a perceived inability to accomplish the task. If it’s so “simple”, why are they struggling? Such feelings can erode confidence and foster a detrimental belief that they lack ability or intelligence.

In business and professional settings, it can foster a culture of disrespect and dismissal. Using “just”, “easy”, and “simply” can often understate the effort, time, and skills required to accomplish tasks or projects. It can result in underappreciating the work involved and the people doing it. This language minimization can ultimately lead to demotivation, decreased productivity, and a decrease in morale.

So, what can we do to mitigate these impacts? The answer lies in fostering a culture of empathy, respect, and clear communication. Acknowledge the complexity inherent in most tasks and projects. Avoid the temptation to use minimizing language that oversimplifies. Instead, encourage an open dialogue about challenges, complexities, and difficulties. Use language that respects and appreciates the depth of knowledge, expertise, and effort involved.

Remember, every expert was once a beginner, and every task has its hidden complexities. The more we strive to respect these truths in our language, the better we can foster a positive and encouraging environment for learning, growth, and collaboration.

The post The Hidden Power of “Just”, “Easy”, “Simply” appeared first on Boshdirect.

Summary

How does this work you might ask? Web servers can route traffic to other servers using what’s called a “Reverse Proxy.” A proxy is a server or device which can act as an intermediary for other devices. In this case, the web server in your NAS can proxy traffic from other web servers on the same machine or even in the network. This allows you to have a single base URL like http://myserver.com which you can use for all your traffic. Each of your servers will then either be accessible via a subdomain or path.

Subdomain

• http://app1.myserver.com
• http://app2.myserver.com

Path

• http://myserver.com/app1
• http://myserver.com/app2

Challenge

In a typical setup, you would open up a port on your router for each and every server or device you want to access outside your network. In this case, your when you setup port forwarding on your network, your router is proxying the connections from outside your network to devices inside your network. The downside with this approach is you need to open a port for each and every server on your network and if any of those devices share the same port, you will only be able to forward traffic for one of the devices or you’ll have to forward a non-standard port.

Additionally, some networks like work or public networks will block non-standard ports. This means that if your server runs on a high port number like 5050 or 8989, it’s possible that this port will be blocked on other networks you might use. Using a reverse proxy, you can use a standard web port which should be open on a normal network (80=http, 443=https).

How-to (QNAP)

In this example, I’ll show how to setup an HTTP Reverse Proxy on a QNAP NAS using the built-in webserver, Apache.

Note: The same general concepts of modifying the Apache configuration file applies to other devices as well, but you may need to find the location of your configuration file.

Update: I have switched from Apache to Traefik as a reverse proxy on QNAP. Updating the built-in Apache configuration on QNAP has become increasingly difficult and the introduction of containers on QNAP has made the use of packages like Traefik much more approachable.

I’ve left the remainder of this blog post available as the concepts from this article apply to using Apache as a reverse proxy on other systems as well.

We will setup a reverse proxy to allow access to the following servers:

• http://myserver.com:8989 → http://myserver.com/sonar
• http://myserver.com:5050 → http://myserver.com/couch

To do this, we will start by remoting into our NAS using SSH. If you don’t already have an SSH client, consider using Mobaterm which has an SSH and SFTP client all built into one.

1. Open your SFTP client and connect to your NAS IP address.
2. Navigate to /mnt/HDA_ROOT/.config/apache/
   
3. Open/Edit your apache.conf file, scroll to the bottom and add the following line:

   Include /share/Web/custom.conf

   
   Note: You can also include the contents of the custom.conf (below) directly in your apache.conf file, but some NAS devices will completely reset the apache.conf file upon reboot. By using an external file, you can quickly ‘fix’ things after a reboot by adding the single “Include” line.

4. Save the file and choose ‘Yes’ to upload it back to the NAS
5. Navigate to /share/Web/ and create a new file called custom.conf
6. Open/Edit the newly created custom.conf file and add the following details

   #Customizations for reverse proxy
   LoadModule proxy_module modules/mod_proxy.so
   LoadModule proxy_http_module modules/mod_proxy_http.so
   ProxyPass http://localhost:8989/sonarr
   ProxyPassReverse http://localhost:8989/sonarr
   ProxyPass http://localhost:5050/couchpotato
   ProxyPassReverse http://localhost:5050/couchpotato
   

   Note: The path in the location tag is the path you want to use to access the server. The URL inside the location tag is the current target URL of the server. Also note that some applications will require you to set a ‘Url Base’ in the General/Server advanced settings as shown in the example here for the target URLs.

7. Save the file and choose ‘Yes’ to upload it back to the NAS
8. From the SSH interface (right side of Mobaterm), enter the following command and press Enter:

   /etc/init.d/Qthttpd.sh restart

   

Congratulations! You’ve now setup your reverse proxy and can access your servers at the desired URLs!

The post Multiple Servers from One Port on NAS appeared first on Boshdirect.

Note: In order to take advantage of the “pay for what you use” model, make sure you select the ‘Dynamic’ App Service Plan – the classic mode allows you to use your existing App Service resources to run your functions on your existing resources with no additional cost.

Azure Functions can be written in “JavaScript, C#, Python, and PHP, as well as scripting options such as Bash, Batch, and PowerShell.”

Azure Functions are event based in nature – there are a number of bindings for input and for output. Functions can be triggered by time events, Azure platform events, external SaaS triggers, and WebHooks (HTTP API calls). Additionally, Azure Functions make it easy to write the results of your logic back into resources like Azure Storage (Blob, Table, Queue), DocumentDB, HTTP calls, etc. The full list of input and output bindings can be found in the Azure Functions Runtime documentation under the Bindings heading.

Azure Functions can be built completely in your browser or you can use traditional development tools like your favorite IDE. To get started, navigate to the following address and sign-in with your Azure account:

https://functions.azure.com/signin

If you don’t already have an Azure account setup, sign-up using the Azure Portal – once you’re in the Azure Portal, you can also create a Function by taping the New (+) option in the menu and searching for “Function App” by Microsoft in the marketplace.

Creating a Function from the functions.azure.com landing page is a quick-start experience for creating functions and is easy for quick one-off demos. If you want more control over the creation of your Function App, the Azure portal results in the same Function app being created, but gives you more control over specifying the Resource Group, Storage Account, and pricing model (dynamic vs classic).

While you’re creating a Function in the Azure portal, you might even notice that Microsoft has Functions listed under Web + Mobile – that’s because Functions are based on the core technology behind the Azure WebJobs SDK feature. Functions take what’s great about the WebJobs SDK and make it even easier to use – this is great if you’re looking to run code based off the input and output bindings that Functions make available. (For more info, check out this Stack Overflow response by Chris Anderson of Microsoft)

Within your Function App, you can create multiple different functions. All of these functions can run independently, but share the same Function app setts – memory, CI, authentication, CORS, etc. When creating a function through the portal, you will be presented with a number of templates to help you get up to speed quickly. These templates include small snippets of code showing how to setup a variety triggers – just make sure you try the different ‘Scenarios’ from the drop down which show some of the external integrations and some sample snippets like a Face Locator and Image Resizer.

It’s easy to get started, so try it out and refer to the Azure Functions developer documentation as you work through your first Function!

The post Azure Functions – Serverless Code appeared first on Boshdirect.

Update: An update to the firmware seems to have established Flash as a requirement to view the streams from the browser. While this isn’t as bad as needing a proprietary plugin as was needed in old firmware, it’s still not quite as good as being completely plugin free for modern browsers.

It feels a bit odd to be excited about an IP camera that doesn’t require a browser plugin in 2016 considering browser plugins like Flash, Silverlight, and ActiveX components have died out across most parts of the web, but this is the sad reality of IP cameras where custom plugins, ActiveX components, and custom Chrome Apps are fairly standard. Mind you, if you are using your mobile phone you are probably going to prefer to use a mobile app from the vendor or even a third party app like TinyCam Pro or Blue Iris, but it’s nice to be able to pull up a browser and access your camera without having to install anything.

The change from the previous Reolink web based viewer is apparent right away – simply type in the IP address of your camera in your browser and you are immediately prompted to login – in previous installations, you would be presented with a hideous screen asking you to install a plugin and forcing you to use Internet Explorer. With the latest update, you can simply login and immediately start viewing the live video feed from your camera. By default, you’ll view the “Clear” stream, but you can also select to view the “Fluent” stream if you have a limited network connection or want to save on bandwidth – to do this, simply select the “Fluent” radio button before completing your login.

The video stream is smooth and high-quality and looks like just what you would see when using the desktop or mobile apps. In fact, the new web interface seems to mimic the Windows desktop client application in terms of the general design. The top left of the screen shows the “Preview” tab which is used for viewing the live video feed and is what you land on immediately after logging in. The video feed is immediately below and includes options for changing the view type, taking a snapshot, and playing/stopping the video feed. On the right side of the screen are a number of quick configuration options for adjusting the settings on the camera (more on this later).

If you find that the feed is a bit stretched out, you can either adjust the dimensions of your browser to scale the video feed to fit your screen or tap the ‘view’ button on the right side of the view toolbar (above the video feed) to change between ‘stretch’ and ‘center’ options. The default stretch option will stretch the video feed to fit the screen which can resort in the video looking misshapen and distorted. The ‘center’ option matches the height of the video to the height of the space in the browser then horizontally centers the video – this works well if the action is in the middle of your screen as it can sometimes result in the sides of the video being cropped off. It would be great if Reolink also offered a ‘scale’/’fit’ option which would scale both the height and the width of the video to fit the screen, but I’ve found that I can usually find a good fit by switching between the stretch and center options depending on how I have my browser scaled.

Next to the ‘view’ button, you’ll find the ‘snapshot’ button which lets you take a snapshot (picture) of the current video feed. Unfortunately, this feature take 1-2 seconds to actually take the snapshot, so if you have something you want to get an immediate snapshot of this feature might end up disappointing you. On the other hand, this is a quick and easy way to get a picture of the content currently on the screen. Once the snapshot is taken, you are given a preview which you can double-click to view full-screen or right-click to save to your computer.

The quick configuration options to the right of the video mimic the settings seen in the desktop and mobile apps and provide a way to quickly tweak the video feed. The basic settings includes the ability to adjust the On Screen Display overlay (OSD), video encoding, and image settings. The advanced settings includes adjustments for anti-flicker, exposure, white balance, day/night, backlight (dynamic range), and 3D Noise Reduction. If you’re looking for additional configuration options, click the cog icon in the top-right corner of the screen which lets you access additional features like Masks, Network Settings (including Email and FTP), Motion Triggers, Firmware Updates, Auto Reboots, and User Management.

Overall, this is a great update – there are a few small issues like the scaling of video and the delay in taking a snapshot, but the ability to access your video feeds directly in your browser without plugins is awesome!

The post Reolink HTML5 IP Camera Viewer appeared first on Boshdirect.

At first, I was a bit baffled as the developer guidelines clearly state that GuidedStepFragments should be added programmatically and not via XML files and there weren’t any clear references to our control over the XML file. I took a quick peek at the manifest from the androidtv-Leanback example and quickly realized the difference – they were explicitly specifying the theme in the activity declaration. In their example, they were using a modified theme, but in my case I simply added the theme attribute with the default Theme.Leanback.GuidedStep and everything started working as expected.

<activity
    android:name=".tv.TVSetup"
    android:label="@string/action_settings"
    android:theme="@style/Theme.Leanback.GuidedStep">

The post Android TV: GuidedStep InflateException appeared first on Boshdirect.

Azure Queues allow you to store a large number of lightweight messages leveraging Azure Storage. Typical use cases for queues include buffering a set of data or actions for processing. And since the Queues are part of Azure Storage they are super cheap. As of writing this, each queue message can be 64 KB in size and a queue can hold millions of messages (up to the capacity of the storage account).

Examples:

Scott Hanselman has a post showing how an Azure Queue can be used along with Azure WebJobs to offload processing of images. This is a great example as it shows how a real application might accept images from a user in real-time, then use a queue as the hand-off for another service to actually process the images.

As another example, I have used Queues as a temporary staging ground for incoming IoT data from my connected SmartHome where a WebJob then took care of properly sorting the data and moving it to the destination Azure Table Storage location. This allowed me to take advantage of the massively scalable architecture of Azure Queues instead of having my logic running on a Web App where I would have had to take care of scalability.

How can I access the Queue?

Like many other things in Azure, Queues can be accessed through a REST API which is what we will cover in this post. Microsoft has also put together a number of wrapper APIs for .NET, Java, PHP, Node.js, Python, and Ruby which allow you to work with native language constructs and objects while the API takes care of interfacing with the REST API.

Regarding authentication, in order to access resources like Queues on Azure, you can:

• Make the Queue public
• Use your Primary or Secondary storage account key
• Build a custom application / service to proxy requests
• Generate and use a Shared Access Signature (SAS)

For the purposes of this post, we are going to assume an example where we want to be able to limit access to the Queue – that means making the queue public is not an option. And if we have full control of the application using the queues, then perhaps using the Primary or Secondary storage account key is sufficient. But what if we don’t have control of the application – for example, it’s running in a scripting language on a third party server. We might consider building a custom web application or service to proxy the requests, but now we have to deal with scalability and an additional layer of code when all we want to do is allow another application to add to the queue.

This is where Shared Access Signatures come in…

What does a Shared Access Signature do?

Shared Access Signatures allow us grant limited access to the queue without having to expose our main storage account keys or build a custom service. Even better, Shared Access Signatures allow us to grant specific permissions on the queue for a limited set of time. For example, we might want to issue a SAS that allows a client to only PUT new items on the queue (but not read/delete) and only allow this access for the next hour. We can generate a SAS and share it with the client and they will be able to PUT new items on the queue for the next hour and we no longer have to worry about the Primary or Secondary storage account key being exposed or being used for malicious intent if it falls into the wrong hands.

Microsoft has a great post explaining how Shared Access Signatures work and why you would use them if you want more information.

How do I use a Shared Access Signature (SAS)?

First, you’ll need to generate a Shared Access Signature. The specification is fairly straightforward, but it has a number of components to it and can be frustrating to work with if you are just trying to use a one-off SAS without worrying about all the details of generating a SAS. And if you want to create a service that generates SAS tokens, Microsoft has a good article including working C# code just for you.

If you just want a quick app that will generate SAS tokens for you, check out Azure SAS Generator on the Windows store.

Here’s a few types when generating the SAS:

• Try using the 2012-02-12 SAS version
• Make sure you have specified an expiry time (the `se` parameter)
  • And make sure it is far enough in the future!
• Specify at least one permission using the `sr` parameter
  • r = read; a=add; u=update; p=process

Using the SAS generated above, I would simply use the Copy Both button to copy the fully parameterized URL:

https://storageaccount.queue.core.windows.net/resource_name?sv=2012-02-12&se=2015-07-24T13%3A45%3A00Z&sp=r&sig=r8dN1Hvrkk6gRHLBRtA%2BkbqwAKRj3I9TmXUtz4hSht8%3D

And then adjust it per the Azure Queue REST API. For example, if I wanted to peek at 10 messages in the queue, I would modify the URL like:

  https://storageaccount.queue.core.windows.net/resource_name/messages?peekonly=true&numofmessages=10&sv=2012-02-12&se=2015-07-24T13%3A45%3A00Z&sp=r&sig=r8dN1Hvrkk6gRHLBRtA%2BkbqwAKRj3I9TmXUtz4hSht8%3D

Other tips:

• When posting to the queue via the REST API, consider base64 encoding your text as the standard C# library and Visual Studio plugins require the text to be base64 encoded
• Refer to the Azure Queue REST API documentation and ensure you have included all parameters

The post Azure Queue via Shared Access Signature and REST appeared first on Boshdirect.

The command is pretty simple, but be warned that it can have grave consequences if you remove the wrong thing:

git filter-branch --force --index-filter \
'git rm -r --cached --ignore-unmatch .idea' \
--prune-empty --tag-name-filter cat -- --all

git push origin master --force

In the example above, I removed the default .idea folder that is included with JetBrains IDEs like IntelliJ and Pycharm.

The post Remove Folder from Git with History appeared first on Boshdirect.

http://sharptools.boshdirect.com/features

The post SmartThings Tasker plugins and Widgets appeared first on Boshdirect.

Note: If you just want to know how to Configure your Stick-N-Find for use in Tasker, jump to Configure as iBeacon

Needs and Alternatives

I have a fair amount of experience automating my home and life through the use of Tasker, AutoApps, Z-Wave, and custom technology, but there didn’t seem to be a whole lot of information online about automating local proximity detection with Android at the time of writing this article. Note that there are solutions for proximity detection which use the built in proximity sensor, but this is generally only useful for the proximity of a hand / object to the sensor. While this form of proximity detection can be helpful for detecting gestures like hand-waves, I was interested in more broad detection such as the proximity of the phone (without line-of-sight) to a room within a home or office building. For example, I wanted my phone to know if I was in the Living Room or in the Bedroom so when I gave it voice commands it could respond in the proper context.

While the built-in Android proximity sensor provides information about proximity very close to the device, the other end of the spectrum is technology like Geofences and GPS data. I use apps like AutoLocation which provide excellent tools that leverage the Android Fused Location provider and have been tremendously helpful for setting up Geofences that can detect rather large areas. For example, AutoLocation can be useful in detecting when I’m in my neighborhood, when I’m at my house, when I’m at the office, or even when I’m walking vs. driving.

The type of location sensitivity I was looking for lied somewhere between the proximity sensor (very near) and Geofence solutions (far). I already had tools to detect when an object was close to my device or when my device was in a particular building, but I wanted to be able to detect when my phone was in a general area like a particular room.

Stick-N-Find Stickers

Notice: This article was originally posted in 2014 and Bluetooth Smart (BLE) technology is evolving quickly. I would encourage readers to do a quick search on Amazon or Google to see if there are any newer devices with positive user feedback and ratings.

After researching a bit, I found that there were several Bluetooth LE / iBeacon manufacturers out there, but the two that came to the forefront were the Estimote Beacons and Stick-N-Find stickers. Of the two, the Stick-N-Find stickers were cheaper and seemed to be more consumer oriented. I read a number of bad reviews about the Stick-N-Find devices, but I decided I would test the devices considering there had been documented recent improvements with the firmware of the devices.

When I first received the Stick-N-Find stickers, I did like every normal consumer does and immediately started playing with the devices without reading the instructions. When I pulled the beacons out of the box, one of them bounced across my desk and beeped at me – I was a bit surprised to hear this, but I later found that the devices ship in a deep-sleep mode and tapping them 5 times on a hard-surface wakes them up. I had already done a some reading online, so I knew that I would need to update the firmware on the stickers, but the published articles indicated that you may need an iOS device to perform this update. I figured I would give it a try with the stock firmware on the Android app anyway, so I downloaded the latest version of StickNFind from the Google Play store. The 2.5 star review was another reminder of the woes other users had experienced, but I trudged ahead.

I opened the Android application and selected the ‘Pair new Sticker’ option which prompted me to hold the new sticker very close (to the phone) then select it from the list to connect. The prompt also indicated that if a sticker has never been paired before, it should be tapped 4 times to wake the sticker up which would cause the sticker to beep as confirmation that the sticker is awake. I was happy to see that the device paired quickly and was even happier to see that the Android app was prompting me to update the firmware. The firmware update took several minutes for each device, so be patient as you wait for the firmware to update and be sure to keep the phone and sticker near to each other.

Stick-N-Find App

The app worked fairly well and while I don’t intend to review the app in depth, I’ll briefly hit on the core functions. The app is capable of pairing with devices, locating devices, and notify you when a sticker is in/out of range. The first feature I tried was the Radar location finding feature. After pairing with a sticker, I opened up the radar and it showed the sticker I had just connected. When you first connect to a sticker, the app may show a spinning icon and text saying it is trying to wake the sticker. The icon next to the name of your sticker will show a spinning icon as it is trying to connect and once it is connected the icon will turn a solid blue and the “Page” feature and device status including temperature and battery life will become available. The page feature sends a signal to the sticker causing it to start beeping and flashing – both the beeping and flashing are relatively quiet so you will need to be fairly close to the device or in a relatively quiet area to hear it.

The signal strength / radar feature gives you a really rough approximation of how far away from the device you are. As you get really close to the device the signal strength approaches 100% and as you get farther away the signal strength drops to 0%. I found that when the sticker was directly touching my device I would get 99.8% strength; at 1 meter I would get between 98-99%; and at 5 meters I was usually 90%+. I would emphasize again that the signal strength is a relative measurement and can be greatly impacted by walls, bodies, metal, and other objects but it was still fun to try to track a device down and then when I was in range use the Page feature to locate the device. One thing I found is that if I selected the “Click for More Options” bar at the bottom of the screen, sometimes it would only find one of the devices (indicated by the grey/blue bar to the right of each device name). When I would then click on the device which wasn’t showing signal, I would get a message that “You can not connect to an out of range sticker”

The other feature of the app that was interesting to me was the ability to alert the user when the sticker was in range or out of range. Both features are listed under the Alerts tab of the application. The in-range feature is labeled ‘Alert Me When In Area’ and allows sounds the user-selected alarm sound whenever the beacon comes in-range (after being out of range). The out-of-range feature is called a ‘Leash’ and allows the user to set a duration that the sticker can be out of range from the phone before the alert is triggered. Both of these features seemed to work fine with the limited testing I did and seem to be part of the core focus for the target user of this device.

Other Bluetooth LE Apps

Since the Stick-N-Find stickers use standard Bluetooth Low Energy technology, you can access certain information from the devices using other Bluetooth LE apps. I first tried BlueScan and found that the scanner was capable of finding the tags when the drop-down was changed from Classic Scan to Low Energy Scan, but the descriptor seemed to be incorrect and could be related to the default output from the Stick-N-Find devices which appears to be in a proprietary format. That being said, the software was capable of finding the devices and did show some limited information. I also tried Bluetooth LE Scanner which provided much more detail and has the source-code available on GitHub. Bluetooth LE Scanner has some other cool features like the ability to export scans as CSV files and the ability to connect to a device to get additional details and then share those details via email, clipboard, etc.

Configure as iBeacon

In order to be recognized by iBeaconTasker, the Stick-N-Find sticker must be profiled as an iBeacon with a supported UUID. At the time of writing this post, iBeaconTasker was only supporting Estimote beacons and was looking at adding support for additional generic iBeacons. In order to configure the Stick-N-Find sticker as an iBeacon with an Estimote UUID, you will need to download SticknFind BeaconMaker (Android) or SNF Beacon (iOS).

Android Instructions:

1. Install the SticknFind BeaconMaker app
2. Open the “Beacon_Maker” app
3. Select iBeacon
   
   
4. Wait for the list of SnF stickers to populate, then select your sticker.
   Note: If you don’t know which sticker is the one you are interested in, try taking your sticker with your phone and walk away from other potential devices. The ‘R’ value is an indicator of the signal and is likely the lowest value if it is closest to your phone. (eg. -30 to -50)
5. Change the UUID to the Estimote “B9407F30-F5F8-466E-AFF9-25556B57FE6D” and select a unique Major and Minor ID.
   Warning: Make note of your current UUID in case you want to switch back to it later!
   Note: The Major and Minor IDs are entered as hex values. Use an Integer to Hex converter to get the appropriate Hex value.
   Note2: The Major and Minor IDs are arbitrary for our purposes, but try to use the same Major ID across all of your devices and make sure you have a unique Minor ID for each device.
6. If you would like to adjust the range of the Beacon down, do so now (to save battery and reduce how far the Beacon pings)
   Example: I adjusted my SnF device down to -16 dBm to reduce the range so it only triggered when I was in the room and not in other rooms in the house/building. You can also adjust these parameters later and update the device again to try different values.
   
7. Press the Enable button. The application may connect and disconnect from the device multiple times as it prepares for the update. If this is your first time updating the device, it may go through a several minute process (similar to the SnF firmware update) and will display a progress bar indicating the status. Make sure to keep your phone near the sticker during this time.
   Note: In my case, the buttons changed from Busy > Connecting > Busy > Connecting then the progress indication popped up and the update took 3-5 minutes.
   
8. Wait a few moments after the update is complete and you should see a success message showing “Parameters are set succesful”
9. Validate that your device now shows ‘iBeacon’ where it previous showed SnF and verify that the UUID and Major+Minor IDs are displayed.
   

I have just started my foray into this particular part of the software, but I believe this will allow me to configure the Stick-N-Find device as an iBeacon which should make it usable with other iBeacon aware software like iBeaconTasker.

iBeaconTasker

Notice: Some users have reported that the quality of iBeaconTasker has dropped significantly and it crashes frequently. While I have not personally tested it, users of the SmartThings community have noted that Bluetooth Detection by Kanetik is a good Android alternative with great support from the developer.

Tasker is a great automation tool for android that allows the device to respond to states and events and perform various actions. There are several plugins available for Tasker that extend the type of events and states that Tasker can respond to and perform. Most of my favorite plugins come from AutoApps, but I am particularly interested in iBeaconTasker which allows Tasker to respond to the presence or lack of presence of an ‘Estimote’ iBeacon device. Out of the box, iBeaconTasker does not find Stick-N-Find devices, but once you have updated your Stick-N-Find device to the iBeacon profile and set an Estimote UUID, the plugin should recognize your devices. 

Once your sticker is profiled as an ‘Estimote’ iBeacon, follow these easy instructions:

1. Open Tasker
2. Create a New Profile
3. Select ‘State’ as the context
4. Choose Plugin > iBeaconTasker
   Note: make sure you have installed both Tasker and iBeaconTasker.
5. Click the pencil icon next to Configuration
6. Select your desired ‘Estimote’ iBeacon
7. Choose whether you want the profile to be triggered on when the device is Connected (moves in range) or Disconnected (moves out of range)
8. Click the check mark to continue
   Warning: Make sure you have disconnected the Beacon from all other apps and be sure to close any apps which might be accessing the Beacon. These apps could prevent your tasks from triggering as expected.
9. From the ‘State Edit’ Tasker screen, verify that your selected configuration is in place (eg. “Beacon connected” or “Beacon disconnected” is displayed under configuration) and press back to save your configuration
10. From the Enter Task prompt, choose an existing task or create a new one. For purposes of demonstration, we will create a new task.
    Note: At this point, your task should trigger whenever the iBeacon condition is met. If you have multiple beacons or want to be able to check the status of beacons when running tasks, you may want to set global variables 
11. Enter a task name and click the check mark to continue.
12. Click + to add an action. Select Variables > Variable Set
13. Enter “%BEACON_PRESENT” as the name and “1” as the To value.
    Note: This will set the global variable BEACON_PRESENT to 1 indicating that the Beacon is present. This will allow you to check the BEACON_PRESENT variable from other tasks. Make sure you also set a profile/task to set the BEACON_PRESENT to 0 to indicate the Beacon is no longer present. You could also use this variable as a place to store the ID of the most recently seen variable to make your tasks even more conditional.
14. Build your additional profiles/tasks and enjoy!

The post Stick-N-Find iBeacon appeared first on Boshdirect.

https://github.com/debian-pi/raspbian-ua-netinst

The readme file that is shown on the base GitHub project linked above covers the basics of installing the operating system which I will briefly touch on here and the cover a few additional configuration options I choose to do. Some of the key things I like about the raspbian-ua-netinst project is that it fits on a 512 MB card, it downloads the required components through an internet connection via the Ethernet port, and it can do all the hard work completely unattended.

At a high level, here is what is needed to perform the install. (Reference the github link above for more detailed instructions):

• Grab a 512 MB or larger SD card
• Download the 10 MB installer package
• Format the SD card as FAT32
• Unpack the installer archive
• Copy the unpacked files to the SD Card
• Plug the SD card and a network cable into the Pi
• Power up the Pi and let it install (this is the unattended part mentioned above)

After letting the system run through the installation, I attempted to start the python interpreter and received the following response:

I then attempted to to issue a command as root using sudo and received the same response:

After going through a few more commands, I realized that a few of my favorite Linux commands/applications were missing including Python, Sudo, and Nano. In order to get these applications installed after the base Raspbian-UA-Netinst installation, run the following command at the command shell to install the above packages:

Additionally, in order to use sudo, you will want to add your own user. Run the command below substituting the [username] with the preferred username for the new user account you would like to create:

Follow the prompts to complete the addition of the user. This should prompt you to set the password and other descriptive information for the user. When this step is complete, we will add the user to the sudo group to allow the user to temporarily escalate their permissions when needed via sudo.

Additionally, if this user will be using serial ports (files in /dev/) you will want to add the user to the dialout group:

The post Install Raspbian on 2GB Card appeared first on Boshdirect.