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?

 

 

Verizon takes an OATH: the death of AOL and YAHOO!

Two of the Internet’s oldest and most well known names, Yahoo! and AOL, will soon cease to exist.  With their purchases by Verizon, both companies will be merged into something called OATH.  While it remains to be seen just how well the combined company will do, one is for certain, neither company is anything like the companies we knew and loved or loathed, back in their heyday.

Indeed.

Yahoo! was THE search site. Period.  It was the Google of the late nineties and very early double-aughts. If you needed to find something, you went to Yahoo!.  I used Excite, a lot, but, like today and Bing, I found myself always using Yahoo!  Then, at some point, it became Yahoo! Powered by Google.  What? What’s this ‘google’?  I know it is a very big number that Carl Sagan used to talk about…but, what’s this ‘powered by google’?  So, I used Yahoo! to search for google.  The aforementioned number was the top choice, then…Google.com. I click the link and…viola! This empty page, except for the search bar and ‘google’ popped up.  Well, it looks like Yahoo! has company.  I eventually gravitated to Google for my searches.  Excite went belly up, as did most of the other search engines.  But, Yahoo! and Google were there.  Oh, this ‘MSN Search’ thing too…it eventually became useful and its name changed to Bing!, but that was years later.

Yahoo! lingered on…buying up hot properties in a desperate attempt to remain relevant, but…to no avail.  It became relegated to a collection of has-been properties, a few of which are still regarded in some fashion.

Only a few short years ago, Yahoo! was worth tens of billions of dollars.  Microsoft offered something like thirty billion to buy them, but then-CEO Jerry Yang figured that he could get ‘a better deal’ and held out.  He didn’t. He lost his title.  Marissa Mayer was brought in to right the ship…she couldn’t either.  Verizon got it for a tenth of what Microsoft had offered, not even a decade ago. I won’t even talk about the lack of security. Yikes.

America Online.

What can I say? I loved AOL.  I joined in 1992.  It was my favorite past time, well, other than a certain type of human interaction, that is.

Wow, just think, I could click a button, this loud, screaching sound came out of somewhere and, in a minute, I was ONLINE!  I had all kinds of things to do…look stuff up, download pictures, software, source code, short video clips…man, that was cool.  Sure, it took a LONG time to download files that, today, are smaller than most images on a web page, but, this was the early 1990’s and the Internet was new and not widely available. Bulletin boards were the hot things and these ‘chat rooms’ on AOL…yeah, those were cool. Perhaps the ability to share my knowledge with anyone was my favorite thing to do ‘online’.  I had written several demos and applications in this Visual Basic for DOS thing that was, for a few days, HOT.  Yep, HOT.  At least in the VB ‘room’ on AOL.  My demos and app were downloaded were downloaded…what, a dozen times.  Wow.  There was one demo, a phone dialer, that was downloaded about fifty times…I thought I was IT. Yep, fifty times. How freaking cool?

Well, as time went on, this Internet thing got big. REALLY BIG. And so did AOL.  AOL WAS THE INTERNET. For many, many people.  Think about that.

By 1998 or 1999, AOL was bigger than most tech companies. So big, in fact, that it bought Time-Warner Communications in 2000.  What a colossal mistake.  What AOL never counted on was the quick adoption of  high speed internet.  And the internal resistance within the Time Warner part of the company was overwhelming.  “these snot nosed punks aren’t coming in here to tell me what to do.”

By 2005, AOL was dead.  At least, to most they were. The company was still doing OK. It eventually spun off from Time Warner.  It became a collection of popular blogs and, believe it or not, they still had a sizable dial up customer base.  However, it wasn’t enough.

Verizon bought them.

And, now, they will be called Oath.

Admittedly, there’s a certain nostalgia surrounding both companies. That sound from-whatever-when you logged into AOL.  The anticipatory ‘You’ve got mail’. The excitement when the AOL home screen popped up (and, boy, that original DOS AOL client was both beautiful and cool) and, later on, the AOL Browser.  Yahoo! on AOL.

You know, now that I think of it, I kind of miss that sound from whatever and that anticipatory ‘You’ve got mail.’  Only kind of, though.

 

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:

4930

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…

Assembling the NKC 65k Color LCD Shield

Assembling the NKC 65k Color LCD Shield

The NKC 65k Color LCD Shield isn’t difficult to assemble, it is, however a bit time consuming.  The most difficult part of the assembly is soldering the connector board to the LCD itself. You must carefully line it up on both the LCD AND the shield board itself.  More on that in a moment.

To begin, first make sure you have all of the parts. Compare the packing list with what you have. Once you are sure you have every thing, you need to start with the LCD.  Take the very small connector board and, carefully, solder one of the strips to the LCD. You will know where, it’s kind of obvious, but, in case you can’t, on the shield board, look for the outline

lcdconnectorboard.jpg

LCD Connector Board

of the LCD.  On the component side, you will see several solid tracks that appear to go nowhere. This is what you will have to line up.  Once you place the LCD on the Shield board and line them up…the LCD has a tit that goes through the board on one side, line it up using that. Once satisfied, remove the LCD and continue to solder the connector board to the LCD. When you are done, place the LCD back on the shield, make sure the board lines up and then solder it to the shield board.  Congratulations, this was the toughest part of the assembly.

 

The official instrucWP_20170201_21_48_05_Pro.jpgtions say to solder the header now.  I would advise to wait. The problem is that the resistors are difficult to solder if you insert and solder the headers first. So, I would solder those outer resistors next.  Those are the 1K and 10K resistors. While you are at it, solder all of the small, .1uf capacitors (the little bright blue capacitors) into place. A few of these are also next to the headers and in difficult spots if the headers go first.

Solder the remaining resistors into place.  The board is clearly marked, so it should be very easy to figure out where to solder them.

The two large 10uf capacitors are polarized, meaning they must be soldered in a specific way. Notice they both have a gray arrow on them, that is the negative side and must be soldered in with the arrow pointing to the negative sign or round hole on the board.C1 would have the gray arrow facing the LCD and C7 has it facing the Max232 Integrated Circuit.

For the large LM317, place in the three holes, flat side facing toward the Max232.  Solder the center pin.  Carefully, bend the LM317 backward so it is as flush to the board as you can get and solder the remaining pins.

If you have a 16 pin, through hole IC socket (one does not come with the kit) I would suggest you use it in the assembly. It is ok if you do not, it makes it easier if, for some reason, you should ever have to swap the chip out.  If you have the socket, go ahead and solder it to the board, paying attention to pin one.  If you do not have the socket, insert the chip with pin one facing the edge of the board. Pin one is where the ‘u’ shape is on the outline of the chip on the board. Once you are satisfied that you have pin one in the proper place, solder the chip to the board.

The only things left should be the headers. An easy way to solder them in is to place them in your Arduino UNO and then carefully place the board over them, making sure the pins penetrate the board. Solder them.

WP_20170201_22_30_35_Pro.jpg

The Completed Board

 

 

Wow, you’ve assembled your board.  Now you need to test it.  There is a demo sketch (two of them) on the NKC Electronics web site.  Download them and then up load to your Arduino. If all went well, you see a short demo on the screen.

This is a busy but useful board and a ‘fun’ project. It shouldn’t take more than a couple of hours to assemble and test.  There are better panels out there, but this kit is currently $4.95 and could be useful in a monitoring project, a game or for an at a glance status for one of your project.

Have fun!

Official assembly guideWP_20170201_22_36_47_Pro.jpg

Demo 1 - direct I/O

Demo 2 - using digital read/write

Demo 1 is much faster and is what I would use 
for things that need speed.

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
130 PRINT "THE REFERENCE VOLTAGE IS:",A,".",B
Run the code. Say your board's voltage is 4.954 volts, the output would be:
THE REFERENCE VOLTAGE IS:4.954

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’)
  • TEMPERATURE SENSOR
    • 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’)
  • MISCELLANEOUS
    • 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 (https://www.facebook.com/eightbitsblog/)

SAMPLE CODE:

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 "
150 HUMID
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 (https://learn.sparkfun.com/…/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

TEMPERATURE SENSOR

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:
http://cdn.sparkfun.com/datasheets/Sensors/…/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 http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc 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.

Serial.begin(9600);
}

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(voltage);
Serial.print(” deg C: “);
Serial.print(degreesC);
Serial.print(” deg F: “);
Serial.println(degreesF);

// 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.
}

BUT

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: https://hackingmajenkoblog.wordpress.com/…/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.