Skip navigation
1 2 3 Previous Next

Embedded

177 posts

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

 

 

beerbattery.png

A research team at the University of Colorado-Boulder is using wastewater from breweries to help cultivate ion battery electrodes. A diagram of the process researchers use the wastewater (Photo from University Colorado-Boulder)

 

For some, beer is the ultimate refreshment, but thanks to researchers at the University of Colorado-Boulder, it can also be a power source. Researchers have found a way to transform brewery runoff into low-cost lithium-ion battery electrodes. Talk about getting a buzz. This is a great way to recycle the waste. When a brewery makes a single barrel of beer it takes around seven barrels of water to make it. The wastewater then has to be filtered before it’s thrown out, which also costs brewers money. Using the waste to cultivate batteries not only recycles the matter, but it saves money as well.

 

The process of using the wastewater for ion batteries is similar to beer making according to the Colorado researchers. They cultivate the feedstock in wastewater, which produces Neurosporacrassa, a fast growing fungus. This sugary fungus can then be used to make anodes for the ion batteries. The researchers say the wastewater is ideal for the fungus to grow in. The wastewater also helps researchers note the fungus' chemical and physical processes from the beginning.

 

Researchers are in the testing phases with the process now, but as long as tests prove successful it has the potential to be used on a wider scale. This process could help breweries limit their wastewater costs and manufacturers would have access to an incubating medium for battery technology components that are cost effective. So far, one brewery is one board with the research team: Avery Brewing in Boulder. This new partnership will allow the team to test the process on a wider scale. The team, led by Tyler Huggins and Justin Whiteley, recently took part in the finals of a US Department of Energy-sponsored incubator competition at the Argonne National Laboratory in Chicago.

 

Recycling wastewater to help ion batteries is a great step forward in helping to reduce waste on the planet. This process prevents the waste from just sitting in giant vats in the brewery. It also saves them money and happy breweries make for tastier beer, probably. Who would've thought beer could actually be used to make batteries. And you thought the best thing they did with beer is make fried foods with it.

 

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

http://twitter.com/Cabe_Atwell

ledbasketballcourt.jpg

Yoyogi National Gymnasium replaced the wooden floor with 400sqm of SEfl LED Video-flooring from Glux. (via rentGlux)

 

The B. League basketball games in Tokyo have kicked off with the first beginning with Alvark Tokyo against the Ryukyu Golden Kings at Tokyo’s Yoyogi National Gymnasium. The game itself is just like any pro basketball game, however the MVP in this case isn’t the best player but rather the court itself as the traditional wood planks have been replaced by LED display panels.

All of the sections of the court, including the center circle and free-throw lines are prominently displayed just like any regulation court but that is where the similarities end as graphics and animations are projected on the floor when something significant happens in the game.

 

For example- during the tip-off both team names encircle the center circle and explodes away during the jump. A successful 3-pointer will result in number 3 graphic and dunking results in an explosion and/or the player’s bio displayed on the court. What’s more, players can be tracked with tracer lines and circles that follow them as they traverse up and down the court.

 

 

The court itself is made up of 1,680 individual displays that are about 20-inches from edge to edge, measuring out at 400sqm. The panels are actually a product of China-based Glux who are known for their creative LED displays, which were prevalent for the opening ceremony of the 2008 Olympics in Beijing, the 2010 Shanghai World Expo and the 2010 Singapore Youth Olympics.

 

 

For the Yoyogi Gymnasium, Glux used their SEfl LED Video-flooring, which has a pixel density of up to 36,864 (dots/m2), a refresh rate of 1MHz and a contrast ratio of 2000: 1. Each panel is covered by a transparent PC ABS protective mask and is made using a strong waterproof carbon fiber frame, making it incredibly durable and able to withstand over 1,000 pounds and great for playing basketball on.

 

IMG_0641.JPG

Workers installing the SEfl LED flooring, which is done in the same fashion as some anti-static tile floors found in server rooms.

 

The LED flooring is installed in almost a similar fashion as some modular anti-static floor tiles found in server rooms, which uses aluminum floor beams to connect each panel while metal latches lock them in place, making it easy to switch out panels if problems arise. Each LCD panel also has its own power supply built in as well as a CAT6 port to interlock the panels together for use as massive single display or a ton of smaller ones, all of which can be controlled using a single laptop or PC.

 

As the video shows, the end result of putting together a bunch of LED floor panels is certainly impressive but I have to wonder if it interferes with the players. Blinding isn’t a problem as each LED display has a film over the ABS protective mask to subdue its brightness and glare but I can’t help wondering if they get motion sickness during animations.

 

Have a story tip? Message me at:

http://twitter.com/Cabe_Atwell

RR thud-rumble-invader-180816-616x440.jpg
The Invader mixes an old school turntable with a embedded record

(Photo from Thud Rumble)

 

Hoping to do something similar to this with a Raspberry Pi, but in the meantime....

 

The art of DJing has been around since the late 70s. Over time the art form has evolved and adapted to new technology. Some find the use of computers in DJing an innovation; others see it as lazy and prefer the old school way. But both methods offer something different the other doesn't have. Isn't there a way to bring the best of both worlds together? A group of DJs may have answered the call with their latest turntable, The Invader, which features a mixer and an embedded computer.

 

The project is created by DJs Qbert, Yogafrog (Ritche Desuasido), Rich Johnson (DJ Hard Rich), and Killa-Jewel (Julie Fainer). They had the idea four years ago when their company, Thud Rumble, was having an open house and Rich Johnson expressed his desire to make a mixing machine for them. The dream is now a reality. Showing off prototypes at Intel's IDF keynote, The Invader looks like an old school mixer with a touchscreen display running Windows 10. The turntables run on the company's own Traktor mixing software, but any DJ app that runs on Microsoft's OS will work.

 

The prototypes are pretty tall, but the company wants to make it no taller than two centimeters so it'll easily slip inside a backpack. The turntable has standard features found on most mixing board, like faders in the middle of the board and volume controls for each deck above. There are also eight buttons along the side a DJ can set up to play different cuts in a song. The board runs on Intel i5 and i7 processors, if you couldn't guess, and comes with additional HDMI for video mixing. Currently, there's no soundcard, but the company are working with Native Instruments for a future audio interface.

 

The Invader is still in the early phase of development and the creators are looking to add more features. The printed circuit board needs to be finalized along with the standard audio ports. These ports allow you to switch to phono so you can scratch actual vinyl. The Invader also gives you some customization choices from laser-etching options to choice of rubber or old school arcade buttons for video game enthusiasts. So what is the price for this new turntable? It'll be priced at $1,699. It sounds like a lot, but compared it to the Pioneer DJ DJM-S9 mixer for Serato, which costs the same without the built-in computer. The Invader will ship at the end of the year.

 

This turntable is an innovative way to mix the old school with the new. And best of all, it lets you have the best of both world without having to lug around a laptop. Macbooks may be light, but why risk bringing all that data around with you? The Invader gives you everything you need in this all-in-one turntable. But this doesn't mean it could pose some problems. For one, most DJs use mixers provided by venues. Some may not have an issue with bringing their own mixer, but others may not want to do so. Also, with a laptop you have instant access to your songs and mixes. With this turntable you may have to move your songs to the embedded computer. Hopefully, the songs will be easily accessible. Either way, it's a new way to think about an artform as old as Djing.

 

 

 


hero.png

Ecad.io lets users convert their ECAD files into MCAD files online, such as this Arduino Uno 3D schematic. (via ecad.io)

 

If you’re looking for a quick and simple way to convert your ECAD files into MCAD, you may want to check out ecad.io (now part of the Autodesk empire). What’s more, users can view and manipulate the models in 3D as well as modify those models in a limited fashion i.e. hiding unwanted objects and changing-out simple components. Once the 3D model manipulation is complete, it can then be downloaded in several different formats for use on most MCAD systems.

 

Ecad.io was actually designed by the creators of CADSoft and wanted a simplistic system for engineers that wouldn’t break the bank, didn’t take forever to install and didn’t require a Ph.D. to use. Their intention was to make the data-language bridge between ECAD and MCAD as simple and straightforward as possible over a web-based platform using desktop or online CAD tools.

 

 

Ecad.io is capable of reading/writing in a number of different formats in order to be compatible with a number of different ECAD and MCAD systems. As it stands now, ecad.io reads IDF 2/3 ECAD interchange formats as well as the IPC-2581 format and Cadsoft Eagle files. As far as writing goes, it uses STEP and IGES 3D data exchange file formats, allowing different format files to flow back and forth with relative ease.

 

It is also compatible with most every CAD system on the planet, including CadSoft Eagle, A host of Mentor suites (BroadStation, Expedition, etc.), SolidWorks and PTC Creo just to name a few. A complete list of systems can be found here (https://www.ecad.io/Resources/Systems). As far as features go, ecad.io has a simplified built-in component library and simple tools to help position them on the 3D model. If users need a specific component that is not listed in the library, it will then offer a suitable replacement based on the original components name, size and type. Of course, users can always substitute their own if they prefer and even save them in ecad.io’s library for future use.

 

Security for ecad.io isn’t the best in the world, but it is effective as far as online browser-based platforms go. Is anything online truly secure? Once a model is uploaded, the platform extracts the necessary data from the shape of the PCB and component layout from the file and then deletes it. The board’s data is then compressed and encrypted before being stored for later use. The user can also delete that data file if the need arises.

 

Is ecad.io an end-all conversion and manipulation tool for producing ECAD/MCAD models? No and it was never meant to be but it can come in handy, especially when subtle model adjustments and conversions need to be done quickly and remotely. Since it’s browser-based, you can use it anywhere, making it a versatile tool to keep handy when away from home.

 

Have a story tip? Message me at:

http://twitter.com/Cabe_Atwell

Carbon-Nanotube-Substrate-closeup.jpg

Researchers used a rapid-deposition process to attach an aligned array of carbon nanotubes on a 1-inch X 1-inch substrate. (via WISC)

 

Materials engineers from the University of Wisconsin have finally developed a process that turns carbon nanotubes into resistors that can outperform traditional silicon or even gallium-based transistors. How much faster are they compared to silicon- 1.9-times faster to be exact, making them a viable candidate for batteries with longer life, faster Wi-Fi and faster processors.

 

Scientists have been trying for years to replace silicon with carbon but some issues were holding them back, most notably getting pure nanotubes with limited defects and putting them in a structured order. Without those, their performance is limited, disrupting their semiconducting properties- essentially underperforming when compared to using traditional materials. To get the near-perfect nanotubes separated from the subpar tubes, the engineers turned to a solution of polymers to sort-out the imperfect (metallic) tubes, leaving only high-quality carbon semiconducting tubes. The engineers then baked the arrays in a vacuum to get rid of the polymers insulating layer between the nanotubes and the resistor’s electrodes.

 

master.img-000.jpg

To get the nanotubes in alignment and parallel on a wafer, the engineers used a process called floating evaporative self-assembly.

 

Another problem the engineers needed to tackle was getting the nanotubes in perfect alignment with equal spacing deposited on a substrate. To do this, the team turned to a process known as floating evaporative self-assembly (FESA), which is done by dropping the nanotube solution in a water bath and then vertically dunking the substrate in and out of the bath, This process causes the tubes to self-align with equal spacing when the nanotube solution evaporates.

 

With that issue out of the way, the engineers then proceeded to turn the nanotubes into a functioning transistor by first coating the new wafer with a PMMA resist (polymeric material) and then patterned using electro-beam lithography. After that process, the unwanted or defective material is etched away from the wafer. Acetone is then used to clear away the rest of the PMMA material and then palladium contacts are added to the nanotubes resulting in a FET (field Effect Transistor.

 

Don’t expect to see these new nanotube transistors in mobile devices or PCs anytime soon however, as there are many refinements they must undergo before they can be mass-produced, including scaling up the manufacturing process and adapting them to current silicon-based geometries. Still, it will not be that far off before these issues are resolved, making the future look that much brighter and faster.

 

Have a story tip? Message me at:

http://twitter.com/Cabe_Atwell

io808.jpg

HTML’s virtual drum machines are now available for free on all popular browsers. It, Arduino, and littleBits new drum and synth kits make music making easier than ever.

 

This is a hobby like interest for me - synthesizers and drum machines. Mainly, I am fascinated with them due to the plethora of SBCs I could use to recreate the sound. Or rather, how do I use SBCs to recreate them. Here is some 808 news for you…

 

If you were thinking of forking over $600 for a drum kit, think again. HTML just released a virtual version of its 808 and 5 Drum Machine via web browser, and it’s free! If it’s a hands-on drum machine you require, consider building your own with littleBits and Arduino. The io-808 is a virtual TR-808 based on the HTML-808 and HTML5 Drum Machine. The interface features all the great controls and functionality of a real drum machine, online. Best yet, it’s free and the quality is intended to match the sound of a physical 808 via Web Audio API.

 

It’s not perfect, but for free you’ll get to toy around to see if you really need the upgraded infrastructure to record your own rendition of Back-to-Back in your basement. Most of us don’t. But if you do require a kit, consider littleBits and Arduino DIY projects before dishing out your hard-earned money.

 

SynthKitBoxandBits-Reskin_WhiteBackgroundHR.jpg

 

For $159, the littleBits Synth Kit makes all electronic music possible. You can build your own electronic instruments, including a DIY keytar (like a guitar, mostly), drum kit, soundboard, mixer, synthesizer, and more. And if you get bored with one design, simply break it down and move onto the next project. The kit even includes an invention booklet with 36 step-by-step ideas for ‘professional grade’ tools. Building with littleBits is child’s play.

 

2b8ff2af-fcee-43d6-93f6-74905b53c1b8.JPG

 

And for the true DIYer out there, you can build your own 80s-themed drum machine with spare parts. If you have an extra Arduino board and some spare littleBits parts lying around, you already have all the parts you need.

 

The Arduino Lo-fi Beat Box is your key to 80s beats. The demo kit features 16 TR-808-like beats, with up to eight instruments per pattern. You can adjust the tempo from 60 BPM to 188 BPM, and even code in your own waveforms, drum kits, and patterns. Mono waveforms are 22,050Hz and 8-bit signed for lo-fi grunge tunes you love. 

 

Making music has never been so easy. Bookmark these project, or go build your own.

 

Then again... nothing sound quite like an eight oh eight!

 

 

 

Have a story tip? Message me at:

http://twitter.com/Cabe_Atwell

Filter Blog

By date: By tag: