Feed aggregator

Voice Controlled Stereo Balance With ESP8266

Hackaday - 5 hours 29 minก่อน

A stereo setup assumes that the listener is physically located between the speakers, that’s how it can deliver sound equally from both sides. It’s also why the receiver has a “Balance” adjustment, so the listener can virtually move the center point of the audio by changing the relative volume of the speakers. You should set your speaker balance so that your normal sitting location is centered, but of course you might not always be in that same position every time you listen to music or watch something.

[Vije Miller] writes in with his unique solution to the problem of the roving listener. He’s come up with a system that can adjust the volume of his speakers without having to touch the receiver’s setup, in fact, he doesn’t have to touch anything. By leveraging configurable voice control software running on his computer, his little ESP8266-based devices do all the work.

Each speaker has its own device which consists of a NodeMCU ESP8266 and X9C104 digital potentiometer inside of a 3D printed case. The audio terminal block on the gadget allows him to connect it inline between the speaker and the receiver, giving [Vije] the ability to adjust the volume through software. The source code, which he’s posted on the Hackaday.io project page, uses a very simple REST-style API to change speaker volume based on HTTP requests which hit the ESP8266’s IP address.

The second part of the project is a computer running VoiceAttack, which lets [Vije] assign different actions based on what the software hears. When he says the appropriate command, the software goes through and fires off HTTP requests to the nodes in the system. Everything is currently setup for two speakers, but it shouldn’t be too difficult to expand to more speakers (or even rooms) with some adjustment to the software.

It’s not the first voice controlled speaker we’ve ever seen, but it does solve a very specific problem in a unique way. We’d be interested in seeing the next logical step, which would see this technology integrated into the speaker itself.

Huawei’s next smartphone may also be a wireless charger (for earbuds)

Liliputing - 5 hours 41 minก่อน

Huawei’s expected to launch the Mate 20 smartphone on October 16th. It’ll be powered by the company’s new Kirin 980 processor, and it may have at least three cameras, arranged in a square-shaped pattern for some reason. But one of the most surprising things about the phone? Not only will you probably be able to […]

The post Huawei’s next smartphone may also be a wireless charger (for earbuds) appeared first on Liliputing.

‘SHE BON’ is an Artful, Wearable, Sensual, Sensing Platform

Hackaday - 6 hours 59 minก่อน

SHE BON (that’s the French bon, or “good”) is an ambitious project by [Sarah Petkus] that consists of a series of wearable electronic and mechanical elements which all come together as a system for a single purpose: to sense and indicate female arousal. As a proponent of increased discussion and openness around the topic of sexuality, [Sarah]’s goal is to take something hidden and turn it into something obvious and overt, while giving it a certain artful flair in the process.

The core of the system is a wearable backpack in the shape of a heart, from which all other sensors and feedback elements are connected. A lot of thought has gone into the design of the system, ensuring that the different modules have an artistic angle to their feedback while also being comfortable to actually wear, and [Sarah] seems to have a knack for slick design. Some of the elements are complete and some are still in progress, but the system is well documented with a clear vision for the whole. It’s an unusual and fascinating project, and was one of the finalists selected in the Human Computer Interface portion of the 2018 Hackaday Prize. Speaking of which, the Musical Instrument Challenge is underway, so be sure check it out!

The HackadayPrize2018 is Sponsored by:





Industrial 3D Printing Uses Layers Like We’ve Never Seen Before

Hackaday - 8 hours 28 minก่อน

We’ve seen FDM printers lay down layers by extruding plastic in a line. We’ve seen printers use sintering and lithography to melt or cure one layer at a time before more print medium moves into place for the next layer. What we’ve never seen before is a printer like this that builds parts from distinct layers of substrate.

At the International Manufacturing Technology Show last week I spoke with Eric Povitz of Impossible Objects. The company is using a “sheet lamination process” that first prints each layer on carbon fiber or fiberglass, then uses a hydraulic press and an oven to bake the part into existence before bead-blasting the excess substrate away. Check out my interview with Eric and join me below for more pictures and details.

It’s incredible to see a process that prints the layers individually, using holes to align all of the layers on rods before fusing them together. I’m told the accuracy and resolution is quite good but don’t have a metric to back that up. The accuracy is best running parallel to the layers, so wide flat parts will yield consistent results. Very tall parts that require many layers will eventually see variations in accuracy.

The substrate used in this process is quite thin and wispy. The printer itself moves the substrate through a process that uses inkjet printing to deposit a binder. Powdered thermoplastic is then applied where it sticks to the binder and the excess is reclaimed. The layers are automatically stacked in order at the end of the machine.

The second half of the process compresses the layers in a press, and bakes them to melt the thermoplastic into a solid. Bead blasting is then used to remove the excess substrate. Depending on your application, the part is now ready to used, or can be further processed through machining, adding threaded inserts, or other processes common to working with composites.

There’s a range of materials available for use with this technique. They depend on what substrate and thermoplastic is chosen. One of the more interesting examples they had on hand is made of carbon fiber reinforced polyether ether ketone (PEEK). This material has excellent heat resistance, and feels like metal when held in your hand. This particular demo is a jig for holding PCBs during wave soldering.

What you end up with are composite parts that have very different properties from those printed in powder or resin processes. These parts are reinforced by the fibers of the substrate and will certainly find eager customers in the manufacturing industry for applications that aren’t being met by other additive technologies.

If you loved this, make sure you also check out the direct metal printing equipment we saw at IMTS.

Join Hackaday For A Night Of Pre-Maker Faire Hacks

Hackaday - พุธ, 09/19/2018 - 23:01

This weekend is the World Maker Faire in New York, and Hackaday will be there looking at the latest and greatest projects from makers around the globe. We’ll also be buying bottles of water for five dollars, but that’s another story entirely.

As always, this year’s World Maker Faire will be held at the wonderful New York Hall of Science, and the lineup is spectacular. There will be cosplay, and Adam Savage will be there with a half dozen Junior Mythbusters. There will be a twenty-six foot tall hydraulic hand trucked in from Burning Man. You’re looking at the greatest event in STEAM education since the Bay Area Maker Faire last May.

Hackaday has a fantastic New York community and we’re holding a meetup this Thursday to sync up with Maker Faire. Guess what?  You’re invited!

We’re teaming up with our friends at Kickstarter to bring you an awesome night of hardware builds, music hacks, snacks, and more. While this is an informal event, we do have a few people who will be bringing their latest hacks to show off. Nick Chelyapov, a designer turned gear head who designed an Arduino-based synthesizer and drum machine. This isn’t a toy, but it’s also not a complicated mess of patch cables and eurorack modules. The Bitty is a real instrument that’s easy enough for anyone to pick up and make bleep bloops.

Also confirmed for this meetup is Nick Yulman, an artist who works with sound and interactive media in a variety of contexts. He’s gearing up to install his robotic musical instruments in the Areté Gallery in Greenpoint, Brooklyn. But this week he’ll be showing us how musical robots helped him stop worrying and love digital music.

This isn’t an event to be missed. You can RSVP for the event over on Eventbrite, and be sure to bring whatever project you’re working on. It’s going to be an entire night of drinks and hacks, just the thing before Maker Faire really gets rolling. Once the weekend hits, find us at the Faire; several of us from the Hackaday crew will be wandering the grounds looking for awesome hardware projects. Stephen Tranovich is even giving a talk about the Hackaday Prize on Sunday at 11. See you at the Faire!

Daily Deals (9-19-2018)

Liliputing - พุธ, 09/19/2018 - 22:55

Sony and Bose make some of the best noise-canceling wireless headphones around… if you want to spend $300 or more on a pair of headphones. Fortunately there are growing options for folks on a tighter budget. Case in point: today you can pick up a pair of TaoTronics over-ear wireless headphones with active noise canceling […]

The post Daily Deals (9-19-2018) appeared first on Liliputing.

Asus VivoBook Flip 14 with Kaby Lake-R now available for $750 and up

Liliputing - พุธ, 09/19/2018 - 22:00

The Asus VivoBook Flip 14 is mid-range convertible laptop with a 360-degree hinge that lets you position the touchscreen display for use in laptop or tablet modes. In June Asus unveiled a new model called the VivoBook Flip TP412 featuring 8th-gen Intel Core “Kaby Lake Refresh” processor options, and now it’s available for purchase in […]

The post Asus VivoBook Flip 14 with Kaby Lake-R now available for $750 and up appeared first on Liliputing.

Braille on a Tablet Computer

Hackaday - พุธ, 09/19/2018 - 22:00

Signing up for college classes can be intimidating, from tuition, textbook requirements, to finding an engaging professor. Imagine signing up online, but you cannot use your monitor. We wager that roughly ninety-nine percent of the hackers reading this article have it displayed on a tablet, phone, or computer monitor. Conversely, “Only one percent of published books is available in Braille,” according to [Kristina Tsvetanova] who has created a hybrid tablet computer with a Braille display next to a touch-screen tablet running Android. The tablet accepts voice commands for launching apps, a feature baked right into Android. The idea came to her after helping a blind classmate sign up for classes.

Details on the mechanism are not clear, but they are calling it smart liquid, so it may be safe to assume hydraulic valves control the raised dots, which they call “tixels”. A rendering of the tablet can be seen below the break. The ability to create a full page of braille cells suggest they have made the technology pretty compact. We have seen Braille written on PCBs, a refreshable display based on vibrator motors, and a nicely sized Braille keyboard that can fit on the back of a mobile phone.

Xiaomi introduces $465 Mi 8 Pro and $200 Mi 8 Lite smartphones

Liliputing - พุธ, 09/19/2018 - 21:12

It’s been a few months since Xiaomi launched the Mi 8 family of smartphones in China. Now the company company is introducing two new models. The Mi 8 Pro has premium features including a Qualcomm Snapdragon 845 processor, an AMOLED display, and a pressure-sensitive in-display fingerprint sensor. It will be available in China later this […]

The post Xiaomi introduces $465 Mi 8 Pro and $200 Mi 8 Lite smartphones appeared first on Liliputing.

Learn To Loop The Python Way: Iterators And Generators Explained

Hackaday - พุธ, 09/19/2018 - 21:00

If you’ve ever written any Python at all, the chances are you’ve used iterators without even realising it. Writing your own and using them in your programs can provide significant performance improvements, particularly when handling large datasets or running in an environment with limited resources. They can also make your code more elegant and give you “Pythonic” bragging rights.

Here we’ll walk through the details and show you how to roll your own, illustrating along the way just why they’re useful.

You’re probably familiar with looping over objects in Python using English-style syntax like this:

people = [['Sam', 19], ['Laura', 34], ['Jona', 23]] for name, age in people: ... info_file = open('info.txt') for line in info_file: ... hundred_squares = [x**2 for x in range(100)] ", ".join(["Punctuated", "by", "commas"])

These kind of statements are possible due to the magic of iterators. To explain the benefits of being able to write your own iterators, we first need to dive into some details and de-mystify what’s actually going on.

Iterators and Iterables

Iterators and iterables are two different concepts. The definitions seem finickity, but they’re well worth understanding as they will make everything else much easier, particularly when we get to the fun of generators. Stay with us!

Iterators

An iterator is an object which represents a stream of data. More precisely, an object that has a __next__ method. When you use a for-loop, list comprehension or anything else that iterates over an object, in the background the __next__ method is being called on an iterator.

Ok, so let’s make an example. All we have to do is create a class which implements __next__. Our iterator will just spit out multiples of a specified number.

class Multiple: def __init__(self, number): self.number = number self.counter = 0 def __next__(self): self.counter += 1 return self.number * self.counter if __name__ == '__main__': m = Multiple(463) print(next(m)) print(next(m)) print(next(m)) print(next(m))

When this code is run, it produces the following output:

$ python iterator_test.py 463 926 1389 1852

Let’s take a look at what’s going on. We made our own class and defined a __next__ method, which returns a new iteration every time it’s called. An iterator always has to keep a record of where it is in the sequence, which we do using self.counter. Instead of calling the object’s __next__ method, we called next on the object. This is the recommended way of doing things since it’s nicer to read as well as being more flexible.

Cool. But if we try to use this in a for-loop instead of calling next manually, we’ll discover something’s amiss.

if __name__ == '__main__': for number in Multiple(463): print(number) $ python iterator_test.py Traceback (most recent call last): File "iterator_test.py", line 11, in <module> for number in Multiple(463): TypeError: 'Multiple' object is not iterable

What? Not iterable? But it’s an iterator!

This is where the difference between iterators and iterables becomes apparent. The for loop we wrote above expected an iterable.

Iterables

An iterable is something which is able to iterate. In practice, an iterable is an object which has an __iter__ method, which returns an iterator. This seems like a bit of a strange idea, but it does make for a lot of flexibility; let us explain why.

When __iter__ is called on an object, it must return an iterator. That iterator can be an external object which can be re-used between different iterables, or the iterator could be self. That’s right: an iterable can simply return itself as the iterator! This makes for an easy way to write a compact jack-of-all-trades class which does everything we need it to.

To clarify: strings, lists, files, and dictionaries are all examples of iterables. They are datatypes in their own right, but will all automatically play nicely if you try and loop over them in any way because they return an iterator on themselves.

With this in mind, let’s patch up our Multiple example, by simply adding an __iter__ method that returns self.

class Multiple: def __init__(self, number): self.number = number self.counter = 0 def __iter__(self): return self def __next__(self): self.counter += 1 return self.number * self.counter if __name__ == '__main__': for number in Multiple(463): print(number)

It now runs as we would expect it to. It also goes on forever! We created an infinite iterator, since we didn’t specify any kind of maximum condition. This kind of behaviour is sometimes useful, but often our iterator will need to provide a finite amount of items before becoming exhausted. Here’s how we would implement a maximum limit:

class Multiple: def __init__(self, number, maximum): self.number = number self.maximum = maximum self.counter = 0 def __iter__(self): return self def __next__(self): self.counter += 1 value = self.number * self.counter if value > self.maximum: raise StopIteration else: return value if __name__ == '__main__': for number in Multiple(463, 3000): print(number)

To signal that our iterator has been exhausted, the defined protocol is to raise StopIteration. Any construct which deals with iterators will be prepared for this, like the for loop in our example. When this is run, it correctly stops at the appropriate point.

$ python iterator_test.py 463 926 1389 1852 2315 2778 It’s good to be lazy

So why is it worthwhile to be able to write our own iterators?

Many programs have a need to iterate over a large list of generated data. The conventional way to do this would be to calculate the values for the list and populate it, then loop over the whole thing. However, if you’re dealing with big datasets, this can tie up a pretty sizeable chunk of memory.

As we’ve already seen, iterators can work on the principle of lazy evaluation: as you loop over an iterator, values are generated as required. In many situations, the simple choice to use an iterator or generator can markedly improve performance, and ensure that your program doesn’t bottleneck when used in the wild with bigger datasets or smaller memory than it was tested on.

Now that we’ve had a quick poke around under the hood and understand what’s going on, we can move onto a much cleaner and more abstracted way to work: generators.

Generators

You may have noticed that there’s a fair amount of boilerplate code in the example above. Generators make it far easier to build your own iterators. There’s no fussing around with __iter__ and __next__, and we don’t have to keep track of an internal state or worry about raising exceptions.

Let’s re-write our multiple-machine as a generator.

def multiple_gen(number, maximum): counter = 1 value = number * counter while value <= maximum: yield value counter += 1 value = number * counter if __name__ == '__main__': for number in multiple_gen(463, 3000): print(number)

Wow, that’s a lot shorter than our iterator example. The main thing to note is a new keyword: yield. yield is similar to return, but instead of terminating the function, it simply pauses execution until another value is required. Pretty neat.

In most cases where you generate values, append them to a list and then return the whole list, you can simply yield each value instead! It’s more readable, there’s less code, and it performs better in most cases.

With all this talk about performance, it’s time we put iterators to the test!

Here’s a really simple program comparing our multiple-machine from above with a ‘traditional’ list approach. We generate multiples of 463 up to 100,000,000,000 and time how long each strategy takes.

import time def multiple(number, maximum): counter = 1 multiple_list = [] value = number * counter while value <= maximum: multiple_list.append(value) value = number * counter counter += 1 return multiple_list def multiple_gen(number, maximum): counter = 1 value = number * counter while value <= maximum: yield value counter += 1 value = number * counter if __name__ == '__main__': MULTIPLE = 463 MAX = 100_000_000_000 start_time = time.time() for number in multiple_gen(MULTIPLE, MAX): pass print(f"Generator took {time.time() - start_time :.2f}s") start_time = time.time() for number in multiple(MULTIPLE, MAX): pass print(f"Normal list took {time.time() - start_time :.2f}s")

We ran this on a few different Linux and Windows boxes with various specs. On average, the generator approach was about three times faster, using barely any memory, whilst the normal list method quickly gobbled all the RAM and a decent chunk of swap as well. A few times we got a MemoryError when the normal list approach was running on Windows.

Generator comprehensions

You might be familiar with list comprehensions: concise syntax for creating a list from an iterable. Here’s an example where we compute the cube of each number in a list.

nums = [2512, 37, 946, 522, 7984] cubes = [number**3 for number in nums]

It just so happens that we have a similar construct to create generators (officially called “generator expressions”, but they’re nearly identical to list comprehensions). It’s as easy as swapping [] for (). A quick session at a Python prompt confirms this.

>>> nums = [2512, 37, 946, 522, 7984] >>> cubes = [number**3 for number in nums] >>> type(cubes) <class 'list'> >>> cubes_gen = (number**3 for number in nums) >>> type(cubes_gen) <class 'generator'> >>>

Again, not likely to make much difference in the example above, but it’s a two-second change which does come in handy.

Summary

When you’re dealing with lots of data, it’s essential to be smart about how you use resources, and if you can process the data one item at a time, iterators and generators are just the ticket. A lot of the techniques we’ve talked about above are just common sense, but the fact that they are built into Python in a defined way is great. Once you dip your toe into iterators and generators, you’ll find yourself using them surprisingly often.

Sony PlayStation Classic coming in December for $100 (with 20 PS1 games pre-loaded)

Liliputing - พุธ, 09/19/2018 - 19:51

Sony is following in Nintendo’s footsteps and launching a tiny replica of a classic game console with a bunch of games pre-installed. The PlayStation Classic is set to hit the streets on December 3rd, and it’s already up for pre-order for $100 from Best Buy and GameStop. The retro console looks like a shrunken version […]

The post Sony PlayStation Classic coming in December for $100 (with 20 PS1 games pre-loaded) appeared first on Liliputing.

Final Fantasy Exploit Teaches 32-bit Integer Math

Hackaday - พุธ, 09/19/2018 - 18:00

One of the fun things about old video games, besides their obvious nostalgia, is that some of the more popular games have been pried apart and tinkered with for years, leading to a lot of new “development” within the games. This often uncovers some hidden gems that gamers might not have had any knowledge of during the game’s heyday, like this coding oddity found in Final Fantasy 7 that illustrates a lot about how 32-bit processors do math.

The original PlayStation used a 32-bit RISC processor, but the most significant bit could be used for integer signing. This means that if you have an integer that has a value of 2,147,483,647 (01111111111111111111111111111111 in binary) and you add one, the value is suddenly negative 2147483648 because the most significant digit is also an indicator of the integer’s sign. In this situation, the integer is said to “overflow”. In Final Fantasy 7, if you can somehow get a character to deal 262,144 damage in one hit (much less than two billion, due to the way the game does damage calculations), the game has a little bit of a meltdown.

[4-8Productions] had to do a lot of work to show how this glitch can be exploited in the game as well. Usually damage in this game is limited to 9,999 but under certain configurations (admittedly obtained by using other exploits and tools available for FF7 like a savegame editor) two of the characters can deal more damage than this critical value, exposing the 32-bit processor’s weak spot.

Even though integer signing is a pretty basic concept for most of us, the video is definitely worth a watch especially if you’re fans of the classic game. Of course, Final Fantasy 7 isn’t the only classic that has been exploited and reverse-engineered to the extreme. You can use a Super Mario World level to implement a calculator now, too.

Visual Schematic Diffs in KiCAD Help Find Changes

Hackaday - พุธ, 09/19/2018 - 15:00

When writing software a key part of the development workflow is looking at changes between files. With version control systems this process can get pretty advanced, letting you see changes between arbitrary files and slices in time. Tooling exists to do this visually in the world of EDA tools but it hasn’t really trickled all the way down to the free hobbyist level yet. But thanks to open and well understood file formats [jean-noël] has written plotgitsch to do it for KiCAD.

In the high(er)-end world of EDA tools like OrCAD and Altium there is a tight integration between the version control system and the design tools, with the VCS is sold as a product to improve the design workflow. But KiCAD doesn’t try to force a version control system on the user so it doesn’t really make sense to bake VCS related tools in directly. You can manage changes in KiCAD projects with git but as [jean-noël] notes reading Git’s textual description of changed X/Y coordinates and paths to library files is much more useful for a computer than for a human. It basically sucks to use. What you really need is a diff tool that can show the user what changed between two versions instead of describe it. And that’s what plotgitsch provides.

plotgitsch’s core function is to generate images of a KiCAD project at arbitrary Git revisions. After that there are two ways to view the output. One is to generate images of each version which can be fed into a generic visual diff tool (UNIX philosophy anyone?). The documentation has an example script to help facilitate setting this up. The other way generates a color coded image in plotgitsch itself and opens it in the user’s viewer of choice. It may not be integrated into the EDA but we’ll take one click visual diffs any day!

Soldering Like It’s 205 BC

Hackaday - พุธ, 09/19/2018 - 12:00

Did you ever stop to think how unlikely the discovery of soldering is? It’s hard to imagine what sequence of events led to it; after all, metals heated to just the right temperature while applying an alloy of lead and tin in the right proportions in the presence of a proper fluxing agent doesn’t seem like something that would happen by accident.

Luckily, [Chris] at Clickspring is currently in the business of recreating the tools and technologies that would have been used in ancient times, and he’s made a wonderful video on precision soft soldering the old-fashioned way. The video below is part of a side series he’s been working on while he builds a replica of the Antikythera mechanism, that curious analog astronomical computer of antiquity. Many parts in the mechanism were soldered, and [Chris] explores plausible methods using tools and materials known to have been available at the time the mechanism was constructed (reported by different historians as any time between 205 BC and 70 BC or so). His irons are forged copper blocks, his heat source is a charcoal fire, and his solder is a 60:40 mix of lead and tin, just as we use today. He vividly demonstrates how important both surface prep and flux are, and shows both active and passive fluxes. He settled on rosin for the final joints, which turned out silky smooth and perfect; we suspect it took quite a bit of practice to get the technique down, but as always, [Chris] makes it look easy.

If you’d like to dig a bit deeper into modern techniques, we’ve covered the physics of solder and fluxes in some depth. And if you need more of those sweet, sweet Clickspring videos, we’ve got you covered there as well.

Super Magnesium: Lighter Than Aluminum, Cheaper Than Carbon Fiber

Hackaday - พุธ, 09/19/2018 - 09:00

We think of high tech materials as the purview of the space program, or of high-performance aircraft. But there are other niche applications that foster super materials, for example the world of cycling. Magnesium is one such material as it is strong and light, but it has the annoying property of burning in its pure state. Alloys of magnesium meanwhile generally don’t combust unless they are ground fine or exposed to high temperatures. Allite is introducing a new line known as “super magnesium” which is in reality three distinct alloys that they claim are 30% lighter than aluminum, as well as stronger and stiffer than the equivalent mass of that metal. They also claim the material will melt at 1200F instead of burning. To lend an air of mystique, this material was once only available for defense applications but now is open to everyone.

It’s a material that comes in three grades. AE81 is optimized for welding, ZE62 is better suited for forging, while WE54 is made for casting processes. Those names might sound like made up stock numbers, but they aren’t, as magnesium allows typically have names that indicate the material used to mix with the magnesium. A stands for aluminum, Z is for zirconium zinc, W is for yttrium, and E stands for rare earths. So AE81 is a mix of magnesium, aluminum, and some rare earth material. The numbers indicate the approximate amount of each addition, so AE81 is 8% aluminum and 1% rare earth.

Previously, flame retardant magnesium had calcium added to the mix which raised the burn temperature significantly. There remains a widespread perception that magnesium alloys easily burn, but that’s because elemental magnesium burns spectacularly. Typical alloys can burn, but fortunately for us that doesn’t happen at temperatures under 800F with these alloys in a solid piece of metal although powders or ribbons may burn more easily. According to the company, normal machining works well and requires less power than machining with other metals.

IF you want to see a big magnesium alloy forge, check out the Mesta. If you want to make your own wheels, maybe you should stick to aluminum for now.

Robotic Fruit Fly Won’t Eat Your Fruit

Hackaday - พุธ, 09/19/2018 - 06:00

The DelFly project has been busy since the last time we checked in on them. The Dutch team started 13 years ago and produced the smallest camera-carrying drone, and an autonomous tiny ornithopter. However, that ornithopter — now five years old — had to use some traditional control surfaces and a tail like an airplane which was decidedly not fruit fly-like. Now they’ve solved those problems and have announced the DelFly Nimble, a 13 inch and 1-ounce ornithopter. You can see the Nimble in the video below.

The close emulation of a real fly means the thing looks distinctly insect-like in flight. The dual wings use Mylar and form an X configuration. They flap about 17 times per second. A fully charged battery  — remember, the whole thing weighs an ounce — lasts five minutes. With an efficient speed of 3 meters per second, the team claims a flight range of over 1 kilometer with a peak speed that can reach  7 meters per second. It can even take a payload, as long as that payload weighs 4 grams or less.

The tiny robot has two rotary servo actuators, one for each pair of wings, along with two flapping mechanisms. There are a lot of technical details on their website, but it caught our eye that the flight computer is an STM32 microcontroller.

We assumed this had some sort of spy application, but DelFly says they want to use the machine to study insect flight dynamics. We’ll take that at face value.

If you want to see the previous revision which clearly had an airplane tail and control surfaces, we looked at it earlier. If you are wondering what the world looks like to an autonomous fruit fly, we can help with that, too.

Photos courtesy of TU Delft, CC BY-SA 4.0

#FreePCB via Twitter to 2 random RTs

dangerous prototype - พุธ, 09/19/2018 - 05:52

Every Tuesday we give away two coupons for the free PCB drawer via Twitter. This post was announced on Twitter, and in 24 hours we’ll send coupon codes to two random retweeters. Don’t forget there’s free PCBs three times a every week:

  • Hate Twitter and Facebook? Free PCB Sunday is the classic PCB giveaway. Catch it every Sunday, right here on the blog
  • Tweet-a-PCB Tuesday. Follow us and get boards in 144 characters or less
  • Facebook PCB Friday. Free PCBs will be your friend for the weekend

Some stuff:

  • Yes, we’ll mail it anywhere in the world!
  • Check out how we mail PCBs worldwide video.
  • We’ll contact you via Twitter with a coupon code for the PCB drawer.
  • Limit one PCB per address per month please.
  • Like everything else on this site, PCBs are offered without warranty.

We try to stagger free PCB posts so every time zone has a chance to participate, but the best way to see it first is to subscribe to the RSS feed, follow us on Twitter, or like us on Facebook.

Lilbits 337: Samsung’s first phone with 3 rear cameras

Liliputing - พุธ, 09/19/2018 - 04:30

Rumor has it that Samsung will slap three cameras on the back of the Galaxy S10 smartphone due to hit the streets in 2019. But it looks like that won’t be the company’s first phone with a triple camera system on the back. Roland Quandt spotted some pictures of the upcoming Samsung Galaxy A7 (2018) […]

The post Lilbits 337: Samsung’s first phone with 3 rear cameras appeared first on Liliputing.

This dual-screen phone has displays on the front and back

Liliputing - พุธ, 09/19/2018 - 03:30

There have been a handful of dual-screen smartphones over the years. The ZTE Axon M is a dual-screen phone that gives you an almost tablet-sized screen when unfolded. The Yota 3 has a full color screen on the front and an energy-efficient E Ink display on the back for reading eBooks or viewing persistent images […]

The post This dual-screen phone has displays on the front and back appeared first on Liliputing.

Epic Clock Clocks The Unix Epoch

Hackaday - พุธ, 09/19/2018 - 03:00

Admit it: when you first heard of the concept of the Unix Epoch, you sat down with a calculator to see when exactly 2³¹-1 seconds would be from midnight UTC on January 1, 1970. Personally, I did that math right around the time my company hired contractors to put “Y2K Suspect” stickers on every piece of equipment that looked like it might have a computer in it, so the fact that the big day would come sometime in 2038 was both comforting and terrifying.

[Forklift] is similarly entranced by the idea of the Unix Epoch and built a clock to display it, at least for the next 20 years or so. Accommodating the eventual maximum value of 2,147,483,647, plus the more practical ISO-8601 format, required a few more digits than the usual clock – sixteen to be exact. The blue seven-segment displays make an impression in the sleek wooden case, about which there is sadly no detail in the build log. But the internals are well documented, and include a GPS module and an RTC. The clock parses the NMEA time string from the satellites and syncs the RTC. There’s a brief video below of the clock in action.

We really like the look of [Forklift]’s clock, and watching the seconds count up to the eventual overflow seems like a fun way to spend the next two decades. It’s not the first Epoch clock we’ve featured, of course, but it’s pretty slick.

Syndicate content