Ketan's Home

September 29, 2018

Laser Noob: Getting Started With the K40 Laser

Filed under: Uncategorized — ketan @ 10:36 AM

Why spend thousands on a laser cutter/engraver when you can spend as little as $350 shipped to your door? Sure it’s not as nice as those fancy domestic machines, but the plucky K40 is the little laser that can. Just head on down to Al’s Laser Emporium and pick one up.  Yes, it sounds like a used car dealership ad, but how far is it from the truth? Read on to find out!

Laser cutting and engraving machines have been around for decades. Much like 3D printers, they were originally impossibly expensive for someone working at home. The closest you could get to a hobbyist laser was Epilog laser, which would still cost somewhere between $10,000 and $20,000 for a small laser system. A few companies made a go with the Epilog and did quite well – notably Adafruit used to offer laptop laser engraving services.

Over the last decade or so things have changed. China got involved, and suddenly there were cheap lasers on the market. Currently, there are several low-cost laser models available in various power levels. The most popular is the smallest – a 40-watt model, dubbed the K40. There are numerous manufacturers and there have been many versions over the years. They all look about the same though: A blue sheet metal box with the laser tube mounted along the back. The cutting compartment is on the left and the electronics are on the right. Earlier versions came with Moshidraw software and a parallel interface.

The K40 mechanics haven’t changed very much, but the electronics have been updated to USB with modern stepper drivers. Make no mistake, these are not “quality” machines. They are built down to a cost. Interlock switches are non-existent. Overheat protection for the tube is your problem. Low cooling water flow alarm? Nope, better keep an eye on that yourself. The cutting bed looks like a mixture of an afterthought and parts someone found in the spares bin. The exhaust duct is routed 3 inches into the cutting area. In other words, these are the perfect machines for a hacker.

I’ve been watching the K40 and similar machines on eBay for years. Originally these machines were shipped from China. It was a crapshoot if a large heavy gas filled glass tube would survive the trip halfway around the world. Now, many of the machines are shipping from California and other ports within the lower 48 states. I’m guessing the machines are shipped to a warehouse here in the USA, tested, then the good units are sent on to customers.

With all this in mind, I finally decided to jump in and get a K40 laser. My first problem was deciding which laser to buy. eBay and Alibaba are riddled with auctions from sellers with different versions of the K40. Everyone says they’re newer and better than the rest. Some boast different accessory packages, and things like air assist – but also cost more. There is enough information to throw even the most seasoned eBayer into analysis paralysis mode.

In the end, I decided to go with one of the cheaper (but not the cheapest) lasers with a digital front panel display. My model also came with a temperature readout for the cooling water, and wheels – for those who like to roll their benchtop lasers around.

I clicked the “buy it now” button and started waiting. The machine in its 62 lb crate would take about a week to ship from the west coast. That gave me plenty of time to order some safety equipment.

Laser Safety

While the K40 may be cheap, I didn’t want to skimp on safety equipment. There are many vendors for laser safe goggles online. There are plenty of them available from China, but I really didn’t want to risk my eyes to a company I had never heard of. I did some checking around and ended up ordering a pair manufactured by Honeywell. Amazon had them available on Prime, so they got to me before the K40 itself. Whichever pair you order, make sure they are rated for CO2 lasers. There are many types of lasers out there, and goggles meant to protect you from a UV medical laser won’t help much at all when it comes to an IR laser like the one in the K40. IR safe glasses will be clear, or nearly so. But don’t mistake them for bog standard safety glasses. These are specially made materials which will help keep you safe from the invisible blindness beam your K40 puts out when your other safety measures fail.

Lasers burn things, and it is unfortunately common for those things to catch fire inside the laser. I’m keeping a large ABC dry powder fire extinguisher near the printer. However, that’s only a stopgap. If you’ve ever had to use a powder extinguisher, you know how messy they are. To try to keep the K40 and the rest of my lab safe, I’m planning to invest in a gas extinguisher of some type. Either CO2 or Halotron, depending on which is safer for use in a basement room.

While I never plan to leave the laser running unattended, I also have smoke detectors in my lab. Finally, I added a carbon monoxide detector to make sure the K40 doesn’t fill the room with a silent killer.

Unboxing

Hackaday doesn’t do unboxing videos, but the impression I got while unpacking the K40 was that it is big – bigger than one would imagine from the photos. My machine measured 32″ wide x 19.75″ deep x 10.25″ high. Thankfully I had workbench space right near a window that made a perfect home.

Cooling

The K40 laser is water cooled. All the lasers include a coolant pump as one of the accessories. The pump I received is a wonder of cost reduction. It’s an aquarium or pond pump, with a magnetically coupled impeller. I was concerned when after use I saw water dripping out of the pump down the 120 V power cord. It turns out the back cover of the pump isn’t even sealed. It doesn’t need to be. The motor stator and coils are potted in black epoxy. As long as that potting compound is in place, nothing can get to the motor. It does seem to work well for keeping the cooling water flowing. However, I can’t say I completely trust it with the life of my laser tube. A mod may be in the future for this system.

For coolant, I’m using distilled water. My reservoir for these early tests is a simple shoebox-sized plastic container. It holds a gallon of water and keeps the pump submerged. If the laser isn’t going to be used for a few days, I dump the water and empty the tube by blowing into the inlet line.

Exhaust

Cutting things with a laser will produce smoke and fumes; that’s a given. The K40 comes with an exhaust fan which is rather anemic, to say the least. It’s literally a bathroom exhaust fan slapped on the back of the laser. Smoke is pulled through a slot cut in the back of the case and sent up the exhaust hose. I already have a large Dayton fan mounted in the window of my lab. While the unguarded blades are decidedly dangerous, it moves a crazy amount of air. This coupled with the stock exhaust fan was able to keep the smell of burning wood and plastic down to reasonable levels. However, I’ll definitely be upgrading the stock exhaust in the future.

Aligning The Optics

The first step in setting up one of these lasers is arguably the most dangerous: aligning the mirrors. This is why I bought good laser goggles. Working on the laser with the doors off is something you generally don’t want to do since you can’t control where the beam goes.

Keep the laser safety glasses on at all times, close the door, and make sure no one else walks into the room. My tube was so far out of alignment that the beam exited the case through the open door and made a small scorch mark on the wall behind my workbench. It would not have been good if someone else was standing there.

There are plenty of video tutorials out there for aligning the mirrors on a K40. I found this one to be particularly helpful. The idea is to make sure that the laser dot hits the center of each of the three mirrors in the beam path. Two of the mirrors move on an X-Y table, so it’s important to make sure the beam hits the same spot no matter where they are positioned. I used Post-it notes rather than the painter’s tape many of the tutorials call for. It’s much easier to see the burn mark on the yellow Post-It than on the dark blue tape.

You don’t need a computer for these steps, just keep the stepper motors off and move the table by hand. When it comes time to fire the laser, you just have to tap the test button on the front panel.
The first thing to align is the tube itself. My tube was so far out of alignment that the beam wasn’t even hitting the mirror. The tube is held in with two metal spring straps. Rubber rings keep the straps from breaking the glass tube. More rubber acts as shims to align the tube vertically. I removed one of the shims from the left side of the tube and added it to the right. It’s a fiddly procedure since tightening too hard on the screws will break the single most expensive part of the K40 – the laser tube.

I found that even after an alignment, my K40 still wasn’t performing correctly. I cleaned the mirrors and the laser tube with alcohol, but it was no help. Finally, I disassembled the focusing head. That’s where I found my problem. There were bits of metal inside the head from when it was machined. These metal pieces were in the beam path, disrupting it. I took the 45-degree mirror and the focusing lens out, then carefully cleaned the tube. Once everything was re-assembled, my K40 was ready for action.

Software

The laser comes with an obviously burned CD and a USB stick. My laptop doesn’t have a CD drive, so I popped in the USB stick and found… nothing. It’s not really a drive, but a dongle to unlock the laser driver software. I had to go and find my USB cd drive before using the K40. Most of the filenames on the disc are in Chinese. Some digging eventually led me to a file for Corel Laser. It’s a copy of Corel Draw with a plugin to drive the K40. The copy of Corel Draw is almost certainly an illegal cracked copy. I got access to a legit base copy from a friend who switched over to Adobe.

In simple terms, CorelLaser gives you a toolbar and can cut or engrave any image loaded into Corel Draw. Cutting and engraving are very different processes though. Cutting is a vector operation. The laser will trace the path of every line in the image. Engraving is a raster affair. The laser will draw the image line by line, left to right and top to bottom. You can also perform both processes on the same design by creating a cut layer and an engraving layer in the software.

I ran into trouble with the software pretty quickly. Whenever I tried to cut, the laser head moved slowly. Changing the movement settings didn’t help. Some digging eventually pointed me to the settings page for CorelLaser. Here I found the “mainboard” setting was wrong. The value has to match the model number silk screened on the laser mainboard. Of course, the mainboard is mounted in such a way that you can’t read the model number, but a quick cell phone photo fixed that problem. My model is 6C6879-LASER-M2. The board firmware is dated 2018-01-08, so the board must have been built sometime after that.

I expected CorelLaser to be a hot mess. Honestly, it isn’t half bad. It definitely has some maddening quirks, but overall it does what it should – drive the steppers and switch the laser. The top quirk I’ve found is line width. Corel defaults to “hairline” as line width. This is larger than the laser kerf, so CorelLaser interprets it as two parallel paths. Tracing two close paths on with the K40 will make a wide burning mess of whatever you’re trying to cut. The solution is to select everything in your document <Ctrl-A> then hit F12, and change the line width to .001 mm. CorelLaser will then operate as you expect it to.

Which Materials to use (and which to avoid)

What to cut? As with any laser cutter, thought has to be given to the materials being cut. In general, wood is safe to cut, as is paper, cloth, melamine, pressboard, matte board, cork, some rubbers, natural leather, and Corian. Engraving can be performed on materials such as glass, stone, anodized aluminum, steel (with a laser engraving coating) and other materials.

Some plastics should never be cut in a laser cutter. Anything with chlorine – notably PVC and vinyl. Burning PVC results in chlorine gas, which will kill the user, and hydrochloric acid, which will rust your K40 out so bad that your next of kin won’t be able to enjoy it. A simple test for chlorine is the copper wire burnination test, which can be seen in this 10-year-old video from [Adam] and [Zach] at NYC Resistor. ABS plastic is another one to avoid. It tends to melt and is messy to cut. It also releases trace amounts of cyanide gas. If you’re ever unsure about a material, look up on the pages of hackerspaces who have lasers. If they won’t cut it on their laser, you probably shouldn’t either.

Cutting and Engraving

Cutting and engraving are what we’re all here for, right? The fun part of learning the laser is figuring out how to set up the software for different materials. With a laser, you have three variables to play with. Laser power, speed, and the number of passes. Laser power is controlled by the front panel of the K40. It’s either a knob and an inaccurate milliampere meter or a digital control expressed in power percentage. Cutting with more than one pass is messier than just cutting the material once, so save that for when you really need to do it.

There are a few guides out there – I’ve found this page to be a good starting point for figuring out which speeds and power levels to run at for a given material. I generally will use the speed from that site, then start at a much lower laser power. Testing on scrap pieces, I’ll keep raising the power until I have a clean cut. If the power is below 50%, I’ll generally stick with it, and not adjust the speed.

You should definitely keep notes of what you use. On my laser, I found a deep engrave on ⅛” acrylic at 50% and 320 mm/s. Cutting ⅛” birch plywood worked best at 25% power and 5 mm/s. Keep in mind that quality control on the K40 is non-existent, and beam focus will matter, so your device may be different from mine. Further, materials such as plywood and acrylic can change from batch to batch depending on moisture content and other variables. Always buy some extra material to use as scrap for dialing in your settings.

Performance

So how good is the K40 in a “bone stock” condition? Pretty damn good actually. I was able to cut ⅛” birch plywood and ⅛” acrylic with one pass at less than 50% power. The parts would literally fall out as each cut complete. This is a laser, so of course, there is some charring of the wood on the edges, but nothing a bit of sandpaper can’t fix. As a torture test, I took the Hackaday logo .svg file loaded it up into CorelLaser, set the line width to .001 mm, and hit go. The K40 dutifully cut out the jolly wrencher, giving me a little puzzle of pieces to try to fit back together.
Engraving performance was good too – I was able to cut simple black and white images (and text) into wood and acrylic. I can see how this would be perfect for making control panels with labeled lights and switches.

Summary

The K40 is a cheap laser engraver/cutter. However, it is very capable, even when used unmodified. That said, the cutter is a great platform for modification. You can bet I’ll be spending some time adding things like air assist and a better bed to my K40 as well as cutting down that exhaust duct.

from Hack a Day https://ift.tt/2DAm3dA

Article: Modeling Uncertainty With Reactive DDD

Filed under: Uncategorized — ketan @ 10:22 AM

Vaughn Vernon has written several books on DDD and reactive messaging patterns, and has found that the nature of distributed systems means you must deal with uncertainty. How to respond to a missing message, or a message that is received twice, should be a business decision, and therefore must be part of the domain model.

By Vaughn Vernon

from InfoQ https://ift.tt/2y0l7tb

September 27, 2018

Self-Solving Rubik’s Cube

Filed under: Uncategorized — ketan @ 7:14 AM

Self-Solving Rubik’s Cube

Rubik’s Cube has been around for what seems like forever now, and has spawned an entire subculture devoted to solving the puzzle with automation. Most Rubik robots put the cube in a specially designed cradle bristling with actuators and sensors, and while those rigs are impressive, they don’t come close to this robotic Rubik solver built into the cube itself.

Fair warning that [Human Controller] doesn’t provide much detail on this build other than pictures; even translating the Japanese web page doesn’t offer much more information. But there are pictures, plus the video below, which reveal the engineering masterpiece encased within the standard sized Rubik’s cube. The internal mechanism of the original cube had been replaced by a spherical assembly around which the cube’s faces rotate. The sphere, which appears to be 3D-printed, houses six motors and gear trains, along with a microcontroller board and what appear to be Hall sensor boards to detect the position of each face. Everything is wired up with magnet wire to keep bundles to a minimum size, and buried deep inside is a LiPo battery pack. A disassembly video offers further clues to this ingenious device’s inner workings.

Once the cube senses that it has been scrambled, it sets to work on the solution, walking all over the table in the process. It’s clearly not just recording the scrambling steps and playing them back in reverse; the video below shows far more moves to solve the cube than the 15 it took to scramble it.

While we’re always impressed by marvels of speed like this robot with a 637 millisecond solve time, putting everything needed to solve the cube inside it is a feat worth celebrating. Here’s hoping that a build log shows up soon to satisfy our need for details.

Thanks to [jackw01] and [rasz_pl] for the heads up.

from Hack a Day https://ift.tt/2zr8JnS

September 26, 2018

Improve Your Code Coverage With Lombok @Data

Filed under: Uncategorized — ketan @ 10:37 PM

Problem

On my previous project, we had a problem achieving code coverage with Jacoco. Lombok was used extensively on the project, and each time we added a new domain object, we were losing precious code coverage percentages.

So, what was happening?

We were using @lombok.Data for generating equals/hashCode /toString methods for Java beans. The problem was that the code coverage tool was marking this method as uncovered. So, instead of having a Java bean with full code coverage, we ended up with around 15 percent coverage per Java bean. Adding new beans just made an already bad situation even worse.

Solution

Different solutions were proposed on how to fix this problem. One of them was using a third-party library to “cover” all equals/ hashCode/toString methods generated by Lombok. We’ve seen this solution being used on similar projects, but since we founded it was a dirty fix, we didn’t want to use it in our case. The solution we finally chose was actually very simple.

In the 0.8.0 release, Jacoco added support for filtering out all methods annotated with @lombok.Generated from their reports. The only thing we needed to do was tell Lombok to add the @lombok.Generated annotation to its generated methods.

In order to fix the issue, we added lombok.config file to the root of our project. The file had the following content:

  • config.stopBubbling = true is telling Lombok that this is the root directory and that it shouldn’t search parent directories for more configuration files (you can have more than one lombok config files in different directories/packages).
  • lombok.addLombokGeneratedAnnotation = true is telling Lombok to add the @lombok.Generated annotation to all generated methods.

And, that’s it. After applying the given changes, Jacoco was filtering out Lombok auto-generated methods, code coverage was back to normal, and everybody was happy again!

from Javalobby https://ift.tt/2Q6uizF

September 20, 2018

Soldering Like It’s 205 BC

Filed under: Uncategorized — ketan @ 7:20 AM

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.

from Hack a Day https://ift.tt/2QGG0ly

September 15, 2018

Easy Portable Serial Ports

Filed under: Uncategorized — ketan @ 2:34 PM

Modern operating systems insulate us — as programmers, especially — from so much work. Depending on how far back you go, programmers had to manage their own fonts, their own allocation space on mass storage, or even their own memory allotments. Every year, though, it seems like things get easier and easier. So why is it so annoying to open a simple serial port? It isn’t hard, of course, but on every operating system it seems to be painful — probably in an attempt to be flexible. And it is even worse if you want portability. I needed to write some C code that read data from an FPGA’s embedded logic analyzer, and I was annoyed at having to write yet more serial port code. I have my own shim library, but it isn’t well tested and isn’t all that flexible — it does what I need, but I wanted something better. What I wound up with the serial library from Sigrok. You know Sigrok? The logic analyzer software.

 You might counter that the serial port is old hat, so no one wants to support it with modern systems. While the physical serial port might be on life support, there’s no shortage of equipment that connects via USB that appears to be a serial port. So while I was talking to an FTDI chip on an FPGA board, you could just as well be talking to an Arduino or a USB voltmeter or anything.

I guess the Sigrok developers had the same problem I did and they took the time to write a nice API and port it to major platforms. Although Sigrok uses it, they maintain it as a separate project and it was just what I needed. Sort of. I say sort of because the version installed with Ubuntu was old and I needed some features on the newest release, but — as usual — the Internet came to the rescue. A quick Git command, and four lines of build instructions and we were ready to go.

Getting Started

Since I use Linux, the build instructions on the page worked fine. The install goes into /usr/local so I removed the libserialport-dev package just to be sure I didn’t get the wrong one by mistake.

The library provides a header file, libserialport.h. That file defines an sp_port type that is opaque. Since you don’t know the size of it, you can only create a pointer to it. You can get the pointer filled in by calling sp_get_port_by_name. You can also have the library give you a list of ports available. Once you have the port you can open it. There are simple calls for setting most things, but you usually only need to call sp_set_baudrate.

There’s also simple calls for doing blocking and non-blocking reads and writes and figuring out if there are characters waiting to be read.

My Example

I wound up writing about 50 lines of code to ping the analyzer with two commands and pull the data out to the terminal. You can find it below. It was just quick and dirty — I didn’t try to optimize the reads or anything.

I doubt you’ll implement my code since you don’t have the logic analyzer. I will share that eventually in another post, though. But if you do want to have a go, you could easily code an Arduino to pick up two bytes on the serial port and then dump out 4,096 bytes.

Of course, this wasn’t my final code, but it shows how easy it was to write some portable code to work with the serial port.


// WordPress loves to eat angle brackets, so if the 3 includes below are blank
// they are: stdio.h stdlib.h and libserialport.h
#include <stdio.h>
#include <stdlib.h>
#include <libserialport.h>

#define BAUD 9600
// Commands to LA
#define USERCMD_RESET 0
#define USERCMD_RUN 1


int main(int argc, char *argv[])
{
  struct sp_port *port;
  int err;
  int i,cmd;
  int count=4096;
// We need a serial port name
  if (argc<2)
    {
    fprintf(stderr,"Usage la port\n");
    exit(1);
    }
// Open serial port
  err=sp_get_port_by_name(argv[1],&port);
  if (err==SP_OK)
  err=sp_open(port,SP_MODE_READ_WRITE);
  if (err!=SP_OK)
    {
    fprintf(stderr,"Can't open port %s\n",argv[1]);
    exit(2);
    }
// set Baud rate
  sp_set_baudrate(port,BAUD);

// write reset
  cmd=USERCMD_RESET;
  sp_blocking_write(port,&cmd,1,100);
// write run
  cmd=USERCMD_RUN;
  sp_blocking_write(port,&cmd,1,100);
// read data 
  for (i=0;i<count;i++) 
    {
    int waiting;
    int c=0;
    do 
      {
      waiting=sp_input_waiting(port);
      } while (waiting<=0);
// sort of inefficient -- could read a bunch of bytes at once
// could even block for all of them at once
    sp_nonblocking_read(port,(void *)&c,1);
    if (i%16==0) putchar('\n');
    printf("%02X ",c);
    }
  putchar('\n');
  sp_close(port);
  return 0;
}

Portability and Support

The library works on Linux, Mac, FreeBSD, Windows and Android. No Commodore 64 or VAX support, but we can let that slide. It is well documented, too. You might wonder what the big deal is. Well, let’s take a little detour. Keep in mind that you may have a favorite library that hides a lot of this from you and that’s great. Maybe it is even cross-platform, at which point that’s great, too. But I’m talking using the OS’s native API.

Linux borrows heavily from Unix so it things serial ports might just be modems or teletypes. That means there are dozens and dozens of obscure options for serial ports, mostly in the wacky termios structures. Everything is a file, so opening the port isn’t that stressful. You do have to decide if you want to set strange bits like O_NOCTTY and O_NDELAY. Oh, and you probably want to tell the port not to hang if no data is available by setting the FNDELAY bit which is via another API call. Plus set the baud rate.

I won’t bore you with all the exact code, but if you really want an idea of what’s involved, here’s a pretty good reference. Just remember the benign code to open the port is just the tip of the iceberg. Keep reading at least until Chapter 3.

Windows isn’t much better. The actual API interface is similar — but not the same — as the Linux code. You create a file almost in the usual way. But then you get a device control block (DCB) and fill it all in to configure the port. Want timeouts? That’s another call. There’s a whole different API for non-blocking I/O although you have a few choices there. There’s also EscapeCommFunction to do other odd things.

None of this is that hard and, in fact, Windows is a bit easier only because it is less flexible. But it is very easy to just use one portable open source library.

Going Forward

Next time you want to talk serial with a PC using any language that can call a library, you ought to consider this one. Even if you don’t need the portability, it is a pleasant enough API and you don’t have to switch gears later if you do port or if you just start a different project.

If you don’t like it, there are other choices. A quick search turned up a C++ library that supports Windows, Linux, and Mac. Some popular libraries like Boost for C++ have serial port handlers, too. Here’s a simple C-language library that is pretty minimal. There are doubtless others and I’d imagine the comments will turn up a few gems, as well.

Photo Credit: Fun with VMWare by [Bill Bradford] CC-By-2.0.

from Hack a Day https://ift.tt/2NfRRsH

September 13, 2018

Automagic Tool makes KiCAD Schematic Symbols from PDFs

Filed under: Uncategorized — ketan @ 7:25 AM

Automagic Tool makes KiCAD Schematic Symbols from PDFs

Last time we talked about a KiCAD tool it was to describe a way to make the zen-like task of manual assembly more convenient. But what about that most onerous of EE CAD tasks, part creation? Home makers probably don’t have access to expensive part library subscriptions or teams of people to create parts for them, so they are left to the tedium of creating them by hand. What if the dream tool existed that could read the darn PDF by itself and make a part? It turns out [Sébastien] made that tool and it’s called uConfig.

uConfig has a pretty simple premise. It scrapes manufacturer datasheets in PDF form, finds what it thinks are diagrams of parts with pin names, functions, etc, and emits the result as parts in a KiCAD library. To aid in the final conversion [Sébastien] added rules engine which consume his custom KiCAD Style Sheets which specify how to categorize pins. In the simple case the engine can string match or use regex to let you specify things like “all pins named VDD[A-C] should be power pins”. But it can also be used to move everything it thinks belongs to “GPIOB” and stick them on the bottom of the created symbol. We could imagine features like that would be of particular use breaking out gigantic parts like a 400 ball BeagleBone on a chip.

Thanks for the tip [arturo182]!

from Hack a Day https://ift.tt/2OauTzx

September 12, 2018

Article: Microservices in a Post-Kubernetes Era

Filed under: Uncategorized — ketan @ 7:49 AM

The microservice architecture is still the most popular architectural style for distributed systems. But Kubernetes and the cloud native movement has redefined certain aspects of application design and development at scale. Modern developers must be fluent in a programming language to implement the business functionality, and equally fluent in cloud native technologies.

By Bilgin Ibryam

from InfoQ https://ift.tt/2C8zTDi

The Customer is Not Always Right and Neither Are You

Filed under: Uncategorized — ketan @ 7:19 AM

At the recent Agile 2018 conference Natalie Warnert gave a talk titled "The customer is not always right, and neither are you!” in which she gave the audience thought provoking concepts in how to make sure we are building the right thing. She presented three traps that teams fall into – incorrect customer, premature solution and drowning in data and provided advice on how to avoid them.

By Angela Wick

from InfoQ https://ift.tt/2NgrCS3

September 11, 2018

Temperature Controlled Fan Keeps Printer Cool

Filed under: Uncategorized — ketan @ 8:41 PM

There are many annoying issues associated with desktop 3D printers, but perhaps none are trickier than keeping the machine at the proper temperature. Too cold, and printed parts can warp or fail to adhere to the bed. Too hot, and the filament can get soft and jam, or the motors will start clanking and missing steps. High-end industrial 3D printers have temperature-controlled enclosures for precisely this reason, but the best you can hope for with a printer that’s little more than some aluminum extrusion and an Arduino is a heated bed that helps but is no substitute for the real thing.

Like many 3D printer owners chasing perfect prints, [Stephen Thone] ended up putting his machine into a DIY enclosure to help keep it warm. Unfortunately, there gets to be a point when things get a little too hot inside the insulating cube. To address this issue, he put together a simple but very elegant temperature controlled fan to vent the enclosure when the internal conditions go above the optimal temperature.

[Stephen] picked up the digital temperature controller on Amazon for about $4 USD, and found a 60mm fan in the parts bin. He then came up with a clever two-part printed enclosure that slides together to make the fan and controller one unit which he can place in a hole he cut in the enclosure.

A lot of attention was paid to the front panel of the device, including mid-print filament swaps to create highlighted text and separate buttons printed in different colors. The end result is a very professional looking interface that involved relatively little manual labor; often a problem when trying to come up with nice looking panels.

Whether it’s to keep from breathing ABS fumes, or to quiet the thing down enough so you can get some sleep, it looks like an enclosure of some type is becoming the latest must-have 3D printer accessory.

from Hack a Day https://ift.tt/2MmiDdv

Older Posts »

Create a free website or blog at WordPress.com.