Microsoft’s deception: the Photo’s app in the post-creators release

Frustration.  That’s the word to describe what it can be like to be a Windows Insider.

Awesome! Another word to describe what it is like to be a Windows Insider.

The two words are, generally, not used at the same time to describe the experience.

Recently, however, that was, in fact, the case.

As an Insider, when Microsoft introduces new features or changes to Windows and asks the Insiders to bang away, we trust that the feature we are asked to go test is, you know, actually there.  Such was the case, very recently, when new features were added to the Photos app in Windows 10.  Microsoft made a huge deal out of the new features: ability to create a sharp video out of video clips and photos. It could pair it the right music and will have the ability to inject 3D objects that could interact with the objects in the video. It looked spectacular.  But, as it was to be an early release, not all features would be immediately available.  As it turned out, many insiders didn’t get the new features at all. See, what Microsoft failed to reveal was that a subset of Insiders were prevented-so the story goes-from getting the new stuff, on purpose, to serve as a ‘control’.  Now, why they needed this ‘A/B’ test is beyond me. I could see it for, say, different file systems–see who it worked on better, compared to a control population, but not for a feature so prominently featured in the BUILD 2017 conference. It was covered by all of the tech press and non-tech press.  One would think they would want maximum coverage. It is a cool feature.  But, no.  Microsoft saw fit to hold it back from many, including myself.  For reasons I don’t yet understand.  We were able to get the new bits, after emailing a request, signing a eula and waiting. A really nice, and patient, young lady helped through the ridiculous exercise. I finally got the features almost a week later. I was beginning to think it was bogus and only a few journalists had received it.  This is yet another example of Microsoft’s inability to capitalize on anything. While the features are pretty good, the experience is sub par because of what I had to go through.

So, that was the frustration part.

The more I use the new features, though, the second word comes into play.  Simply put, the new features are awesome with the best still to come. The slickness of the resulting video is striking and the ability for the application to pull out snippets of video is just cool. So, once I did get the new bits, the awesomness took over.

While the resulting goodness of the new Photos app is clear, and I appreciate the help the young lady provided while trying to get the new bits, it does not excuse the bait and switch that Microsoft subjected us to, nor does the lame excuse they gave.  Seriously? An ‘a/b’ test on a PHOTOS app? Really?



Embedded Tiny Basic Updates are Coming

I am in the process of updating Half-Byte Embedded Tiny Basic.  The new Volt function, the Year function and a few other enhancements are on the way.

As with HB Tiny Basic 3, the Volt function returns the system reference voltage:

200 V=VOLT(0)
210 PRINT "Voltage is ",V,".",V%1000

So, if your reference voltage is 4.930 volts, the VOLT function would return:


The code snippet above would return:

Voltage is 4.930

Year(0) simply returns the current year if you have an RTC attached.

Other enhancements will include:

  • Support for limited LED animation
  • MOTOR control
  • Ability to utilize a light sensor to dim the LED array based on lighting in 
    the area.
  • Keypad support

And, one idea I am toying with–and it would depend on the amount of free space left–is some limited support for an LCD screen. I have not yet decided if it would be of the 2×16 variety or something like a Nokia 5110.  Again, it depends on the amount storage that is left.

Tokenizing the language would save a ton of SRAM for your apps, so I am looking into doing this as well.  I have been looking at how others do it and I don’t think It would be very difficult to retro fit it into the language. Of course, I could just start over…

Updated Half-Byte Tiny Basic v3

101_3353.jpgI have posted a new version of Half-Byte Tiny Basic v3. You can grab the .ino file here. If you already downloaded v3, download the new .ino file and is should compile in Arduino 1.6.x. I made sure it compiled in 1.6.7 before uploading it.  It is the same as the previous version, except that it has one new function: VOLT(0).

VOLT returns the reference voltage as an integer in the thousands.  Divide by 1000 and get the remainder. You can do so like this:

100 CLS
110 V=VOLT(0)
120 A=V/1000:B=V%1000
Run the code. Say your board's voltage is 4.954 volts, the output would be:

Of course, you don’t need to divide it, you simply use the returned value to get a better reading on an analog pin. Use it to monitor a sensor, etc. TREAD works in a similar way as well.

The next version of the language will include more low level hardware interfacing to make controlling motors and other things much easier.

Please try this version and let me know, via the comments, if you had problems compiling and uploading to your board.  Feel free to comment on the language, what you like, don’t like, etc.  I do listen and have incorporated many suggestions and will credit what ever I use.


Half-Byte’s Embedded Tiny Basic is ready!

Half-Byte’s Embedded Tiny Basic is ready!

The Half-Byte Embedded Tiny Basic is a subset of Half-Byte Tiny Basic. It does not contain the video or PS/2 style keyboard support and, thus, all of the graphical functionality has been removed.  Serial communication is the only way to upload or write Basic programs in this version.  The purpose to provide a quick, easy way to create applications for your devices.

Half-Byte developed a programmable clock using two 8×8 LED Arrays, using the Maxim 7219 chip, an HC-06 Bluetooth module, DS1307 based RTC, DHT-11 temperature sensor and a Half-Byte Console board.  Embedded Tiny Basic runs the device and, via Bluetooth, it is easy to program the clock.  I use Tera Term to connect to the device and can either type in a program or copy and paste one for quick upload.

Embedded Tiny Basic is tailored for these devices, the DHT-11 and the 8×8 LED Arrays, but it would be easy enough to change for what ever sensors you wish.

The download package contains the libraries, documentation and sample code as well as the Embedded Basic sketch.  Arduino IDE 1.6.x and up should work. I have used 1.6.7 and 1.8.1 for Windows Store and it compiled fine.

Embedded Basic Specific Features

  • 8×8 LED ARRAY
    • SCROLL variable or function
    • SCROLL “quoted text”
    • SET column, row, on or off
    • DIRECTION direction (where direction is 1 for left, 2 for right, 3 for up, 4 for down)
    • BRIGHT x (where x is a value from 0 to 15) Controls the brightness of the LED Array
  • CLOCK (DS1307)
    • TIME (displays the time and date on the array)
    • SETTIME hours, minutes, seconds, day, month, year (sets the time and date…all parameters must be supplied.)
    • x=HOUR(0) (returns the current hour to the variable ‘x’, can be any variable)
    • x=MINUTE(0) (returns the current minute to ‘x’)
    • x=DAY(0) (returns the current day to ‘x’)
    • x=MONTH(0) (returns the current month to ‘x’)
    • TEMP (sends the temperature to the array)
    • HUMID (sends the humidity to the array)
    • x=TEMP(0) (returns the current temperature to ‘x’)
    • x=HUMID(0) (returns the current humidity to ‘x’)
    • TONE pin, pitch, duration (sends a tone, specified by pitch, to pin for the duration)
  • TIPS
    • Use IF IN(0)<>-1 GOTO xxxx as an interrupt.  This tests the Serial in pin for something other than a -1.  -1 means there is nothing coming in on the serial pin. A non -1 value means the user likely hit a key on the keyboard of the Serial device. Useful for Bluetooth connections over serial, like the HC-06.
    • SAVE your program and it will autorun when the device is restarted. You will have three seconds to interrupt the autorun sequence (pressing a key will do.)
    • Combine statements where possible to save space.
    • Use ? instead of PRINT
    • Every effort has been made to fully debug Embedded Tiny Basic, but there may be some things that have been missed. Please feel free to let us know on the blog via comments of the Facebook page.

Please feel free to share any programs you have written in Embedded Tiny Basic as well as suggestions, tips, tricks, complaints, etc. As stated above, you can do so here on the blog via comments or on the Facebook page (


100 SCROLL"   Half-Byte Clock. "
110 TIME
120 SCROLL " Indoor temp is "
125 IF IN(0)<>-1 GOTO 500
130 TEMP
140 SCROLL " Humidity is "
160 SCROLL "% "
170 H=HOUR(0):M=MINUTE(0)
180 IF H=11 IF M>30 IF M<40 TONE 8,1024,2048
200 IF IN(0)<>-1 GOTO 500
300 GOTO 100
500 SCROLL "Done"

Note: line 180 acts as an alarm. If the time is 11:30am, a sound will play for
about two seconds. Lines 125 and 200 checks for a signal on the Serial in pin. 
If it is there, control transfers to line 500 and stops.

Download here.


Accurately reading analog pins, making Half-Byte Tiny Basic do the same and a fix for LiquidCrystal_I2C

temperaturesensor-128-300-225-80While experimenting with a new to me temperature sensor, I was a bit puzzled as to how to read the sensor. It has three pins, voltage, ground and signal. Well, it is obvious on how to connect the pins, power and ground and, since it was temperature sensor spitting out an analog signal, I figured one of the analog pins would suffice. I was correct about that, but, then, I did not know how to interpret the results. There is actually very little on the ‘net about this thing. It is a TMP-01 from OSEPP. Even the OSEPP web page has little on the device. I actually found out how to interpret the device on the SparkFun Galileo page (…/sik-galileo—part-7-reading-a…)

One thing about Arduino chips (like the 328) have a built in voltage measuring mechanism. Yes, that’s right, it has a built in voltage meter of sorts.

On that page, there is this code:

Example sketch 07


Use the “serial monitor” window to read a temperature sensor.

The TMP36 is an easy-to-use temperature sensor that outputs
a voltage that’s proportional to the ambient temperature.
You can use it for all kinds of automation tasks where you’d
like to know or control the temperature of something.

More information on the sensor is available in the datasheet:…/TMP35_36_37.pdf

Even more exciting, we’ll start using the Arduino’s serial port
to send data back to your main computer! Up until now, we’ve
been limited to using simple LEDs for output. We’ll see that
the Arduino can also easily output all kinds of text and data.

Hardware connections:

Be careful when installing the temperature sensor, as it is
almost identical to the transistors! The one you want has
a triangle logo and “TMP” in very tiny letters. The
ones you DON’T want will have “222” on them.

When looking at the flat side of the temperature sensor
with the pins down, from left to right the pins are:
5V, SIGNAL, and GND.

Connect the 5V pin to 5 Volts (5V).
Connect the SIGNAL pin to ANALOG pin 0.
Connect the GND pin to ground (GND).


This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit for SIK information.
Visit to learn about the Arduino.

Version 2.0 6/2012 MDG

// We’ll use analog input 0 to measure the temperature sensor’s
// signal pin.

const int temperaturePin = 0;

void setup()
// In this sketch, we’ll use the Arduino’s serial port
// to send text back to the main computer. For both sides to
// communicate properly, they need to be set to the same speed.
// We use the Serial.begin() function to initialize the port
// and set the communications speed.

// The speed is measured in bits per second, also known as
// “baud rate”. 9600 is a very commonly used baud rate,
// and will transfer about 10 characters per second.


void loop()
// Up to now we’ve only used integer (“int”) values in our
// sketches. Integers are always whole numbers (0, 1, 23, etc.).
// In this sketch, we’ll use floating-point values (“float”).
// Floats can be fractional numbers such as 1.42, 2523.43121, etc.

// We’ll declare three floating-point variables
// (We can declare multiple variables of the same type on one line:)

float voltage, degreesC, degreesF;

// First we’ll measure the voltage at the analog pin. Normally
// we’d use analogRead(), which returns a number from 0 to 1023.
// Here we’ve written a function (further down) called
// getVoltage() that returns the true voltage (0 to 5 Volts)
// present on an analog input pin.

voltage = getVoltage(temperaturePin);

// Now we’ll convert the voltage to degrees Celsius.
// This formula comes from the temperature sensor datasheet:

degreesC = (voltage – 0.5) * 100.0;

// While we’re at it, let’s convert degrees Celsius to Fahrenheit.
// This is the classic C to F conversion formula:

degreesF = degreesC * (9.0/5.0) + 32.0;

// Now we’ll use the serial port to print these values
// to the serial monitor!

// To open the serial monitor window, upload your code,
// then click the “magnifying glass” button at the right edge
// of the Arduino IDE toolbar. The serial monitor window
// will open.

// (NOTE: remember we said that the communication speed
// must be the same on both sides. Ensure that the baud rate
// control at the bottom of the window is set to 9600. If it
// isn’t, change it to 9600.)

// Also note that every time you upload a new sketch to the
// Arduino, the serial monitor window will close. It does this
// because the serial port is also used to upload code!
// When the upload is complete, you can re-open the serial
// monitor window.

// To send data from the Arduino to the serial monitor window,
// we use the Serial.print() function. You can print variables
// or text (within quotes).

Serial.print(“voltage: “);
Serial.print(” deg C: “);
Serial.print(” deg F: “);

// These statements will print lines of data like this:
// “voltage: 0.73 deg C: 22.75 deg F: 72.96”

// Note that all of the above statements are “print”, except
// for the last one, which is “println”. “Print” will output
// text to the SAME LINE, similar to building a sentence
// out of words. “Println” will insert a “carriage return”
// character at the end of whatever it prints, moving down
// to the NEXT line.

delay(1000); // repeat once per second (change as you wish!)

float getVoltage(int pin)
// This function has one input parameter, the analog pin number
// to read. You might notice that this function does not have
// “void” in front of it; this is because it returns a floating-
// point value, which is the true voltage on that pin (0 to 5V).

// You can write your own functions that take in parameters
// and return values. Here’s how:

// To take in parameters, put their type and name in the
// parenthesis after the function name (see above). You can
// have multiple parameters, separated with commas.

// To return a value, put the type BEFORE the function name
// (see “float”, above), and use a return() statement in your code
// to actually return the value (see below).

// If you don’t need to get any parameters, you can just put
// “()” after the function name.

// If you don’t need to return a value, just write “void” before
// the function name.

// Here’s the return statement for this function. We’re doing
// all the math we need to do within this statement:

return (analogRead(pin) * 0.004882814);

// This equation converts the 0 to 1023 value that analogRead()
// returns, into a 0.0 to 5.0 value that is the true voltage
// being read at that pin.


There is more to it. In order to get a more accurate voltage, you have come up with the reference voltage and use it instead of the .004882814 used above.

 This site:…/making-accurate…/
 has a really nice explanation and some code to get the reference voltage:
 long readVcc() {
 long result;
 // Read 1.1V reference against AVcc
 ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
 delay(2); // Wait for Vref to settle
 ADCSRA |= _BV(ADSC); // Convert
 while (bit_is_set(ADCSRA,ADSC));
 result = ADCL;
 result |= ADCH<<8;
 result = 1125300L / result; // Back-calculate AVcc in mV
 return result;
And call it like this:
 unsigned int ADCValue;
 double Voltage;
 double Vcc;

 Vcc = readVcc()/1000.0;
 ADCValue = analogRead(0);
 Voltage = (ADCValue / 1024.0) * Vcc;

Call that function to get your reference and use that where ever you need, such as the temperature sensor.

Making Half-Byte Tiny Basic Accurately Those Analog Pins too!

I am adding a function to Half-Byte Tiny Basic to return this value.
It goes like this:
250 a=VOLT(0)
260 print a,”,”,a/1000
Line 250 gets the reference voltage
Line 260 displays the voltage and the voltage divided by 1000. The returned voltage is in the thousands, so you must divide by 1000 to get the actual value.

Using AREAD in conjunction with VOLT should give you the ability to read, accurately, the analog pins that have some kind of sensor attached to them that does not need a library to read them, like the TEMP-01.

Fix for LiquidCrystal_I2C not displaying the whole string

This also brings me to another issue…the LiquidCrystal_I2C library.  The newer versions of the GCC compiler that is used in the latest versions of the Arduino compiler have a problem: they only display one character instead of the entire string.  I spent a lot of time trying to figure out what I was doing wrong, but, it turns out, there is a bug in the library.  I found another that corrects the bug and you can download it from here.

Falling like a rock: Pebble is no more

wp_20150708_22_15_12_proA few short years ago, a product came on the market that I got excited about. The product utilized ePaper, could go a week between charges and was programmable. Better yet, it was ‘crowd funded.’  The product took off, initially, and raised a lot of money from Kickstarter.  That product, the Pebble Smartwatch, was a successful kickstarter project, probably the most successful of any from that site.

Last year, I finally got one.  I like it a lot.  The problem, though, was my smartphone. I use a Windows Mobile 10 device and there is no official app from Pebble. Eventually, someone developed a nice Pebble watch app for my favorite smartphone operating system.  For the last few months, I’ve been very happy with this setup: I see my notifications, calls, email, etc. on my watch, I don’t need to pull the phone out.  Great.

The app even works with some of the back end plumbing from Pebble.  Nice. I get weather and some other things. Very cool.

Last week (December of 2016) I see a rumor that Fitbit was purchasing Pebble.  I think, GREAT! My favorite smartwatch will get a much needed boost from an established company, that is also Windows Mobile friendly. Awesome. I may even get the new Pebble 2!  How sweet is that?

Turns out, it is bitter.

Fitbit did, in fact, buy Pebble. BUT…they only bought the services and software, NOT the hardware. So, Pebble is now history.  There is no word on when the services will cease. The watch will still work with phones, but the stuff that made it special, the heart of Pebble, will be pebble-geek-watchfaces_2-300x300going away.

No more new watches.  Fitbit did not want the hardware. Nor did they want about sixty percent of the employees either.

I now have one more piece of hardware that is orphaned.  Man, my ability to choose platforms is horrible.

Zune, Windows Phone/Mobile, Palm OS, webOS for Palm, Vista, Windows 8, CED Video Disc, LaserDisk, HD-DVD, Pontiac…and, now…Pebble.  Wow.  What a record, huh?

So, RIP, Pebble. It was nice while it lasted.

Download Half-Byte Tiny Basic 3

When I published the Tiny Basic 3 announcement, I included a link to download the installation package.  Well, that link was to the programming in Tiny Basic book.  Here is the correct link to download the source to upload to your Arduino or compatible:!AnSbTyHNR1Q_vvlyQ9Om0fdanKbUHg

The link has been updated in the article as well.