Skip navigation
1 2 3 Previous Next

Embedded

183 posts

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

Chipsetter_ONE__Oblique_View.jpg

The Chipsetter ONE is an automated pic-and-place machine that assembles PCB electronics using component trays and an array of tape feeders that can utilize different sized SMTs. (via Chipsetter)

 

Anyone who has ever assembled their own PCBs can tell you that it’s a time consuming process that becomes a monotonous nightmare if you have to assemble more than one. Those who prefer to farm that chore out to a manufacturer can tell you that often times it’s costly and can take weeks to receive them depending on how many are needed.

 

In an effort to alleviate those issues, Chipsetter has designed a desktop pick-and-place machine that can assemble PCB electronics in-house in a matter of minutes. In fact, the Chipsetter ONE makes it easy to switch over to different PCB jobs as the tape feeds are modular and can be swapped-out on the fly depending on user’s needs.

 

 

Chipsetter designed the ONE using an automated vacuum head that’s outfitted with dual articulated arms that are capable of picking and placing two electronic components at a time with a size ranging all the way down to 0402. It has a placement speed of up to 1250 component placements per-hour and can accommodate boards of up to 13.5 X 10-inches.

 

Chipsetter_ONE__Reel_Feeder_Attachment__Web_Scale.jpg

The Chipsetter ONE can handle up to 40 8mm tape feeders at a time as well as components from cut-tape and tube packages. I like what I'm seeing here...

 

As far as tape feeders go, the ONE can handle up to 40 8mm feeders as well as 12 and 16mm feeders as well. Components can also be supplied using cut-tape, tube packages and JEDEC/custom trays- or even a dual combination of package platforms. The pick-and-place machine has an accuracy of 30-microns thanks to a pair of cameras, situated above and below the 8-position auto-tool changer, making it incredibly reliable with component placement. The top camera actually inspects and corrects component alignment while the bottom corrects any misalignment with in-place components.

 

On the software side, the platform handles everything so there is no setup or programming needed, even for different circuit board projects. Users simply send the manufacturing data, including Centroid and BOM files (in .csv format) from their favorite EDA platform to the machine and it does the rest.

 

There are a few drawbacks to Chipsetter’s ONE, as users need to apply the solder paste manually, which can get messy if not done correctly. Users also need their own reflow oven, as the ONE does not come equipped with one. This makes it hard to justify the price tag, which comes in at just over $3,500 US. Makers who manufacture several circuit boards per year probably would not benefit from using this machine, however small businesses who churn-out dozens per-year would probably find it beneficial from producing their PCBs in-house.

 

Chipsetter is currently coming to an end of an unsuccessful Kickstarter campaign to manufacture the ONE with reaching only $66,714 of their target goal of $104,895 and it’s uncertain if those interested will be able to get their hands on one in the near future. 

 

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

http://twitter.com/Cabe_Atwell

Joled.PNG

The team at the university uses voxels and ultrasound waves to keep the pixels floating in mid-air. These pixels are actually floating in mid-air (via University of Sussex)

 

With most of our times spent staring at screens, the clear, crispness of displays are important. Every year devices seek out pixels that are better and make for the ultimate viewing experience. But what if the pixels floated in midair? The University of Sussex has created an experimental display, dubbed JOLED, made of a grid of voxels that measure 7x6 voxels high and wide. That’s not the mind blowing part. The voxels look like multi-colored spheres that float in mid-air.

 

Looking at the testing footage, it looks like a magic trick or CGI footage, but this is very real. The spheres stay in the air by ultrasound speakers that put out high-pitched and high intensity soundwaves, which are inaudible but forceful enough to keep the spheres in the air. The pixels themselves are coated in titanium dioxide, which gives them an electrostatic charge which allows them to be manipulated in mid-air with a change in the electric force field.

 

So what can this technology be used for? The team at Sussex is currently testing how the display can be used to provide on-demand media. They see it as a screen appearing in front of the viewer and then the objects fall to the ground once the video is finished. They also want viewers to be able to interact with it. Sounds like something out of The Matrix. The team also wants to up the pixel density along with the colors displayed.

 

It’s definitely cool to see these pixels float in the air looking like it was created with movie magic. But don’t expect to see the display for yourself anytime soon. The team still has a lot of work to do before they make this technology a reality. Recently, the team presented their findings at Japan’s ACM User Interface Software and Technology Symposium. This technology could lead to new possibilities for media, including mobile and game designers. 

 

Who knows, this is what our displays could look like in the future. For now, we’ll have to shell out a lot of cash for those flat old 4K TVs. Or.. is it time to dust off the CRT?

 

 

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

http://twitter.com/Cabe_Atwell

Can anyone help me on how to automatically  wake MFRC 522 Mifare Reader up by the presence of a RFID Card. And after goes back to sleep

tera.jpg

Russian and European scientists believe T-rays will be faster than electromagnetic fields when running computers. Will T-rays make our computers faster?

 

No one looks forward to going to the airport and in recent years the experience has been more unpleasant thanks to TSAs. Security is important, but there’s a sense of dread and unease when walking through a body scanner. But while getting scanned to make sure you have the proper sized shampoo, did you ever think the TSA technology could be used to speed up your computer? Russian and European scientists are currently testing the method and published their findings in Nature.

 

No matter how fast your computer is, it can always be faster. Memory is what keeps our computers from being lightning fast. Memory cells on a PC are switched via an external magnetic field, but it’s not necessarily the fastest method. But this new process proposed by scientists would forego that. Rather it would use terahertz radiation (T-rays), the same ones found on airport bdy scanners. The T-rays could speed up the rate at which cells reset by a factor of 1000. This could then be used to make faster memory.

 

T-rays (Terahertz-driven anisotropy fields) emit a series of short electromagnetic pulses that hit the cells at high terahertz frequencies making them faster than the average electromagnetic field. But don’t expect to find t-rays blasting through computers any time soon. Scientists are still testing the method. So far they’ve tested it on a weak ferromagnet, thulium orthoferrite (TmFeO) with great success. The results also showed the T-rays’ effect was ten times greater than the external magnetic field making this method faster and more efficient. But the T-rays have yet to be tested on computer memory cells. You’ll have to wait on getting a super speedy computer.

 

Because T-rays can dish out quick, precise scans of organic and mechanical material, they have other uses as well. Some proposals include looking for weapons inside of luggage, scanning broken microchips, and looking into fragile texts. If this method does actually work on computer memory cells, it would be a huge improvement for high performance computers. Even the tiniest boost could make a big difference depending on the application. Scientists are still working out all the kinks but hopefully we’ll have an update on this development soon.

 

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

http://twitter.com/Cabe_Atwell

 

 

Filter Blog

By date: By tag: