Skip navigation
1 2 3 Previous Next

Embedded

187 posts

Screenshot 2017-02-03 at 3.30.18 PM.png

Psychometric profiling mines big data from social media platforms to create advertising tailored to the personality traits of select people. A screenshot of Cambridge Analytica’s Data Dashboard tool, which provides demographic data based on the OCEAN personality model to political campaign workers (via cambridgeanalytica.com)

 

This sort of data analysis always freaks me out.

 

You’ve probably noticed that the ads which pop up on your browser and Facebook feed are highly relevant to you and often feature products you’ve purchased in the past. You may already know that this is because of your digital footprint-the trace you leave when you visit a web page or use your credit card to buy something. How does the internet know this about you? The answer lies in big data and the world of statistical programming. Statistical programming is a way to mine extremely large amounts of data for predictive modelling. Computer programs use complicated mathematics to analyze volumes of data too big for the human mind.

 

Predicting climate and weather patterns is one form of statistical modelling. An enormous amount of data on temperature, humidity, and wind, among other variables, are analyzed by computer programs which then generate predictions of future climate patterns. Another, based on marketing, has recently been developed using data from Facebook.

 

Begun in 2008 by then-doctoral student Michal Kosinski while at Cambridge University, the project aimed to measure anyone’s personality according to five traits psychologists term OCEAN-openness, conscientiousness, extraversion, and neuroticism. How much you enjoy new things, how much you care about taking care of someone else’s needs, how much you like to spend time with others, and what kind of anxious tendencies you have. These traits are remarkably accurate in how they can predict behavior. What Kosinski did was figure out a way to assess someone’s OCEAN profile based entirely on their Facebook activity. He started by sending out questionnaires to friends.

 

The results were then compared with their Facebook activity-what they liked, posted and shared. As Facebook grew, so did the pool of questionnaires and profiles. Very strong correlations between respondents’ questionnaires and their Facebook activity emerged. Gay men are more likely to ‘like’ the cosmetic line MAC. Straight men are more likely to ‘like’ Wu-Tang Clan. By 2012, Kosinski’s team was able to predict age, skin color, religious and political affiliation, and many other traits, from 68 likes on Facebook.

 

Well, so what? It turns out that you can do a lot with this information, as Kosinski’s team discovered when they were approached by private firm Cambridge Analytica with an offer to purchase usage rights of the research. Cambridge Analytica designed models for engaging with different OCEAN types and developed marketing to appeal to someone based on those traits.

 

Guess who hired Cambridge Analytica for targeted marketing? Both the Brexit and Trump campaigns. While Kosinski claims that it’s impossible to know how much his research affected election outcomes, one thing is certain: there’s going to be a lot more targeted marketing in the coming years.

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

emblem.jpg

Tokyo’s 2020 Olympics committee wants the public to donate old gadgets to extract metals for them and create medals for the 2020 games. The medals for the upcoming Olympic Games will be made out of old gadgets. (Photo via Tokyo 2020 Olympics)

 

Tokyo’s 2020 Olympics they have something special up their sleeve: making medals out of old gadgets. To involve the community and promote recycling, the committee is asking the public to turn in unused or forgotten gadgets, like old smartphones. These items and other household appliances have small traces of the materials generally needed to make the medals. Rather than relying on mining companies, Tokyo wants to give people’s unwanted gadgets a new purpose. Saying that your old toaster went to making a gold medal is a pretty high honor.

 

The planning committee teamed up with partner companies NTT DOCOMO and Japan Environmental Sanitation Center (JESC) for the program. Starting in April public offices and over 2,400 NTT DOCOMO stores will have collection boxes where people can drop off their unwanted items. The goal is to collect eight tons of metal, which will equal to two tons after the production process, the total amount needed to make 5,000 medals for the Olympic and Paralympic games. Once they have the eight tons, the collection will come to an end.

 

This effort not only lets the community get involved but also directly responds to Recommendation 4 of the Olympic Agenda 2020, which aims to make sustainability integrated into planning and execution of the games. Many Olympic athletes spoke positively about the collection, saying it makes the medals that much more special. Gymnast Kohei Uchimura believes it wasteful to “discard devices every time there is a technological advance” and thinks this is a great way to reduce that waste. Decathlete Aston Eaton believes the medals from the collected items will represent the “weight of a nation.”

 

Making medals out of discarded objects is a novel way to recycle them. Many often don’t know what to do with their old phones and computers and settle for stuffing them in a junk drawer or leaving them in the dump. Perhaps this new effort will inspire further projects that tackle recycle in a similar way.

 

The Olympic 2020 planning committee isn’t the first to extract metals from these devices. Last year, tech giant Apple revealed they managed to collect 2,204 pounds of gold from broken iPhones in 2015. Apple promotes various recycling program, including the popular Apple Renew, which lets you recycle any Apple device at their stores. The company collected over 90 million pounds of e-waste, 61 million of which were reusable materials. The company then uses many of these extracted materials for their own products.

 

Wish they would release a potential prototype picture.

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

stanfordDiamondoid-penny-fullres.jpeg

Standford and DOE researchers have created super-thin wires just three atoms wide using diamonds and assembling them Lego-style. (via Standford)

 

Researchers from Stanford University and the Department of Energy (DOE) have developed a way to use diamonds- tiny bits of diamonds, to create a wire that is only three atoms wide. The wires have the potential to be used in all sorts of applications, including electricity-generating fabrics, optoelectronic devices and crazy superconducting materials that won’t bleed electricity.

 

What’s more, the building process of the wires requires a new Lego-like assembling technique and begins with attaching a single sulfur atom to a small diamondoid (nano-diamond or carbon cage molecule), which is then dropped into a solution where the sulfur atom bonds with a copper ion. The bonding doesn’t stop there, as diamondoids (in this case adamantane) are extremely attracted to each other through what is known as van der Waals forces- the same force that allows geckos to stick to walls.

 

In the diamondoid’s case, the force makes them clump together similar to sugar crystals and as you might have guessed, self-assemble to create a wire structure, complete with a copper-ion core. Stanford grad student Fei Hua Li (the mind behind figuring out the diamondoid’s attractive properties) explains it this way- “Much like LEGO blocks, they only fit together in certain ways that are determined by their size and shape.” He went on to say, “The copper and sulfur atoms of each building block wound up in the middle, forming the conductive core of the wire, and the bulkier diamondoids wound up on the outside, forming the insulating shell.”

 

stanforddiamondoid_assemly_still_v01.jpg

The basic building block of the nano-wire shows the copper/sulfur center being self-assembled by the attracting diamondoid outer shell.

 

Beyond using copper-ion based wires, the researchers also created them using other metals such as cadmium, zinc, iron and silver- all created using different solutions and with different cage molecules. What’s interesting is that each different build had similar material properties to some of those used in today’s technological applications.

 

For instance, the cadmium-based nano-wires had similar material properties to those used in optoelectronics such as LEDs, while the zinc-based wires are similar to those found in some solar panels and piezoelectric generators. The possibilities of using these wires for creating a host of new materials with electrical properties are almost endless, their development is still in its infancy but considering that they have virtually no electrical bleed, it will be exciting to see what they can be adapted for beyond just efficient electronics.

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

 

LED.jpg

The lighting industry has been changed forever by LEDs, and now they could become even cheaper and more efficient with the incorporation of perovskites. New LED is made with crystalline substances known as perovskites. (Photo via Sameer A. Khan/Fotobuddy)

 

The advent of light emitting diodes (LEDs) have revolutionized lighting because of their efficiency, durability, and longevity, and now Princeton engineering researchers have further improved the revolutionary light source through the use of perovskites. These are crystalline substances that belong to a class of compounds that have the same structure as perovskite (CaTiO3 ), a calcium titanium oxide mineral.

 

According to perovskite-info.com (an aptly named website): “... perovskites can have an impressive array of interesting properties including “colossal magnetoresistance” - their electrical resistance changes when they are put in a magnetic field (which can be useful for microelectronics)”, and they have several practical applications in, “...sensors and catalyst electrodes, certain types of fuel cells, solar cells, lasers, memory devices and spintronics applications.” Now perovskites are entering LED technology and they present, “... a potential lower-cost alternative to gallium nitride (GaN) and other materials used in LED manufacturing,” according to Barry Rand, an assistant professor of electrical engineering and the Andlinger Center for Energy at Princeton. This potential reduction in price makes LEDs more and more attractive given that they are more durable, efficient and long-lasting, but also more expensive than incandescent and fluorescent bulbs.

 

In the abstract of Rand’s initial report, it was noted that perovskites have promising potential for LEDs because of their, “high colour purity, low non-radiative recombination rates and tunable bandgap.” Rand and the other researchers found that the perovskite LEDs were found to be highly efficient, and enabled by the formation of “self-assembled, nanometre-sized crystallites.” It was found that when a long-chain organic ammonium halide was added to the perovskite solution, it resulted in smaller crystallites on the halide perovskite film, and according to Phys.org, this improves the “external quantum efficiency, meaning the LEDs emitted more photons per number of electrons entering the device”, and the films were also more stable than those produced through other means.

 

Professor of materials science and engineering at the University of Minnesota, Russell Holmes, believes that the Princeton research brings perovskite-based LEDs closer to commercialization. These developments would make LEDs an even tougher competitor in the lighting industry, and the wide application perovskites have demonstrated in increasingly important technologies like solar cells is also a nice caveat.

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

Hello friends, we have designed many Proteus Libraries on our blog The Engineering Projects which are not yet developed and we are really very proud that we are the first designers for these Proteus Libraries. I am gonna share all those Proteus Libraries in this instructable so that Engineering Students can download them and use them in their Projects.

I have also designed their videos in which I have explained in detail How to use these Proteus Libraries. So, you can join our You Tube Channel to have a look at these Proteus Libraries. Here are the links:

So, let's get started with these New Proteus Libraries for Engineering Students:

 

Step 1: Links to Download New Proteus Libraries

Here are the links to our New Proteus Libraries:

fractal-1280081_960_720.jpg

Microsoft’s Todd Holmdahl is heading up the effort to engineer scalable quantum hardware and software.

 

Microsoft has been on a quest to build the holy grail of computers for over a decade, dumping tons of money into researching quantum computing and the company says they are ready to transition over to the engineering phase of their endeavor. At least that’s what MS executive Todd Holmdahl aims to accomplish by developing the hardware and software to do so.

 

Like most cutting-edge tech development, nothing is set in stone and more often than not failure is a big part of the effort, something Todd is well aware of considering he was the person who spearheaded the Xbox, Kinect and HoloLens. As head of the team to bring about a scalable form of quantum computer, Todd is partnering with some of more renowned researchers in the quantum field including Leo Kouwenhoven (Delft University of Technology professor) and Charles Marcus (Niels Bohr Institute professor), both of which received funding from Microsoft to research theoretical topological qubit computing.

 

F1.large.jpg

It’s all in the anyon braids, which form the logic gates that theoretically make quantum computing possible. (via MS)

 

To bring their quantum computer into reality, Todd and his team are turning to quasiparticles known as anyons, which will form the logic gates needed to perform computations. The problem with quasiparticles is that they are extremely unstable and tend to disintegrate in a matter of milliseconds shortly after being formed. Anyons by themselves exist in two dimensions and exhibit both an on and off state at the same time, however to make them stable and suitable for use in computing a third dimension is needed.

 

Hence the braiding, which is done by rotating the worldliness of a pair of anyons, which can’t be merged and therefore form a stable state and act as a logic gate. The team has already started to braid these anyons in the hopes of creating those logic gates that form the basis for quantum computing. Since the particles can exist in two states they can theoretically double the amount of computing power exponentially- so if one is capable of doing two calculations and two can perform four (and so on), imagine what a billion (or the equivalent amount of transistors found in today’s CPUs) can do!

 

On the software side, the team is working on trying to frame the software necessary to accompany topological quantum computing. So far, they have developed a series of tools to help them simulate a quantum computer in order to get a better understanding. The language they used to build the tools is called LIQUi|> (Language-Integrated Quantum Operations) with the characters at the end denoting how operations are written in math terms. The team hopes that using LIQUi|> will help pave the road to build the algorithms that can take advantage of quantum computers.

 

While they are making strides in their lofty endeavor, it will still be a ways off before quantum computing will come to fruition. My guess is that it will be another 10 to 20 years before they can produce a physical working model and probably several more before they can be manufactured on a larger scale. Still, it is exciting to see that we’re on the cusp of harnessing a computational power that used to be thought of a science fiction.

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

Cabe Atwell

Even More Moto Mods!

Posted by Cabe Atwell Dec 26, 2016

motomods2.PNG

Motorola is increasing its edge with modular phones by adding new snap-on Mods to its Z model, enhancing capabilities to include a range of features. An array of modular magnetic snap-ons to Motorola’s Z phone, which enhances the device’s capabilities to include a projector, camera lens, and high-powered charger (via Motorola.com)

 

In an age where cell phones are falling in both price and reusability, the modular approach to capabilities taken by Motorola is refreshing. The idea is simple-modular phones allow for enhanced capabilities by adding more modules-in this case, Mods- that snap on to the back of a smartphone magnetically.

 

The modular component adds an additional feature while attached to the original device. So far, Motorola’s Z phone is leading the way with these features. Motorola claims that the Mods were designed with future generations of Moto Z’s in mind, so that if you buy a boombox feature or a lens feature for today’s current Moto Z, it will still work on the next model.

 

Additionally, to create each modular add-on, Motorola partnered with different industry leaders in design and engineering. The speaker Mod was created through a partnership with American electronics company JBL, and the camera Mod with optics company Hasselblad.

 

These are not merely gimmicks, but highly functional, high quality devices in their own right. As such, there are a few cons. Each Mod comes with its own battery, which charges independently of the smartphone. That means if you attach a Mod to a not-yet-fully charged Moto Z, and start charging, the juice first goes to the phone, then the Mod. It is possible to charge them separately, of course, but be aware that the Moto Mod system relies on battery power-and lots of it. That could be a reason why the latest Mod, a Mophie battery pack, came out recently. Providing 3,000mAh of power time, it clamps onto the phone as any other Mod, lengthening the time between charging. This feature is only another $80, and a carport feature, produced in partnership with Incipio, is only $65.

 

Motorola plans to produce even more Mods in 2017 than 2016, according to Moto Mods director John Touvannas. That has to make you wonder, what next? Are they going to invent needs we didn’t know we had, or come up with features that are actually useful? Possibly both. A call for solicitations from users resulted in some 380 pitches for new Mods, ranging from baby monitors to breathalyzers. If the Moto Mod team is able to take a new look at preexisting features, they could create enhanced features that offer something for everyone

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

qualcomm-w10.png

Qualcomm processors will now be able to run Windows 10 giving the ability to run high powered Win32 apps. Qualcomm making the big announcement at WinHEC (Via Qualcomm)

 

Qualcomm made headlines a few months ago for making the biggest semiconductor deal ever. Now, they have another big announcement in store. Qualcomm and Microsoft are teaming up to bring Windows 10 to Qualcomm’s mobile processors. Thanks to this, Qualcomm’s Snapdragon processors will be the first ARM-based processors to fully support Windows 10. The announcement was made at WinHEC where attendees got to see a demo of the full desktop version of Photoshop running on a Snapdragon CPU via emulation. So why is this such a big deal?

 

Qualcomm’s chips, such as the Snapdragon, are high powered and are supposed to offer the best experience when it comes to streaming, watching movies, and even making phone calls. Most of the company’s processors are found on mobile devices and though they are powerful, most chips found in smartphones still aren’t strong enough to run energy consuming apps, like Photoshop and other Win32 apps. Bringing Windows 10 to these processors changes that. Qualcomm’s next generation of processors have the ability to run Win32 apps via x86 emulation on Windows 10.  As they showed in the demo, these chips will now be able to handle such high powered apps, bringing a desktop experience to your mobile device and stronger processors to standard PCs.

 

Both Qualcomm and Microsoft believe Windows 10 PCs powered by Snapdragon will be available as early as next year. Not only will the new devices fully support Windows 10, but they’ll also include Gigabit LTE, and superior Wi-Fi housed in a fanless design that’s meant to provide a long battery life. This is also big news for Microsoft because it may allow them to build a smartphone with the ability to run Win32 apps along with other UWP apps. Microsoft tried breaking into the smartphone game with its Windows phone, but it couldn’t compete with Samsung and Motorola. With Qualcomm on their side it could allow them to create something better and more powerful that the Surface Phone.

 

This isn’t the first time Windows attempted to run ARM devices. They previously gave it a shot with the OS Windows RT, but the results were not so successful. The biggest issue was ARM-based Windows programs were not synonymous with the standard 32 bit programs. Because of this, developers were forced to rewrite their programs to be compatible with Windows RT. Though some are still suspicious that the processor will run the apps via emulation, it’ll still be interesting to see if this will give Microsoft the break they need to finally create a successful smartphone. It could also give Qualcomm the support it needs to give Intel a run for their money.

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

CLICK THIS INFORGRAPHIC IMAGE BELOW!

2 engineering the walking dead 1 perpetual motion generator.jpg

http://twitter.com/Cabe_Atwell

limesdr-2-1_jpg_open-graph.jpg

Lime Microsystem’s LimeSDR features Snappy Ubuntu Core, allowing anyone to write their own apps for any number of projects. (via Lime Microsystems)

 

Back in June of this year, Lime Microsystems successfully funded their LimeSDR platform on Crowd Supply, garnering over $777K with a $500K goal. The company touted the board as ‘a low-cost, open-source, apps-enabled, software defined radio’ that can be used for everything radio- cellular base stations, media streaming, drone/RC control, IoT, you name it. What’s more, since the board is open-source in every way and outfitted with Snappy Ubuntu Core, users can write their own code or apps and share them with others in much the same fashion as the Raspberry Pi and Arduino communities.

 

 

Think of the LimeSDR as a development board for radio-based projects as it can handle a myriad of wireless communication standards including UMTS, LTE, GSM, LoRa, Bluetooth, Zigbee, RFID, as well as a wide frequency range of 100 KHz to 3.8 GHz. Lime’s choice of electronics makes it easy to use whatever standard you want as it features the company’s LMS7002M MIMO FPRF RF transceiver paired with an Intel/Altera Cyclone IV EP4CE40F23 FPGA, allowing it to carry out DSP (Digital Signal Processing) tasks on the hardware.

 

Rounding-out the LimeSDR is 256Mb of DDR2 of onboard RAM, a Cypress USB 3.0 controller, Rakon RPT7050A oscillator, 10 U.FL (6 RX/4 TX) connectors and a series of programmable LEDs. So what has been happening with Lime Microsystems since the successful crowd-funding campaign? According to a Crowd Source update, they are busy acquiring all the components needed to build the boards before they can ship them to those who pledged and are on course to deliver them all by the end of January of next year. Those waiting should check their email as the company will send a message the exact date their LimeSDR will arrive.

 

Lime Microsystems has also been recently lauded by Frost & Sullivan, who gave the RF company their Technology Innovation Award for their LimeSDR platform and “acknowledging the rising importance of programmable radio frequency (RF) in an increasingly software-driven world.” While there are many competing RF boards on the market, the main reason F&S bestowed their prestigious award to Lime was that none of the competition featured open-source hardware and software or was capable of a wide frequency range, noting that some of the other SDR boards even featured Lime’s RF transceiver chips.

 

While nobody has yet received their LimeSDRs, it will be interesting to see what the maker community does with them. Will there be a thriving code/app-based community shortly after launch or will it be sometime before there is significant shareware people can use for their projects?

 

Have a story tip? Message me at: cabe(at)element14(dot)com

  http://twitter.com/Cabe_Atwell

s34m8bUtGX5oxkFU8meBK8.jpg

A team from the University of Florida took inspiration from the popular franchise for a new type of wearable tech. The solar panels are integrated into the woven fabric (image via University of Florida)

 

Wearable technology is on the rise with the release of smartwatches and accessories like FitBit. But no one has quite gotten the integration of smart tech with clothing just right. There are still several kinks creators run into; bulky batteries, textiles that hold an electric charge, and comfort. One team from the University of Florida is trying their hand at wearable tech and it may be what we’ve been waiting for.

 

Rather than using chunky batteries, the team created solar power clothing with the ability to store the sun’s energy. They achieved this by making filaments that can be crafted into textiles, which then give them the ability to store and use the sun’s energy. The filaments are made out of flexible copper ribbons equipped with a solar cell on one side and an energy storing layer on the other side. It's a type of "supercapacitor" material. Which is genius, since the cap' can efficintly gather all energy generated from the solar cells quickly. With an entire shirt, let's say, all made of supercap material... the surface area of said capacitor would be enormous. The energy density they claim is 1.15mWh/cm^3 (and a power density of 243 mW/cm^3).

 

During the testing phases, the team sewed them into a square piece of yarn, which can then be sewn into jackets or other outwear to get energy to power devices, like phones. This new tech improves on the major limitations of solar cells. Traditional cells are limited in their portability since they have to store the energy they produce in battery or have it flow into a power grid.

 

solar clothes 3.PNG

 

Believe it or not, the inspiration behind the tech was actually taken from the popular Back to the Future franchise, specifically the self-lacing Nikes from the second film. Along with this, they also had the military in mind. Soldiers overseas are at a risk of extreme exhaustion and heat stroke from carrying over 30 pounds of batteries in the hot sun. This new wearable tech will relieve some of the weight by eliminating the batteries completely.

 

Aside from being used for the military, the team believes the technology can be used for other things, like electric cars. Because the solar cells can be integrated easily into fabrics, are portable, and don’t rely on chunky batteries, it could be the breakthrough wearable tech has been looking for. Imagine wearing a coat or hoodie with the ability to charge your phone. No more freaking out over low batteries or carrying around battery banks. It’ll be exciting to see what the team can do with the tech in future. For now, make sure to keep your phones properly charged.

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

Our Raspberry Pi friends will know the Building a Low Power Compact LCD Display project that shabaz published a while ago. He designed a £5 LCD module and the source code for Raspberry Pi.

Let's have a look at the I2C traffic.

 

 

What data is flowing according to the code?

Our code tries to send 9 bytes.

  • 1:           the 7-bit I2C address + read/write bit
  • 2 - 6:     config and commands
  • 7 - 9:     data for the segments and dots

 

#define LCD_ADDR 0x38
// ...

// Commands (these can be 'continued' by setting the MSB
#define DEVICE_ADDR 0x62
#define BLINK_OFF 0x70
#define BANK_CMD 0x78


// BANK_CMD bit values
#define WR_BANK_A 0x00
#define WR_BANK_B 0x02
#define DISP_BANK_A 0x00
#define DISP_BANK_B 0x01

// ...

 unsigned char mode, device, bank, blinkmode;


  mode=0xc9; // Set static mode, display enabled, continuation enabled
  device=DEVICE_ADDR | 0x80; // Select the device, continuation enabled
  bank=BANK_CMD | 0x80 | WR_BANK_A | DISP_BANK_A; 
  blinkmode=BLINK_OFF | 0x80;
  buf[0]=mode;
  buf[1]=device;
  buf[2]=blinkmode;
  buf[3]=bank;
  buf[4]=0x00; // pointer
  buf[5]=progval->byte0;
  buf[6]=progval->byte1;
  buf[7]=progval->byte2;

 

What's really flowing to the LCD Controller

These two captures are the result of sending ' . . ' and '  0.0' to the display:

blankdotblankdotblank.png

blanknodotzerodotzero.png

Everything looks as expected. On the odd lines from 3 to 17 we find exactly what's defined in the code.

Line 3 in the screen captures, with value 0xc9, is exactly what's assigned to buf[0]in the code.

  mode=0xc9; // Set static mode, display enabled, continuation enabled
  //...
  buf[0]=mode;

 

The only thing that may need some more clarification is the I2C address, on line 1.

We've set it to 0x38, but in the transfers there is 0x70.

That's part of the I2C protocol.

The address isn't 8 bit, but 7 bit.

That 7 bit value is appended with a read/write bit. 1 if we're reading, 0 if we're writing.

Because we're writing to the LCD, we append the address with a 0.

The value 0x38 left shifted and with the last bit set to 0 equals 0x70.

 

address.png

Our Raspberry Pi friends will know the Building a Low Power Compact LCD Display project that shabaz published a while ago. He designed a £5 LCD module and the source code for Raspberry Pi.

 

I have ported that code to the Texas Instruments Hercules family. The hardware is exactly the same as in the original article.

lcd-complete-cc-r.jpg

Take care to read shabaz' blog first. It's a good read and this blog builds upon the information.

 

Porting from Pi to Hercules

The Pi code is linux based. It uses the linux i2c file device to talk to the LCD driver.

Our Hercules isn't a linux controller. Our work will be to port from the file type i2c access to a hardware driver based API.

 

The API is documented in the HALCoGen configuration program.

That help set also has an example that we can use to understand how a typical i2c conversation looks like: example_i2cMaster_TX_RX.

The first part of that example is a Master Send scenario with a loop. Exactly the same as what shabaz uses in his Pi test.

That means we don't have to find out what API functions to call when. We can just replace the each linux-based set of calls in the Pi code with the ones from the example.

 

I have only ported lcd3-test.c.

Shabaz uses i2c abstraction utility functions in his design. HALCoGen already has an abstraction API, so I'm using that.

You will see that the changes are very few.

 

header declarations:

 

Pi

#include <stdio.h>
#include "i2cfunc.h"

Hercules

#include <stdio.h>
#include "i2c.h"

 

constants and variables:

 

Pi

// we will use I2C2 which is enumerated as 1 on the BBB
#define I2CBUS 1

// set to 1 to print out the intermediate calculations
#define DBG_PRINT 0
// set to 1 to use the example values in the datasheet
// rather than the values retrieved via i2c
#define ALG_TEST 0

#define LCD_ADDR 0x38
// Four possible values for DEVICE_ADDRESS
// R1   R2   R3   R4   DEVICE_ADDRESS
// Fit       FIT       0x60
//      Fit  Fit       0x61
// Fit            Fit  0x62
//      Fit       Fit  0x63

// Commands (these can be 'continued' by setting the MSB
#define DEVICE_ADDR 0x60
#define BLINK_OFF 0x70
#define BANK_CMD 0x78

// BANK_CMD bit values
#define WR_BANK_A 0x00
#define WR_BANK_B 0x02
#define DISP_BANK_A 0x00
#define DISP_BANK_B 0x01

typedef struct char_prog_s
{
  unsigned char byte0;
  unsigned char byte1;
  unsigned char byte2;
} char_prog_t;

typedef struct ascii_s
{
  char_prog_t char0;
  char_prog_t char1;
  char_prog_t char2;
} ascii_t;

const char bit_table[]=
{
  0x38, 0x00, 0x86,    0x00, 0xbe, 0x00,    0x86, 0x00, 0x38,    /* 0 */
  0x08, 0x00, 0x02,    0x00, 0x0a, 0x00,    0x02, 0x00, 0x08,    /* 1 */
  0x30, 0x00, 0x46,    0x00, 0x76, 0x00,    0x46, 0x00, 0x30,    /* 2 */
  0x18, 0x00, 0x46,    0x00, 0x5e, 0x00,    0x46, 0x00, 0x18,    /* 3 */
  0x08, 0x00, 0xc2,    0x00, 0xca, 0x00,    0xc2, 0x00, 0x08,    /* 4 */
  0x18, 0x00, 0xc4,    0x00, 0xdc, 0x00,    0xc4, 0x00, 0x18,    /* 5 */
  0x38, 0x00, 0xc4,    0x00, 0xfc, 0x00,    0xc4, 0x00, 0x38,    /* 6 */
  0x08, 0x00, 0x06,    0x00, 0x0e, 0x00,    0x06, 0x00, 0x08,    /* 7 */
  0x38, 0x00, 0xc6,    0x00, 0xfe, 0x00,    0xc6, 0x00, 0x38,    /* 8 */
  0x18, 0x00, 0xc6,    0x00, 0xde, 0x00,    0xc6, 0x00, 0x18     /* 9 */
};

unsigned char buf[10];
int handle;

 

Hercules

// set to 1 to use the example values in the datasheet
// rather than the values retrieved via i2c
#define ALG_TEST 0


#define LCD_ADDR 0x38
// Four possible values for DEVICE_ADDRESS
// R1   R2   R3   R4   DEVICE_ADDRESS
// Fit       FIT       0x60
//      Fit  Fit       0x61
// Fit            Fit  0x62
//      Fit       Fit  0x63

// Commands (these can be 'continued' by setting the MSB
// jc20161120 R1 and R4 mounted on my board
#define DEVICE_ADDR 0x62
#define BLINK_OFF 0x70
#define BANK_CMD 0x78

// BANK_CMD bit values
#define WR_BANK_A 0x00
#define WR_BANK_B 0x02
#define DISP_BANK_A 0x00
#define DISP_BANK_B 0x01

typedef struct char_prog_s {
  unsigned char byte0;
  unsigned char byte1;
  unsigned char byte2;
} char_prog_t;

typedef struct ascii_s {
  char_prog_t char0;
  char_prog_t char1;
  char_prog_t char2;
} ascii_t;

const char bit_table[] = { 0x38, 0x00, 0x86, 0x00, 0xbe, 0x00, 0x86, 0x00, 0x38, //0
    0x08, 0x00, 0x02, 0x00, 0x0a, 0x00, 0x02, 0x00, 0x08,     //1
    0x30, 0x00, 0x46, 0x00, 0x76, 0x00, 0x46, 0x00, 0x30,     //2
    0x18, 0x00, 0x46, 0x00, 0x5e, 0x00, 0x46, 0x00, 0x18,     //3
    0x08, 0x00, 0xc2, 0x00, 0xca, 0x00, 0xc2, 0x00, 0x08,     //4
    0x18, 0x00, 0xc4, 0x00, 0xdc, 0x00, 0xc4, 0x00, 0x18,     //5
    0x38, 0x00, 0xc4, 0x00, 0xfc, 0x00, 0xc4, 0x00, 0x38,     //6
    0x08, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x06, 0x00, 0x08,     //7
    0x38, 0x00, 0xc6, 0x00, 0xfe, 0x00, 0xc6, 0x00, 0x38,     //8
    0x18, 0x00, 0xc6, 0x00, 0xde, 0x00, 0xc6, 0x00, 0x18      //9
    };

unsigned char buf[10];

 

The char_prog() function is not changed at all, so I'm skipping that.

 

print_line():

 

Pi

void
print_line(char* line)
{
  // ...
  buf[5]=byte0;
  buf[6]=byte1;
  buf[7]=byte2;
  i2c_write(handle, buf, 8);
}

 

Hercules

void print_line(char* line) {
  // ...
  int delay;
  // ...
  buf[5] = byte0;
  buf[6] = byte1;
  buf[7] = byte2;

  /* Configure Data count */
  i2cSetCount(i2cREG1, 8); // buffer values
  /* Set mode as Master */
  i2cSetMode(i2cREG1, I2C_MASTER);

  /* Set Stop after programmed Count */
  i2cSetStop(i2cREG1);

  /* Transmit Start Condition */
  i2cSetStart(i2cREG1);
  /* Tranmit DATA_COUNT number of data in Polling mode */
  i2cSend(i2cREG1, 8, buf);

  /* Wait until Bus Busy is cleared */
  while (i2cIsBusBusy(i2cREG1) == true)
    ;

  /* Wait until Stop is detected */
  while (i2cIsStopDetected(i2cREG1) == 0)
    ;

  /* Clear the Stop condition */
  i2cClearSCD(i2cREG1);

  for(delay=0;delay<1000000;delay++); // todo: I will have to check in the specs how long I have to wait before I can submit the next conversation.
}

 

The part that shabaz has put in the main() function, I've extracted into a function called lcd3_test().

This because the main() in a non-linux environment has a different nature than bare metal, and I wanted to keep the flow as close to shabaz' as possible.

 

Pi

int
main(void)
{
  int i;
  double v;
  unsigned char text[4];
  char_prog_t *progval;
  unsigned char mode, device, bank, blinkmode;

  mode=0xc9; // Set static mode, display enabled, continuation enabled
  device=DEVICE_ADDR | 0x80; // Select the device, continuation enabled
  bank=BANK_CMD | 0x80 | WR_BANK_A | DISP_BANK_A; 
  blinkmode=BLINK_OFF | 0x80;
  buf[0]=mode;
  buf[1]=device;
  buf[2]=blinkmode;
  buf[3]=bank;
  buf[4]=0x00; // pointer

  handle=i2c_open(I2CBUS, 0x38);

  buf[5]=0xf1; // data
  buf[6]=0x80; // data
  buf[7]=0x02; // data

  progval=char_prog(0, '5');
  buf[5]=progval->byte0;
  buf[6]=progval->byte1;
  buf[7]=progval->byte2;

  print_line(" . .");
  for (v=0.0; v<99.9; v=v+0.1)
  {
    sprintf(text, "%4.1f", v);
    print_line(text);
    delay_ms(40);
  }
  delay_ms(500);
  print_line("   ");

  i2c_close(handle);
  
  return(0);
}

 

Hercules

int lcd3_test(void) {

  double v;
  char text[4];
  char_prog_t *progval;
  unsigned char mode, device, bank, blinkmode;

  i2cInit();

  mode = 0xc9; // Set static mode, display enabled, continuation enabled
  device = DEVICE_ADDR | 0x80; // Select the device, continuation enabled
  bank = BANK_CMD | 0x80 | WR_BANK_A | DISP_BANK_A;
  blinkmode = BLINK_OFF | 0x80;
  buf[0] = mode;
  buf[1] = device;
  buf[2] = blinkmode;
  buf[3] = bank;
  buf[4] = 0x00; // pointer

  buf[5] = 0xf1; // data
  buf[6] = 0x80; // data
  buf[7] = 0x02; // data

  progval = char_prog(0, '5');
  buf[5] = progval->byte0;
  buf[6] = progval->byte1;
  buf[7] = progval->byte2;

  /* Configure address of Slave to talk to */
  i2cSetSlaveAdd(i2cREG1, LCD_ADDR);

  /* Set direction to Transmitter */
  /* Note: Optional - It is done in Init */
  i2cSetDirection(i2cREG1, I2C_TRANSMITTER);

  print_line(" . .");

  for (v = 0.0; v < 99.9; v = v + 0.1) {
    sprintf(text, "%4.1f", v);
    print_line(text);
  }

  print_line("   ");

  return (0);
}

 

and for completeness, the Hercules main() function:

int main(void)
{
  lcd3_test();
  while(1) {
  }
  return 0;
}

 

Configure I2C

True to the Hercules way of working, we set up the i2c driver in HALCoGen.

  • enable the driver

  • set multiplexing to enable i2c functionality

 

  • set the parameters

Connections

We need 4 connections: ground, 3V3, SDA and SCL.

The location of these pins on the LaunchPad depends on witch one you have. Check the schematic file for the right pins.

I'm using an RM46 here.

 

 

For that board, all available pins are on Proto Board Header 11

 

signalLCD boardLaunchXL2-RM46
GND1J11-2
I2C SDA2J11-9
I2C SCL3J11-8
3V34 and 5J11-3

 

 

If you prefer, you can also use BoosterPack position 1 for the connections:

 

CCS project file is attached to this blog. It contains all sources and the HALCoGen configuration for the RM46.

This is an easy-to-replicate exercise. Both for hardware and software.

Spend £5 and check shabaz' instructions for the components, PCB design and build steps.

Then give it a go on your Pi and Hercules.

Have fun!

gold-metasurface-graphic.jpg

A team from UC San Diego used old tube technology to create a chip without semiconductors. This is what the semiconductor free chip would look like. (Image via UC San Diego)

 

The fashion world is proof that old is new again. How else can we explain ‘overalls’ becoming popular again? But it seems that concept is not an exclusive one – it’s coming to the world of technology. Thanks to new research from the University of San Diego, vacuum-tubed powered computers will be making a comeback.

 

Researchers from UC San Diego used vacuum tubes to create the first semiconductor-free, laser-controlled microelectronics device, which uses free electrons. This groundbreaking discovery could lead to better solar panels and faster microelectronic devices. Though it is old technology, the vacuum tubes proved to be more effective because they don’t have the same limitations as semiconductors based on silicon and other materials.

 

Traditional semiconductors cause the electron velocity to be limited due to its resistance of the materials. The electrons also need a zap of energy is needed to get them pulsing through the band gap, which is caused by insulating properties, like silicon. Vacuum tubes dodge these problems since the electrons can be dislodged to carry a current through space. But this doesn’t mean vacuum tubes don’t have their own problems. They require over 100 volts or a powerful laser to knock the electrons loose. The researchers at UC San Diego tackled this problem head on and found a solution in building gold mushroom like nanostructures with parallel gold strips. Combining this with a lower amount of voltage, the electrons were easy to dislodge.

 

So what were the results? Using the vacuum tubes showed a 1000 percent increase in conductivity. This leaves more electrons available for manipulation. Because of this the tubes can act as a transistor, power amplifier, or photodetector, which are all things semiconductors do. But the tubes will work with less resistance and the ability to handle higher amounts of power.

 

Right now this is just a proof of concept. There’s still a lot that testing researchers have to do to ensure these vacuum tubes will actually work for the long term. Dan Sievenpiper, the author of the research paper published in Nature, says the next step for the team is to understand their limitations and how far they can be scaled. The team also wants to test the applications in electronics, environmental applications, and even weapons.

 

The research sounds promising. Hopefully, this application will move from proof of concept to actually being used to make devices, like solar power panels, faster and more efficient. Then maybe more people will be convinced to switch over to solar power for their energy.

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

TI INA301EVM - "High accuracy, high slew-rate current sense amplifier with integrated high-speed comparator optimized for overcurrent protection."
TI INA301EVM - "High accuracy, high slew-rate current sense amplifier with integrated high-speed comparator optimized for overcurrent protection."

 

I saw this board and thought it was pretty useful... see why below...

 

Need your SBC to sense current somewhere in a DC circuit, what’s the best way to do it? Yes, you attempt to make a circuit to do so… or you can just save the time and buy one. I’m a big advocate of “not building a project before building a project.” You want your SBC or MCU to sense current for some reason, not spend any amount of time creating and troubleshooting a way.

 

I saw this board from TI and thought it would make a good addition to one’s dev board cache. Very few kits I’ve come across has any way of sensing current.

 

The TI INA301EVM (an evaluation board) is a current sensing device that amplifies the voltage measurement across a chosen shunt resistor in line with the current source. This analog output device amplifies the signal so that it is suitable for a microcontroller to read its input to an ADC. The INA301 (series) can operate on a supply voltage from 2.7V to 5.5V while operating up to 36V on its input.

example-layout

When measuring current from a device or wire/trace, the voltage is read across a shunt resistor from 0V to 36V range. The output has 2 settable modes, via the reset pin hooked up to one of the GPIO pins of the microcontroller, set high or low.

 

The first mode is transparent mode, which the analog out follows the analog in signal, which is intended to be connected to the ADC pin. The other mode is latched mode. Where an alert can be set using the value of the Rlimit resistor, when an overcurrent is detected, the ALERT pin is pulled low for the microcontroller to detect on its GPIO pin. To determine your Rlimit resistor value, You choose the voltage threshold for the voltage to trip at, using Vlimit in the following equation:

Threshold limit-setting resistor value,  RLIMIT = VLIMIT / ILIMIT

  1. 4 V / 80 µA = 50 kΩ

 

Features:

The device has an excellent temperature range from: -40 C to 125 C

 

Low supply current consumption: at 700uA

 

The elavuation board has 3 different differential amplifiers. 20, 50, 100-V/V gain. Why do you need this? In case the resulting voltage measurement off the current sense resistor is too low to read for the system.

 

typical-use

Application and use: 

Battery Monitor

This device can be used as Battery Monitor where a microcontroller is using the analog output of the INA301 to measure battery current consumption overtime.

 

Power Supply

Current monitor with alarm, the microcontroller can monitor the alarm pin of the INA301 and go into shutdown or sleep when current consumption is too high. This alarm function can also be used as a signal to turn other devices on and off based on the set current alarm.

To get a board, see here. To read even more about it, visit here.

 

Have a story tip? Message me at: cabe(at)element14(dot)com

http://twitter.com/Cabe_Atwell

Filter Blog

By date: By tag: