Ketan's Home

March 16, 2020

3D Printed Parts Keep Respirators Operational During COVID-19 Epidemic

Filed under: Uncategorized — ketan @ 12:50 PM

COVID-19 can seem like a paper tiger, when looking at bare mortality rates. The far greater problem is the increase in fatalities as health systems are stretched to the limit. With thousands of patients presenting all at once, hospitals quickly run out of beds and resources and suddenly, normally survivable conditions become life threatening. One Italian hospital found themselves in such a position, running out of valves for a critical respirator device needed to save their patients. Supplies were running out – but additive manufacturing was able to save the day.

The original part, left, with its 3D-printed replacement.

While the article uses the term “reanimation device”, it’s clear we’re talking about respirators here, necessary to keep patients alive during respiratory distress. The valve in question is a plastic part, one which likely needs to be changed over when the device is used with each individual patient to provide a sterile flow of air. After the alarm was raised by Nunzia Vallini, a local journalist, a ring around of the 3D printing community led to a machine being sent down to the hospital and the parts being reproduced. Once proven to work, things were stepped up, with another company stepping in to produce the parts in quantity with a high-quality laser fusion printer.

It’s a great example of 3D printers being used to produce actual useful parts, and of the community coming together to do vital lifesaving work. We’ve seen the technology come in clutch in the medical field before, too. Stay safe out there, and live to hack another day.

Thanks to [Jarno Burger], [LuigiBrotha], and [Michael Hartmann] for the tips!

from Hack a Day https://ift.tt/38NaIkU

February 19, 2020

Announcing Spring Cloud Stream Horsham.SR2 (3.0.2.RELEASE) and Spring Cloud Hoxton.SR2

Filed under: Uncategorized — ketan @ 7:33 AM

We are pleased to announce the release of the Spring Cloud Stream Horsham.SR2 (3.0.2.RELEASE) release train which is available as part of Spring Cloud Hoxton.SR2 (just released) and builds on Spring Boot 2.2.4 and Spring Cloud Function 3.0.2.RELEASE which was also just released.

Spring Cloud Stream Horsham.SR2 modules are available for use in the Maven Central repository.

This release contains several fixes and enhancements primarily driven by user’s feedback, so thank you.
For more details please follow these links:
Spring Cloud Stream Core
Spring Cloud Stream Core Rabbit Binder
Spring Cloud Stream Core Kafka Binder
Spring Cloud Function

As mentioned, Spring Cloud Hoxton.SR2 was also released, but it only contains updates to Spring Cloud Stream and Spring Cloud Function.

As always, we welcome feedback and contributions, so please reach out to us on Stackoverflow or GitHub and or Gitter

from Spring https://ift.tt/2V4VmVO

January 21, 2020

Microsoft Patches Severe Crypto32.dll Vulnerability

Filed under: Uncategorized — ketan @ 8:03 PM

Microsoft has released patches for various versions of Windows 10 and Windows Server 2019 and 2016 to fix a severe vulnerability affecting system validation of Elliptic Curve Cryptography (ECC) certificates. This vulnerability enables an attacker to spoof the validity of a certificate chain and signature validation and requires prompt patching.

By Sergio De Simone

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

December 17, 2019

Salt Apple TV Remote Control

Filed under: Uncategorized — ketan @ 6:19 PM

Salt Apple TV Remote Control

Apple TV is a best-in-class streaming box with a polarizing remote. While Swiss firm Salt chose the Apple TV to bundle with its broadband fiber TV service, they found the remote to be a problem for some customers. So they made their own. Developed in collaboration with Apple, the new remote is a celebration of mundane usability, with physical buttons for things like pause, rewind, fast-forward, stop, up, down, left, right, power, and select. Thanks to Apple’s help, it works right out of the box without any pairing, and while it lacks a microphone and dedicated Siri button, the tradeoff is well worth it for many Apple TV users — even those that aren’t Salt customers.

from Uncrate https://ift.tt/35ypo6x

November 16, 2019

Ingress Vs Egress – What’s The Difference

Filed under: Uncategorized — ketan @ 8:17 PM

Ingress vs egress: there seems to be a never-ending debate about these terms. They’re kind of archaic and their meaning seems to be different in different situations.

Today, we’ll do our best to try to shed some light on this mystery. We don’t want to get into a philosophical debate, though. Our only goal is to do our best to explain these terms and how they are typically used in the context of networking. But even that, as you’re about to see, can tend to be rather confusing.

We’ll begin by beginning and do our best to define these two terms, first linguistically and then in the specific context of computer networks. We’ll then explain how their meaning can vary based on one’s point of view of based on the scope that we’re contemplating. The same egress traffic in one situation can become ingress traffic in another. Next, we’ll talk about monitoring ingress and egress traffic and introduce some of the best tools you can use for that purpose. But wait! There’s more. We’ll also discuss egress in the specific context of data security and introduce a couple of the best practices to protect yourself against data egress. And, keeping our good habits, we’ll review some of the best SIEM tools that you can use to detect unwanted data egress.

Defining Ingress And Egress

Linguistically speaking, defining either of those words could hardly be easier (pun intended). Let’s see what the Merriam-Webster dictionary has to say about it. It simply and plainly (almost boringly) defines ingress as “the act of entering”. Simple enough, no? And egress is not much more complicated as the same source defines it as “the action of going or coming out”. Here again, a pretty simple definition. If you care to check other sources, you’ll find a definite consensus. Ingress is getting in while egress is getting out.

In The Context Of Network Traffic

But this blog post is not about linguistics, it’s about network administration. And this is were ingress and egress can get a bit more confusing. It’s still the same, though and it has to do with data entering and leaving a network, a device or an interface. So far, nothing complicated. Where it gets tricky, though, is when people don’t agree on what’s in and what’s out. You see, sometimes the ins of one are the outs of another.

It All Depends On Your Point Of View

Ingress or egress, when referring to network traffic, has to do with how you see things, it depends on your point of view. In most other situations, in is in and out is out; there’s nothing confusing about that. This is, however, not so much the case with networks. Let’s try to clarify that using a few concrete examples.

Our first example is that of an Internet gateway. It could be a router, a proxy server or a firewall, that doesn’t matter. It is the device that sits between your local network and the Internet. In this case, I think everyone would agree that the Internet is considered as being the outside and the local network, the inside. So, traffic coming FROM the Internet TO the local network would be ingress traffic and traffic FROM the local network TO the Internet would be egress traffic. So far, it’s still simple.

But if you look at things from a network interface point of view, things get different. In the previous example, if you look at traffic on the LAN interface, traffic going towards the Internet is now ingress traffic as it is entering the gateway. Likewise, traffic going toward the local network is not egress traffic as it is exiting the gateway.

To summarize, differentiating ingress and egress traffic requires that we all agree on what we’re talking about. As we saw, ingress traffic in one context can be egress traffic in a different one. Our best suggestion would be to either avoid using these terms altogether or to clearly state their utilization context every time you use them. That way, you’ll avoid any confusion.

Monitoring Egress And Ingress Traffic

Now that we’re familiar with the terminology, let’s have a look at monitoring ingress and egress traffic. Typically, this is done using special software called network monitoring or bandwidth monitoring tools. These tools use the Simple Network Management Protocol (SNMP) to read interface counters from network-connected equipment. These counters simply tally the number of bytes in and out of each network interface. Note that monitoring tools rarely use ingress and egress and usually refer to traffic in and out of an interface. It is up to you, if you so desire, to determine which is ingress and which is egress traffic, again depending on the specific context.

A Few Tools We’d Recommend

There are many bandwidth or network monitoring tools available. Probably too many and picking the best one—or even just a good one—can be a challenge. We’ve tried many of the available tools and came up with this list of a few of the very best bandwidth monitoring tools you can find.

1. SolarWinds Network Performance Monitor (FREE TRIAL)

SolarWinds is one of the very best makers of network administration tools. The company’s flagship product is called the SolarWinds Network Performance Monitor, or NPM. It is a very complete network monitoring solution that features a user-friendly graphical user interface that administrators can use to monitor devices and to configure the tool.

The system uses SNMP to query devices and display their interfaces’ utilization as well as other useful metrics on a graphical dashboard. In addition to this dashboard, various built-in reports can be generated either on-demand or on based on a scheduled execution. And if the built-in reports don’t give you the information you need, they can be customized at will. The package also includes a few useful tools such as the ability to display a visual rendition of the critical patch between any two points of the network. This tool is highly scalable and it will suit any network from the smallest to large networks with thousands of devices spread over multiple sites.

SolarWinds NPM Enterprise Dashboard

The SolarWinds Network Performance Monitor‘s alerting system is another place where the product shines. As its reports, it is customizable if needed but it can also be used out-of-the-box with minimal configuration. The alerting engine is smart enough not to send notifications for “unimportant” events in the middle of the night or to send hundreds of notifications for as many unresponsive devices when the main issue is a down router or network switch upstream.

Pricing for the SolarWinds Network Performance Monitor starts at just under $3 000 and goes up according to the number of devices to monitor. The pricing structure is actually rather complex and you should contact the SolarWinds sales team for a detailed quote. If you prefer to try the product before purchasing it, a free 30-day trial version is available for download from the SolarWinds website.

2. ManageEngine OpManager

ManageEngine is another well-known publisher of network management tools. The ManageEngine OpManager is a complete management solution that will handle pretty much any monitoring task you can throw at it. The tool runs on either Windows or Linux and is loaded with great features. Among others, there is an auto-discovery feature that can map your network, giving you a uniquely customized dashboard.

The ManageEngine OpManager‘s dashboard is super easy to use and navigate, thanks to its drill-down functionality. And if you are into mobile apps, there are apps for tablets and smartphones allowing you to access the tool from anywhere. This is an overall very polished and professional product.

ManageEngine OpManager Monitoring

Alerting is just as good in OpManager as are all its other components. There is a full complement of threshold-based alerts that will help detect, identify, and troubleshoot network issues. Multiple thresholds with different notifications can be set for all network performance metrics.

If you want to try the product before buying, a free version is available. Although it is a truly free version rather than a time-limited trial, it has some limitations such as letting you monitor no more than ten devices. This is insufficient for all but the smallest of networks. For larger networks, you can choose between the Essential or the Enterprise plans. The first will let you monitor up to 1,000 nodes while the other goes up to 10,000. Pricing information is available by contacting ManageEngine’s sales.

3. PRTG Network Monitor

The PRTG Network Monitor, which we’ll simply refer to as PRTG, is another great monitoring system. Its publisher claims that this tool can monitor all systems, devices, traffic, and applications of your IT infrastructure. It is an all-inclusive package that does not rely on external modules or add-ons that need to be downloaded and installed. Because of its integrated nature, it is quicker and easier to install than most other network monitoring tools. You can choose between a few different user interfaces such as a Windows enterprise console, an Ajax-based web interface, and mobile apps for Android and iOS.

PRTG Dashboard - Datacenter Monitoring

The PRTG Network Monitor is different from most other monitoring tools in that it is sensor-based. Various monitoring features can be added to the tool simply by configuring extra sensors. They are like plugins except that they are not external modules but are, instead, included with the product. PRTG includes over 200 such sensors that cover different monitoring needs. For network performance metrics, the QoS sensor and the Advanced PING Sensor allow you to monitor latency and jitter while the standard SNMP sensor will let you monitor throughput.

The PRTG pricing structure is pretty simple. There’s a free version which is full-featured but will limit your monitoring ability to 100 sensors. There’s also a 30-day trial version which is unlimited but will revert back to the free version once the trial period is over. If you want to keep monitoring more than 100 sensors beyond the trial period, you’ll need to purchase a license. Their price varies according to the number of sensors from $1 600 for 500 sensors to $14 500 for unlimited sensors. Each monitored parameter counts as one sensor. For example, monitoring bandwidth on each port of a 48-port switch will count as 48 sensors.

Egress In The Context Of Security

There is another use for the term egress among network and system administrators that is specific to the context of data security. It refers to data leaving an organization’s local network. Outbound email messages, cloud uploads, or files being moved to external storage are simple examples of data egress. It is a normal part of network activity, but it can pose a threat to organizations when sensitive data is leaked to unauthorized recipients, either unknowingly or maliciously.

Threats Involving Data Egress

Sensitive, proprietary, or easily monetizable information is often targeted by cybercriminals of all kinds. The release of sensitive or proprietary information to the public or to competing organizations is a real concern for enterprises, governments, and organizations of all kinds. Threat actors may try to steal sensitive data through the same methods many employees use every day, such as email, USB, or cloud uploads.

Best Practices For Preventing Unwanted Data Egress

There’s a lot you can do to protect your organization against unauthorized data egress but a few of them are particularly important. Let’s have a look at two of the bare essentials that you must do.

Create an acceptable use and data egress traffic enforcement policy

Include stakeholders to define your acceptable use policy. The policy should be very thorough and protect your company’s resources. It could, for instance, include a list of approved Internet-accessible services and guidelines for accessing and handling sensitive data. And don’t forget that it is one thing to create such policies but you also need to communicate them to users and make sure they understand them.

Implement firewall rules to block egress to malicious or unauthorized destinations

A network firewall is only one of several lines of defense against threats. It is a good starting point where you can ensure that data egress does not occur without explicit permission.

SIEM – To Help Prevent Data Egress

No matter what you do, monitoring remains one of the best ways to protect against data egress. Whenever data leakage happens, you want to know about it right away so you can act upon it. This is where Security Information and Event Management (SIEM) tools can help.

Concretely, a SIEM system does not provide any hard protection. Its primary purpose is to make the life of network and security administrators like you easier. What a typical SIEM system really does is collect information from various protection and detection systems, correlate all this information assembling related events, and react to meaningful events in various ways. Most of the time, SIEM tools also include some form of reporting and/or dashboards.

Some Of The Top SIEM Tools

To give you an idea of what’s available and to help you pick the right SIEM tool for your needs, we’ve assembled this list of some of the best SIEM tools.

1. SolarWinds Security Event Manager (FREE TRIAL)

The same SolarWinds that brought us the Network Monitor reviewed above also has an offering for Security Information and Event Management. In fact, it is one of the very best SIEM tools available. It might not be as full-featured as some other tools but what it does, it does very well and it has all the required functionality. The tool is called the SolarWinds Security Event Manager (SEM). It is best described as an entry-level SIEM system but it’s likely one of the most competitive entry-level systems on the market. The SolarWinds SEM has everything you can expect from a SIEM system, including excellent log management and correlation features that can help detect unauthorized data egress and an impressive reporting engine.

SolarWinds Security Event Manager Screenshot

FREE TRIAL: SolarWinds Security Event Manager

Official Download Link: https://www.solarwinds.com/security-event-manager/registration

As for the tool’s event response features, as expected from SolarWinds, they leave nothing to be desired. The detailed real-time response system will actively react to every threat. And since it’s based on behaviour rather than a signature, you’re protected against unknown or future threats. The tool’s dashboard is possibly one of its best assets. With a simple design, you’ll have no trouble quickly identifying anomalies. Starting at around $4 500, the tool is more than affordable. And if you want to try it first, a free fully functional 30-day trial version is available for download.

Official Download Link: https://www.solarwinds.com/security-event-manager/registration

2. Splunk Enterprise Security

Possibly one of the most popular SIEM system, Splunk Enterprise Security–or simply Splunk ES, as it is often called–is famous for its analytic capabilities. Splunk ES monitors your system’s data in real time, looking for vulnerabilities and signs of abnormal activity. The system uses Splunk’s own Adaptive Response Framework (ARF) which integrates with equipment from more than 55 security vendors. The ARF performs automated response, letting you quickly gain the upper hand. Add to that a simple and uncluttered user interface and you have a winning solution. Other interesting features include the “Notables” function which shows user-customizable alerts and the “Asset Investigator” for flagging malicious activities and preventing further problems.

Splunk ES Risk Analysis Screenshot

Splunk ES is an enterprise-grade product and, as such, it comes with an enterprise-sized price tag. You can’t, unfortunately, get much pricing information from Splunk’s website and you’ll need to contact the sales department to get a quote. Despite its price, this is a great product and you might want to contact Splunk to take advantage of an available free trial.

3. NetWitness

For the past few years, NetWitness has focused on products supporting “deep, real-time network situational awareness and agile network response”. After being purchased by EMC which then merged with Dell, the Netwitness business is now part of the RSA branch of the corporation. And this is good news as RSA has an excellent reputation in security.

NetWitness is ideal for organizations seeking a complete network analytics solution. The tool incorporates information about your business which helps prioritize alerts. According to RSA, the system “collects data across more capture points, computing platforms, and threat intelligence sources than other SIEM solutions”. There’s also advanced threat detection which combines behavioural analysis, data science techniques, and threat intelligence. And finally, the advanced response system boasts orchestration and automation capabilities to help eradicate threats before they impact your business.

RSA NetWitness Screenshot

One of the main drawbacks of NetWitness is that it’s not the easiest to set up and use. However, there is ample documentation available which can help you with setting up and using the product. This is another enterprise-grade product and, as it is often the case with such products, you’ll need to contact sales to get pricing information.

Read Ingress Vs Egress – What’s The Difference by Renaud Larue-Langlois on AddictiveTips – Tech tips to make you smarter

from AddictiveTips https://ift.tt/2NQe4fK

August 26, 2019

Hacking the Sonos Ikea Symfonisk Into a High Quality Speaker Amp

Filed under: Uncategorized — ketan @ 7:48 AM

As soon as I saw IKEA’s announcement for a $99 Sonos-powered Airplay speaker, I was excited for the possibilities its internals could bring. And oh boy, was I right to be. In this tutorial, I’ll show you how to whittle away the woefully inefficient compact speaker unit, and bring it to life on a pair of quality vintage bookshelf speakers.

Just a quick note about speaker selection. Be sure to select a pair of speakers that are (A) set up for bi-amping (eg. four input terminals instead of the standard two), or (B) a set of two-way speakers that you aren’t opposed to dissecting.

Tools required:

#2 Phillips Screwdriver (Possibly #1 as well, if you’re picky)

Needle Nose Pliers

Spudger or pick (if you don’t have fingernails long enough)

While there isn’t much information out there on disassembly of the speaker, a little bit of hunting around the sealed plastic enclosure revealed that the fabric tab with the Sonos and IKEA logos on it functioned as a pull tab to get the grille off.

This reveals the three acoustic elements, a 1 inch rubber done tweeter, a 3 inch woofer, and a curved tuned port. The rubber inserts that suspend the grille in place are firmly seated in their holes, requiring the needle-nose pliers to remove.

Underneath each insert is a Loctite sealed #2 phillips screw, which will each give out a small pop when unscrewed, due to the threadlocker releasing.

Next is the tricky part. The front panel, with all the speakers, is sealed to the case by a friction fit foam strip. The easiest way to remove it is to wedge as many fingers as you can into the bass port, and hook them around the bend (towards the tweeter) and pull firmly and consistently. Be careful not to yank the whole assembly too hard, as there are a few connections to the motherboard inside that can be quite fragile.

Once it’s free from the foam seal, it’s easiest to open it up like a book, in order to get to the four spade connectors, two per driver, and the small flex cable for the buttons and status lights.

There are two different size spade connectors per speaker, a smaller one for ground, and a large one for the positive terminal. Be careful removing these, they are locking spade connectors, meaning that if you pull directly on them, something important will give instead of the connector. Pull back the clear heat shrink, and locate the small locking tab. Squeeze this down with the needle-nose pliers as you pull, and they come off with little to no effort.

Next is the tiny, fragile 8-pin flex cable, and corresponding connector, which the motherboard uses to connect to the front panel controls and indicator light. After peeling back the small oval-shaped foam tape covering the connector, use a spudger, or a fingernail, to open the latch, and gently lift out the end of the cable.

Now that the front panel is completely free, we get our first real look at the internals of the speaker, and WOW, is it impressive for the price. We’ll take a closer look at the motherboard later, but just as a precursor, we can see three large, name brand capacitors, a socketed wifi card (meaning a feasible wifi upgrade years on), and properly isolated high and low voltage sections of the PCB.

We’re next going to remove the brace that holds the foam-wrapped speaker cables in place. One short #2 phillips screws on each side of the plastic part come off, and with minimal effort, you can remove the cables and ferrite core from the clips.

The speaker cables have their own socket and connector, but watch out, as it is yet another locking connector. Use the end of your screwdriver to push the small rectangular latch towards the body of the connector, while simultaneously giving the cable a gentle tug.

On the opposite corner of the motherboard, the AC power input has a similar connector, which is removed in the same way. Next to that are the two wifi antenna cables, one red and one yellow. It is easiest to remove these by removing the blob of hot glue they are seated in at the same time. If it all comes out in one unit, reassembly outside of the case will be easier. If not, peel away the excess hot glue, and prepare for the microscopic job of reconnecting the two coaxial connectors.

Next, remove the six screws holding the motherboard in place. Be careful with the four screws closest to the bottom of the unit, as they are threaded into a cast aluminum heatsink, and require just a bit more torque. Remove the board from the enclosure, turning it diagonally to avoid the internal ribbing of the enclosure.

This surprisingly large heatsink is held in by three more phillips screws, but be careful not to damage the two thermal pads when removing the screws. Remove the heatsink, and use four of the six motherboard screws to affix it back to its spot on the board.

Now that the motherboard and heatsink are one again, we can look closer at the board, and marvel at the quality of it. A good mixture of cheaper and more compact SMD components, as well as appropriately beefy through-hole components. Each side of the board has its own EMI shielded enclosure, with the computer on the front, and the amplifier on the back. Plated mounting holes, heavy doses of solastic, and name brand components all jump out as features of much more expensive circuitry.

Back to the front panel, we can remove the four small phillips screws holding the button assembly to the panel. Remove these, and the buttons, rubber membrane, and small daughterboard are freed.

Now, slowly peel the flex cable from the bottom of the enclosure, as it’s needed to connect the two circuit boards. It’s worth noting that the 8 contact pads of the flex cable face towards the circuit board upon reinsertion. Remove the two phillips screws around the AC socket, and reconnect it to the motherboard for testing.

Next up are the two oddly angled antennas in the top of the enclosure. Engineering-wise, these feel like an afterthought, as they each have their own plastic bracket connecting them to the enclosure, instead of having their mounts molded into the plastic, like all the other components. Speculation aside, they’re easy enough to remove, using a bit of force on the bottom of each bracket breaks the strong double-sided tape holding them in, and the hot glue holding the antenna cables into the enclosure is easy enough to break.

Now we have all the electronics free, it’s time to connect them to the speaker and give it a quick test. This is what you should have in front of you.

Along with a speaker, of course. This is where things start to differ. As mentioned in the beginning of this tutorial, you will need either a bi-amp-able speaker (i.e., separate terminals for woofer and tweeter) or a two-way speaker for which you can bypass the internal crossover. These are two discrete digital amplifiers, one for the tweeter, and one for the woofer. Bridging them not only causes the amplifier to shut down, but it may damage your $99 pile of circuit boards and wires.

The connections are as follows, for the tweeter, red for positive, black for negative, just like the textbook says. For the woofer, blue for positive, and white for negative. A polarity swap isn’t the end of the world, it’ll just cause your two-way speaker to be out of phase with itself. I have my board connected to a vintage JMLabs bi-amped two-way bookshelf speaker, as shown below.

Plug in the AC cord, launch the Sonos app, and launch the real star of the show, the TrueTune feature baked into the app, and your board. Follow the directions, disregarding that your speaker isn’t in its final resting place, as you can simply retune it later. The TrueTune software quickly adapts the digital crossover within the board, allocating the correct frequency ranges to the woofer and the tweeter of your speaker, making it sound near perfect.

Video

And there you have it! One half of the perfect budget Sonos system. Repeat the procedure for your second speaker, maybe build yourself a nice enclosure for the electronics, and relish in the glory of a beautiful pair of Airplay-2, Sonos-enabled, TrueTuned speakers for a few hundred bucks.

from MAKE Magazine https://ift.tt/2YYvHkA

August 21, 2019

The Cloud-native Azure Application Architect Map

Filed under: Uncategorized — ketan @ 11:30 PM

Hi,

 

Recently, I built the Azure Solution Architect Map , the Azure Security Architect Map  and the Azure Infrastructure Architect Map aimed at helping Architects finding their way in Azure. I’m now coming with the last map to close the loop, namely: the Cloud-native Azure Application Architect Map.

As usual, this map is by no way the holy grail and is just there to highlight some good fit between Azure Services and Design Patterns. This map is certainly subject to controversy as they are thousands of ways to design and develop and application. My goal is only to highlight some possibilities.  

 

As usual, here is a screenshot of the map:

 

map.png

 

The map focuses on the following areas:

  • Data & Big Data
  • Common Design Patterns: SAGA, Circuit Breaker, Event-driven Architecture, etc.
  • Domain-driven Design & Microservices: yes I clubbed them together 🙂
  • Artificial Intelligence: NLP, Supervised & Unsupervised ML etc.
  • Miscellaneous: things that come back regularly when developing applications such as real-time HTTP, search, job scheduling etc. 

How to read this map?

 

Whenever you see the attachment icon attachicon.png, it means that I have attached an explanation on a given rationale or service. If you see a (*) next to a node, it is kind of a must read information. So for instance, in the following screenshot:

dddcqrs.png

 

I want to catch your attention on why I make an association between DDD and Microservices:

dddcqrsexplained.png

as well as why I make an association between CQRS and DDD:

cqrsdddexplained.png

You might of course disagree with this but at least, you understand my rationale.

The link icon  link.pngis a pointer to the corresponding Microsoft documentation.

 

Note that I haven’t dived into AKS or Service Fabric since this guys would deserve a dedicated map and are not Azure services like others, they are a universe by themselves.

 

With this tool, any Cloud-native Application Architect should quickly grasp the application landscape of Azure. 

 

Here is the pointer to the map:

 

https://app.mindmapmaker.org/#m:mm196129ff9c6444e79c26d3c8d457704a

 

from New blog articles in Microsoft Tech Community https://ift.tt/33NaqZO

This Week in Spring – August 20th, 2019

Filed under: Uncategorized — ketan @ 7:18 AM

Hi Spring fans! I’m in delightful Denver and Boulder, Colorado, talking to customers and working with my buddies Matt Raible and James Ward on our Spring One Platform 2019 talk. It’s going to be amazing!

I’m oh-so-excited to be working on today’s roundup, as usual, because there’s a ton of good stuff to cover, so let’s get to it!

from Spring https://ift.tt/2MshtBP

July 19, 2019

Put Those iPad Displays To Work With This eDP Adapter

Filed under: Uncategorized — ketan @ 12:29 AM

Regardless of how you might feel about Apple and the ecosystem they’ve cultured over the years, you’ve got to give them some credit in the hardware department. Their “Retina” displays are a perfect example; when they brought the 2,048 by 1,536 panel to the iPad 3, the technology instantly became the envy of every tablet owner. But what if you want to use one of these gorgeous screens outside of Apple’s walled garden?

As it turns out, there are a number of options out there to use these screens on other devices, but [Arthur Jordan] wasn’t quite happy with any of them. So he did what any self respecting hacker would do, and built his own adapter for iPad 3 and 4 screens. Not that he did it completely in the dark; his design is based on the open source Adafruit Qualia driver, which in turn was based on research done by [Mike’s Mods]. A perfect example of the open source community at work.

The resulting board allows you to connect the Retina display from the iPad 3 or 4 to any device that features Embedded DisplayPort (eDP). Rather than put a dedicated port on his board, [Arthur] just left bare pads where you can solder up whatever interface method your particular gadget might use. In his case, he wanted to hook it up to an x86 UP Core SBC, so he even came up with a seperate adapter that breaks out that board’s diminutive display connector to something that can be soldered by hand.

So what’s different between the board [Arthur] developed and Adafruit’s Qualia? Primarily its been made smaller by deleting the DisplayPort connectors in favor of those bare pads, but he’s also dumped the backlight control hardware and 3.3V regulator that in his experience hasn’t been necessary with the eDP devices he’s worked with. So if space is a concern in your build, this version might be what you’re after.

We’ve seen other Retina display adapters in the past, and of course the iPad isn’t the only high-end device that’s had a screen good enough to reuse on its own. The lesson here is that if you put a must-have feature in your product, don’t be surprised when some hacker comes along and figures out how to liberate it for their own purposes.

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

June 20, 2019

Let’s “Electrify” a Korean Board Game

Filed under: Uncategorized — ketan @ 7:29 AM

This is a guest blog post by close SparkFun friend, Jackson Hootman. Jackson is currently studying Mechanical Engineering at the University of Colorado Boulder. Last summer, Jackson had the opportunity to work with SparkFun as an intern, and ever since then has had a passion for creating his own electronics projects. You may remember his post from last year about adding electronics and lighting effects to existing Lego® kits.

How to Play

Yut Nori is a popular Korean board game. It has been played for hundreds of years and consists of players moving four horses (tokens) through a series of stations.

Yut Stations

Yut stations for a rectangular configuration.

Each horse begins and ends at the blue station. The player to first return all of their horses is the winner. If a horse lands on a large station (highlighted in red) then the player has the option of taking a shortcut by moving towards the center station on their next turn.

Yut Courses

There are four possible routes to take.

These short cuts can only be taken if a player lands on the red stations above. Otherwise, the light green path is taken. The number of stations moved per turn is determined by the throwing of four yut sticks. Yut sticks are half cylinders, meaning that when thrown they will either land on a curved side or a flat side. The combination of flat and curved sticks determines the number of stations a player will be able to move. One point is earned per stick that lands on its curved side. The following image gives the corresponding value to each possible combination.

Point Values

Point values for possible yut stick combinations.

What really makes the game fun though is the ability to have multiple tokens from the same team on the board at the same time. Instead of moving a horse already on the game board, a player can choose to add a new horse to the game. Additionally, if a token lands on another token from the same team, those horses can be stacked such that they move together for the remainder of the game. This is dangerous, however, because if an opposing player lands on a station with your horses, then all of your horses at that station are returned home. Below are the tokens and yut sticks I made for my board.

Yut Tokens

The tokens are made from multiple layers of acrylic. They are made to stack together.

Yut Sticks

The sticks are made of 4in long wood half cylinders (with diameter 3⁄4”).

Let’s Add Some Electronics

The electronics of my game board consists of three major parts. First, there is one LED per player. The LEDs are used to indicate to the players whose turn it is. In this way, only one LED will be powered at a time and that respective LED will be on for the entirety of that players turn.

Yut LED

Basic Blue LED in series with 1000 Ohm resistor.

Next, buttons are used to start the game, end the game, finish turns, and change an individual’s score. For my project, I used three separate push buttons. One button is used to add points to a players score, one is used to subtract points from a players score (just in case mistakes were made in adding points). The last button is held for a few seconds to start a game and once on, is used to switch between players. Once gameplay is done, pushing down on this button for a few seconds will shut the board off. Once this is done, the scores will be reset.

Yut Button

Black Concave Button.

Each player’s score (the number of horses they have returned) is displayed using a seven segment display. Because I wanted this game board to handle up to four players, I’d need a way to control at least 28 individuals pins. That’s where shift registers came in handy. I utilized one shift register per seven segment display. This meant that in my final circuit, I had four daisy chained shift registers.

Yut Circuit

Four daisy chained shift registers.

One of the most interesting parts of this project was programming the seven segment displays. Each display has 10 pins, which meant it was important to be uniform in my notation and coding. While writing the Arduino code for this project I chose to define the pins in the following way:

Seven Segment Diagram

Each pin (except for the two common anode pins) controls one segment.

Each pin controls the segment highlighted with the corresponding color. These are common anode displays, meaning that when power is supplied to pin-3 or pin-8, segments will only be powered when their respective pin is set to low.

If for example, you wanted to display the number one, pin-5 and pin-7 should be set to low. To program the seven segment display with a shift register, this information should be sent as a byte. There is one bit per each of the eight pins that control an LED. If only pin-5 and pin-7 are set to low, the byte we want to send to the shift register is 11101011.

Seven Segment Example

Byte to send to shift register to display the number one.

I repeated this process for all the other numbers I wanted to display. I stored the bytes for each number in an array for easy access in Arduino. Feel free to take a look at the code attached below for more information.

//Jackson Hootman
//Yut Game Board

// shift register pins
#define dataPin 2
#define latchPin 3
#define clockPin 4

// inputs
#define ButtonBlack 13
#define ButtonBlue 12
#define ButtonRed 11

// turn indicators
int LED[4];

//player 4 - initially all off
byte sevenSegD = 0xFF;
//player 3 - initially all off
byte sevenSegC = 0xFF;
//player 2 - initially all off
byte sevenSegB = 0xFF;
//player 1 - initially all off
byte sevenSegA = 0xFF;

//array to store byte inputs for 0-4
byte sevenSegArray[5];

//other variables
boolean gameOn = false;
boolean finished[4];
int player = 1;
int score[4];
int place = 1;

void setup() {

  //initial score for each player
  score[0] = 0; //player 1
  score[1] = 0; //player 2
  score[2] = 0; //player 3
  score[3] = 0; //player 4

  //no one has finished
  finished[0] = false; //player 1
  finished[1] = false; //player 2
  finished[2] = false; //player 3
  finished[3] = false; //player 4

  //LED pins
  LED[0] = 9;
  LED[1] = 8;
  LED[2] = 7;
  LED[3] = 6;

  pinMode(LED[0], OUTPUT);
  pinMode(LED[1], OUTPUT);
  pinMode(LED[2], OUTPUT);
  pinMode(LED[3], OUTPUT);

  //byte values for 0-4 on seven segment display
  sevenSegArray[0] = 0x88; // zero in hexidecimal
  sevenSegArray[1] = 0xEB; // one in hexidecimal
  sevenSegArray[2] = 0x4C; // two in hexidecimal
  sevenSegArray[3] = 0x49; // three in hexidecimal
  sevenSegArray[4] = 0x2B; // four in hexidecimal

  // shift register pins
  pinMode(dataPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);

  // input pins
  pinMode(ButtonBlack, INPUT_PULLUP);
  pinMode(ButtonBlue, INPUT_PULLUP);
  pinMode(ButtonRed, INPUT_PULLUP);

  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, LSBFIRST, sevenSegD);
  shiftOut(dataPin, clockPin, LSBFIRST, sevenSegC);
  //latch pin to high - data done transmitting
  digitalWrite(latchPin, HIGH);
  delay(1000);
}

void loop() {
  if (gameOn) {
    if (digitalRead(ButtonBlack) == HIGH) {
      player = switchPlayer(player); // next players turn
      delay(2000);
      if (digitalRead(ButtonBlack) == HIGH) {
        gameOn = false; // if button is held down, turn off
        shutDown();
      }
    }
    if (digitalRead(ButtonBlue) == HIGH) {
      if (score[player - 1] == 3) {
        score[player - 1] = place; //player finished
        finishSegment(player, place, score);
        finishSegment(player, place, score);
        finishSegment(player, place, score);
        updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], sevenSegArray[score[2]],                          sevenSegArray[score[3]]);
        place++;
        finished[player - 1] = true;
        delay(1000);
      }
      if (finished[player - 1] == false) {
        score[player - 1]++; //add one
        updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], sevenSegArray[score[2]],                          sevenSegArray[score[3]]);
       delay(1000);
      }
    }
    if (digitalRead(ButtonRed) == HIGH) {
      if (score[player - 1] == 0) {
      } else {
        score[player - 1]--; //subtract one
        updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], sevenSegArray[score[2]],                          sevenSegArray[score[3]]);
        delay(1000);
      }
    }
 }
  else
 {
    if (digitalRead(ButtonBlack) == HIGH) {
      delay(1000);
      if (digitalRead(ButtonBlack) == HIGH) {
        gameOn = true; //if held, start up
        startUp();
      }
    }
  }
}

void startUp() {
  //blink 3 times

  updateSevenSeg(0, 0, 0, 0); // switch on
  updateLEDs(false, false, false, false); // LEDS off
  delay(500);

  updateSevenSeg(0xFF, 0xFF, 0xFF, 0xFF); // switch off
  updateLEDs(true, true, true, true); // LEDS on
  delay(500);

  updateSevenSeg(0, 0, 0, 0); // switch on
  updateLEDs(false, false, false, false); // LEDS off
  delay(500);

  updateSevenSeg(0xFF, 0xFF, 0xFF, 0xFF); // switch off
  updateLEDs(true, true, true, true); // LEDS on
  delay(500);

  updateSevenSeg(0, 0, 0, 0); // switch on
  updateLEDs(false, false, false, false); // LEDS off
  delay(500);

  updateSevenSeg(0xFF, 0xFF, 0xFF, 0xFF); // switch off
  updateLEDs(true, true, true, true); // LEDS on
  delay(1000);

  updateLEDs(true, false, false, false); // LEDS off

  //initiallize start order
  //player 1 light up
  updateSevenSeg(sevenSegArray[1], 0xFF, 0xFF, 0xFF);
  delay(1000);

  //player 2 light up
  updateSevenSeg(sevenSegArray[1], sevenSegArray[2], 0xFF, 0xFF);
  delay(1000);

  //player 3 light up
  updateSevenSeg(sevenSegArray[1], sevenSegArray[2], sevenSegArray[3], 0xFF);
  delay(1000);

  //player 4 light up
  updateSevenSeg(sevenSegArray[1], sevenSegArray[2], sevenSegArray[3], sevenSegArray[4]);
  delay(2000);

  //all players to zero
  updateSevenSeg(sevenSegArray[0], sevenSegArray[0], sevenSegArray[0], sevenSegArray[0]);
  delay(5000);

  // start with player 1
  player=1;

  //initial score for each player
  score[0] = 0; //player 1
  score[1] = 0; //player 2
  score[2] = 0; //player 3
  score[3] = 0; //player 4

}

void shutDown() {
  //blink 3 times

  updateSevenSeg(0xFF, 0xFF, 0xFF, 0xFF); // switch off
  updateLEDs(true, true, true, true); // LEDS on
  delay(1000);

  updateSevenSeg(0, 0, 0, 0); // switch on
  updateLEDs(false, false, false, false); // LEDS off
  delay(500);

  updateSevenSeg(0xFF, 0xFF, 0xFF, 0xFF); // switch off
  updateLEDs(true, true, true, true); // LEDS on
  delay(500);

  updateSevenSeg(0, 0, 0, 0); // switch on
  updateLEDs(false, false, false, false); // LEDS off
  delay(500);

  updateSevenSeg(0xFF, 0xFF, 0xFF, 0xFF); // switch off
  updateLEDs(true, true, true, true); // LEDS on
  delay(500);

  updateSevenSeg(0, 0, 0, 0); // switch on
  updateLEDs(false, false, false, false); // LEDS off
  delay(500);

  updateSevenSeg(0xFF, 0xFF, 0xFF, 0xFF); // switch off
  updateLEDs(true, true, true, true); // LEDS on
  delay(1000);

  updateLEDs(false, false, false, false); // LEDS off
}

int switchPlayer(int player) {
  switch (player) {
    case 1:
      player = 2;
      updateLEDs(false, true, false, false);
      break;
    case 2:
      player = 3;
      updateLEDs(false, false, true, false);
      break;
    case 3:
      player = 4;
      updateLEDs(false, false, false, true);
      break;
    case 4:
      player = 1;
      updateLEDs(true, false, false, false);
      break;
  }
  return player;
}

void finishSegment(int player, int place, int score[4]) {
  switch (player) {
    case 1:
      updateSevenSeg(0xBF, sevenSegArray[score[1]], sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(0xDF, sevenSegArray[score[1]], sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(0xEF, sevenSegArray[score[1]], sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(0xFB, sevenSegArray[score[1]], sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(0xFD, sevenSegArray[score[1]], sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(0xFE, sevenSegArray[score[1]], sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);

      break;
    case 2:
      updateSevenSeg(sevenSegArray[score[0]], 0xBF, sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], 0xDF, sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], 0xEF, sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], 0xFB, sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], 0xFD, sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], 0xFE, sevenSegArray[score[2]], sevenSegArray[score[3]]);
      delay(200);
      break;
    case 3:
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], 0xBF, sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], 0xDF, sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], 0xEF, sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], 0xFB, sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], 0xFD, sevenSegArray[score[3]]);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], 0xFE, sevenSegArray[score[3]]);
      delay(200);
      break;
    case 4:
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], sevenSegArray[score[2]], 0xBF);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], sevenSegArray[score[2]], 0xDF);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], sevenSegArray[score[2]], 0xEF);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], sevenSegArray[score[2]], 0xFB);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], sevenSegArray[score[2]], 0xFD);
      delay(200);
      updateSevenSeg(sevenSegArray[score[0]], sevenSegArray[score[1]], sevenSegArray[score[2]], 0xFE);
      delay(200);
      break;
      }
}


void updateSevenSeg(byte A, byte B, byte C, byte D) {
  //update seven segment displays
  digitalWrite(latchPin, LOW);
  sevenSegD = D; //display 4
  sevenSegC = C; // display 3
  sevenSegB = B; //display 2
  sevenSegA = A; // display 1
  shiftOut(dataPin, clockPin, LSBFIRST, sevenSegD);
  shiftOut(dataPin, clockPin, LSBFIRST, sevenSegC);
  shiftOut(dataPin, clockPin, LSBFIRST, sevenSegB);
  shiftOut(dataPin, clockPin, LSBFIRST, sevenSegA);
  //latch pin to high - data done transmitting
  digitalWrite(latchPin, HIGH);
}

void updateLEDs(boolean A, boolean B, boolean C, boolean D) {
  //update LEDs
  if (A) {
    digitalWrite(LED[0], HIGH);
  } else {
    digitalWrite(LED[0], LOW);
  }
  if (B) {
    digitalWrite(LED[1], HIGH);
  } else {
    digitalWrite(LED[1], LOW);
  }
  if (C) {
    digitalWrite(LED[2], HIGH);
  } else {
    digitalWrite(LED[2], LOW);
  }
  if (D) {
    digitalWrite(LED[3], HIGH);
  } else {
    digitalWrite(LED[3], LOW);
  }
}

Final Product

The housing for the circuit was made with acrylic sheets. This way exact holes could be made using a laser cutter to fit the seven segment displays, LEDs, and buttons.

Final Game Board in the Dark

Game board in the dark.

I chose to not paint the acrylic so all the electronics were visible. The displays were especially fun in the dark.

Final Game Board in the Light

Tokens on the game board.

The great part about this project is that I had the freedom to create the user experience I wanted. If anyone wants to give this project a go, I recommend you switch things up and make it your own. Perhaps you want to use an LCD instead of seven segment displays. Go for it!

Yut Circuit in its Housing

Circuit in housing.

Regardless, I hope you give this game a try. I’d love to hear what you think and I hope you have as much fun as I did when I first played!

comments | comment feed

from SparkFun Blog http://bit.ly/2IphlQu

Older Posts »

Create a free website or blog at WordPress.com.