The connectBlue serial port adapter with Bluetooth 1.1 wireless technology was used to demonstrate the transmission of electronic data from patient monitors at a recent conference. Bluetooth wireless technology has experienced delays and sundry growing ...

Bluetooth and Medical Devices: Vital Signs Are Robust

For many manufacturers, the question is not whether to network-enable their devices, but how to do so most cost-effectively. Recent developments in the healthcare industry have made the need for networked devices readily apparent. From the current nursing ...

E-Health and Connectivity

The global Trusted Platform Module market is dominated by key Players, such as [Analog Devices, CISSOID S.A, ConnectBlue, Infineon Technologies AG, Intel, Media Tek, Microchip Technology ...

Trusted Platform Module Market Size by 2031

Code Blue Communications Inc. will distribute this serial port adapter and other Bluetooth products manufactured by connectBlue. An interface device developer has gained exclusive rights to distribute connectBlue (Malmö, Sweden; www.connectblue.se ...

Code Blue Communications Brings Bluetooth to Medical Markets

Industrial wireless solution provider connectBlue reveals solution that maintains the signal quality on the existing wireless connection when the scanning for a new network is initiated; for instance, as a device in motion is moving from one access point ...

Wireless LAN Ethernet Port Adapters

connectBlue expands its Wireless LAN range by launching two high-tech modules based on the latest IEEE 802.11 a/b/g/n standards. The dual-band modules operate well both on the 2.4 GHz and the 5 GHz bands facilitating coexistence between wireless ...

connectBlue Unveils Wireless LAN Dual-band Modules

connectBlue, a provider of robust wireless solutions in demanding applications, has signed an agreement with Sigma Connectivity, a leading consultancy company for realizing solutions for Internet of Things. Jan 21, 2014 connectBlue, a provider of robust ...

connectBlue and Sigma Connectivity in Cooperation for Delivering Internet of Things Solutions

At SPS/IPC/Drives, Germany, connectBlue releases the Multiradio Module OWL355 which is a completely ready-to-embed module for demanding industrial, medical and Internet of Things (IoT) applications. Nov 26, 2013 At SPS/IPC/Drives, Germany, connectBlue ...

connectBlue Announces Multiradio Module for Internet of Things

At SPS/IPC/Drives, Germany, connectBlue launches the Rugged Bluetooth Serial Port Adapter RBS421s which is an easy-to-use Bluetooth dual-mode device that supports both Classic Bluetooth and Bluetooth low energy and can be used as a Bluetooth Smart Ready ...

connectBlue Launches Dual-Mode Bluetooth Smart Ready Serial Port Adapter

connectBlue

connectblue

Oh, the magic of hardware Not long ago, I showed you . This is kind of cheating for a number of reasons: how to make the game Snake on JavaScript and Canvas Yes, JavaScript runs in any browser, but you still need a browser to run it. Canvas itself is a bit of a shortcut. It is literally a graphics engine inside JavaScript, and you can directly manipulate Canvas with very straightforward commands and coordinates. While using JavaScript and Canvas was challenging and fun and everything, there is a way to make our game even cooler. Let’s build a hardware-based Snake! The core: Arduino At the core of the system, we’ll have Arduino. It’s a system that helps you build DIY robots, sensors, smart home solutions, and even some slow web servers, should you so desire. Arduino itself is a small board with components soldered onto it: At the center of the board, there’s a chip that you can program in any way you like. To program it, you attach the Arduino to your computer and run special software that puts your code onto the chip. See those black sockets on both sides of the board? That’s where you attach wires to carry electricity. The chip that you programmed can read the values of that electricity and act on them. Using Arduino: a quick example Before I go into Snake, here’s a simple home project you can do with Arduino to make sense of how the system works. On one side, you connect the Arduino to two wires that lead to a humidity sensor. The sensor will output a voltage between 0.1 volt and 5 volts, corresponding to how humid the air is. Let’s say the main wire from the sensor is connected to Socket 1 on the Arduino. On the other side of the Arduino, connect an LED light that can be either on or off. To fire it up, you need to send it 5 volts of current. Let’s say the LED is connected to Socket 2. For the chip, you write some code that has the following meaning: Read the voltage from Socket 1 (the humidity sensor) If that voltage is above 2.5 volts, then do nothing for 30 seconds If that voltage is 2.5 volts or less, send 5 volts to Socket 2 (the LED light), do nothing for 60 seconds, and then stop sending power to Socket 2. Repeat until the heat death of the universe To the Arduino, it’s just a matter of taking a reading, doing some logic, and sending power to someplace on its board. The Arduino is unaware of what is attached to it. The Arduino simply routes electricity. But to me, the user, this is a humidity system that alarms me once the air gets too dry. Currently, my system warns me with a light, but should I choose to, I could attach a buzzer instead. I could even attach an electric humidifier and have it turn on to remediate the dry air. Arduino can work as an alarm system, a timer, a notification system, and more. But for us, it’s going to be a game. Collecting the gear For this project, we’re going to need: You can get the classic Arduino or an Arduino Nano. The mini version comes either pins, sockets, or soldering holes. If you want to avoid soldering, make sure you buy a model with either pins or sockets—like this: An Arduino board. This is a plastic board with metal leads underneath. It allows you to connect wires without soldering. Each column of the breadboard is a single lead. If you want to connect two wires, stick them into the same column. A breadboard. Breadboards are a temporary arrangement. So, should you decide to make this game permanent, you’ll need to solder some components together. But for now, a breadboard will be good enough. This matrix has two parts: an arrangement of LEDs that fire up on demand, and a controller board that communicates which LEDs to light up and when. The matrix will communicate with our Arduino board through five pins, and we’ll use the breadboard to connect the matrix to the Arduino. An LED matrix, 8 * 8. We’ll use this to control the snake. A joystick. This device receives electrical current and makes it weaker by some amount. The more you turn the potentiometer’s handle, the weaker the current becomes. This means that if we know how much current we sent over to the potentiometer, and how much current we got back in return, then we can figure out how much the potentiometer was turned. A 10K rotary potentiometer. Get a bunch of wires off Amazon or AliExpress. Make sure you get some wires with pins, some wires with sockets, and some wires with both pins and sockets. Wires are a dime a dozen, so just get a handful. Some wires. Time for assembly If this is your first Arduino project, let’s go over some basics and safety guidelines first: Arduino operates on tiny currents which won’t harm you even if you come in contact with them. However, once you start using external power supplies (like batteries), then improper wiring can cause damage—both to the Arduino and to people. Practice precaution. Disconnect the Arduino from any sort of power supply before you start assembly. While the Arduino is disconnected and there is no external power (like batteries), there is no current flowing, so nothing bad can happen. We connect the components with wires either directly or through the breadboard. The wires allow the current to flow between the Arduino and other devices. To connect anything through a breadboard, stick two pins into the same column (columns are numbered). Everything connected to a single column is interconnected. For current to flow, it needs a source and a drain. The current kind of flows from the source and into the drain. The drain can be called ‘Ground.’ If you connect a device to the source, but don’t provide the connection to ground, then the current won’t flow and the device won’t work. On some devices, you’ll see pins labeled VCC and GND. VCC is the source. GND is ground. If you connect the source and ground directly (without any devices or components in between), then the current will flow like crazy. This will make your wire heat up and eventually burn. This is called a ‘short circuit.’ Never connect the source and the drain directly! Devices and components can share a common source and drain if there is enough power at the source. The term ‘VCC’ refers to the onboard power supply. Arduino has a 5-volt onboard regulator, which means that your VCC socket on the Arduino may be labeled 5V. It depends on which kind of Arduino you buy. What matters is that, for this project, VCC and 5V are the same. Now with basics out of the way, it’s time to connect your components like so: You’ll notice that: All the red wires are connected to 5V, or source. You can hook them all up to the red row on the breadboard and connect that row to Arduino’s 5V socket. That way, you’ll have a common source for all of your components. All the black wires are connected to ground. Connect all grounds to the blue line on the breadboard and hook up that blue line to Arduino’s ground. Now you have a common ground. If you’re having trouble connecting everything in this way, check out this video: Adding the firmware Now you need to connect your Arduino to your computer via the USB cable that came with the Arduino. The Arduino will start up and probably start blinking with an onboard LED, but nothing beyond that. At this point, it’s time to upload the software that will turn your hardware into a playable game. First, go to Arduino’s website, download the Arduino IDE onto your computer, and launch it. (IDE stands for Integrated Development Environment.) Arduino IDE makes it easy for you to write code and upload it to your Arduino board. Next, copy and paste into your Arduino IDE, and press ‘Upload to Arduino’ (an arrow at the top left corner). The software will compile the code and send it over to the Arduino chip. the code for Snake from this developer’s page I won’t bug you with how the code works for now. We just want to get the firmware into the hardware so we can run our game. By the way, firmware means the kind of software that controls a device’s hardware. Once the firmware sits inside the Arduino, the Arduino will start executing that code. The snake will run. Turn the potentiometer to increase or decrease the snake’s speed. Move the joystick to control how the snake moves. The food will blink. And done! Happy snakin’! If you enjoyed learning about hardware, firmware, and making games, you may be interested in exploring . We offer online education and mentoring to help you build essential tech skills and amp up your career. Practicum

Using Arduino To Build Your Own ‘Snake Game’

How to Integrate Smart Contracts to the Frontend

Cómo integrar contratos inteligentes en el frontend

Intelligens szerződések integrálása a frontendbe

כיצד לשלב חוזים חכמים בחזית הקצה

スマートコントラクトをフロントエンドに統合する方法

프런트엔드에 스마트 계약을 통합하는 방법

Ухаалаг гэрээг Frontend-д хэрхэн нэгтгэх вэ

Tsela ya go Kopanya Dikonteraka tša Bohlale go Frontend

Как интегрировать смарт-контракты во фронтенд

ከመይ ጌርና ስማርት ውዕላት ናብ ፍሮንቴንድ ንወሃሃድ

Paano Isama ang Mga Smart Contract sa Frontend

Smart kontraktlarni frontendga qanday integratsiya qilish mumkin

Cách tích hợp hợp đồng thông minh vào giao diện người dùng

Friends, fellow adventurers, lend me your ears (or eyes)! Today, we’ll take a joyride into the world of RxJS to tame the sneaky gremlin known as memory leaks. Fasten your seatbelts as we unveil the mystic arts of keeping our code clean and our spirits high. JavaScript The What: Memory Leaks, The Unseen Culprits Alright, before we dive into our detective toolkit, it’s worth taking a moment to truly understand our adversary. . They might sound like something that sprouts in your garden after a heavy downpour, but trust me, they’re a lot less fun. Memory leaks Think of your application’s memory as a high-end, all-you-can-eat buffet. Your Observables are the patrons, consuming memory instead of the latest chef’s special. Normally, they’d eat their fill (perform their operations) and then leave, making room for the next hungry Observable. All’s well in our digital eatery. But here’s where memory leaks, the sneaky critters, slink in. Imagine a patron who eats, and then sits there. And sits. And sits some more. They’re not eating anymore, but they’re taking up valuable space, preventing new patrons from getting a seat. This squatter is our memory leak. In the world of RxJS, memory leaks happen when Observables linger around in memory, long after they’ve finished their tasks. They’re no longer needed, but they stick around anyway, taking up precious space. But why is this such a big deal? Well, the more memory leaks you have, the less memory is available for the parts of your application that genuinely need it. This can lead to slower processing times, and in severe cases, can even cause your application to crash altogether. Imagine your buffet getting so crowded with non-eating patrons that there’s no room left for new customers, or even for the staff to move. Chaos ensues, orders pile up, the kitchen gets overwhelmed, and eventually, the whole place could grind to a halt. That’s the kind of digital disaster we’re looking to avoid. And armed with the right tools and know-how, it’s a disaster we’re going to sidestep with grace and style. So let’s roll up our sleeves and prepare to banish these sneaky squatters once and for all! The How: Gearing Up Against Memory Leaks Now that we’ve identified the culprit, it’s time to arm ourselves with some techy tools to prevent those notorious memory leaks in RxJS. We’ve got five tried-and-true techniques here, each ready to tackle memory leaks in its unique way. Ready? Let’s dive right in! Async Pipe: The Auto-Handler users, rejoice! If you’re using Angular, you can call in the pipe in your templates to handle subscribing and unsubscribing from Observables. Angular oversees the lifecycle of the async pipe, automatically unsubscribing when the component is destroyed. Here's a glance at how this works: Angular async <div>{{ source$ | async }}</div> In this snippet, Angular is taking the wheel, managing the Observable via the pipe and ensures the Observable isn’t left unattended, preventing any mischief. As you might have already noticed, using it requires one main condition to be met. The observable has to be rendered in the template, but this is not always the case. This brings us to the trusty ‘unsubscribe’. source$ async The Trusty Unsubscribe Unsubscribing from Observables is like finishing a good book: you close it, return it to the shelf, and then move on to the next one. And just like the end of a book, you’ve got to know when to say “that’s a wrap” to your Observables. When you subscribe to an Observable, you get back a Subscription object. And this Subscription object carries an method. You'll typically want to call this method in the lifecycle hook if you're using Angular or in the case of React ( for VueJS and etc.). Here's how you do it: unsubscribe ngOnDestroy componentWillUnmount unmounted class MyComponent implements OnDestroy {

  ...

  private subscription: Subscription;

  constructor() {
    this.subscription = source$.subscribe();
  }

  ngOnDestroy() {
    this.subscription.unsubscribe();
  }
} In this Angular snippet, we tell our Observable to halt in its tracks when we're done with it by calling . It's like giving a gentle nudge, reminding it to let go. But what if you are managing a large number of subscriptions and don’t want to write repetitive code for storing subscriptions and unsubscribing? source$ .unsubscribe() The Multi-tasking Combination of takeUntil and Subject: If you’re juggling multiple subscriptions within a component, operator with a Subject has got your back. The concept here is to create a Subject that emits a value whenever subscriptions are no longer needed, for example when the component is destroyed or some other event has happened. Then, you use on every subscription. This way, you're instructing all your Observables to wrap things up when the component is on its way out. takeUntil takeUntil(this.destroy$) class MyComponent implements OnDestroy {
  private destroy$ = new Subject<void>();

  ...

  constructor() {
    observableOne$.pipe(takeUntil(this.destroy$)).subscribe();
    observableTwo$.pipe(takeUntil(this.destroy$)).subscribe();
    ...
    observableNinetyNine$.pipe(takeUntil(this.destroy$)).subscribe();
  }

  ngOnDestroy() {
    this.destroy$.next();
    this.destroy$.complete();
  }
} The tells , and others to keep on keeping on until sends a signal. Once it does, the game is up. No more precious memory is being taken! takeUntil observableOne$ observableTwo$ destroy$ Important to remember that it doesn’t have to happen only when the component is destroyed Here are two example cases: class MyComponent {
  private stop$ = new Subject<void>();
  ...

  constructor() {
    sourceOne$.pipe(takeUntil(this.stop$)).subscribe();
    sourceTwo$.pipe(takeUntil(this.stop$)).subscribe();
    ...
    sourceNinetyNine$.pipe(takeUntil(this.stop$)).subscribe();
  }

  onStopStreaming() {
    this.stop$.next();
    this.stop$.complete();
  }

} In the first one, is being triggered by event method. stop$ onStopStreaming() class MyComponent {
  private stop$ = new Subject<void>();
  ...

  constructor() {
    sourceOne$.pipe(takeUntil(this.destroy$)).subscribe();
    sourceTwo$.pipe(takeUntil(this.destroy$)).subscribe();
    ...
    
    finalise$.pipe(
      tap(() => this.stop$.next()),
      tap(() => this.stop$.complete())
    ).subscribe().unsubscribe();
  }

} And in the other one, it’s being triggered by another observable called . You can probably think of other use cases where this legendary combo can do the job greatly. finalise$ Auto-Complete Operators: The Effortless Unsubscribers Alright, code aficionados, let’s talk about some real gems from the world of RxJS: the auto-complete operators. These operators are like the unsung heroes of your Observable sequences, providing an effortless way to handle subscriptions and ensure graceful unsubscription. Get ready to let these operators take the wheel while you sit back and relax! I’ll cover each operator briefly and provide links where you can read more so that you don’t get too bored and eventually reach the end of an article. first() : The Early Bird First up, we have the trusty . Just like the eager early bird, it swiftly grabs the first emitted value from the Observable sequence and then gracefully completes, bidding adieu to any lingering subscriptions. It's all about getting a head start! first() elementAt() : The Precise Selection Sometimes, you need to be precise, like when you’re searching for your favorite song in a playlist (still can’t come up with a better example). The operator comes to your rescue by allowing you to select a specific element from an Observable sequence based on its index. Once that desired element is emitted, the sequence is automatically completed. It's like having a direct line to the value you want, ensuring your subscribers get exactly what they're looking for. elementAt() take() : The Limited Edition Next on the list is the versatile . Think of it as a limited edition collector's item. With , you can specify the number of values you want to pluck from the Observable sequence. Once it reaches that magic number, it gracefully exits the stage, leaving the spotlight on the chosen few. take() take() takeWhile() : The Conditional Watcher Last but not least, we have the observant . This operator acts as a watchful sentinel, keeping an eye on the values emitted by the Observable sequence. As long as a specific condition holds true, it dutifully passes the values along. But the moment the condition evaluates to false, it exits the stage with a graceful bow. takeWhile() These auto-complete operators are like your trusty sidekicks, taking care of the subscription lifecycle and ensuring you don’t have to worry about memory leaks. So go ahead, embrace the simplicity, and let these operators do the heavy lifting for you! Rock ’n’ Roll with Hot Observables But what if you have multiple subscriptions to one Observable? Here comes our next super start. Picture this: you’re at a concert and the band is jamming. Regardless of when you or other fans join in, the band doesn’t start the song over, right? The melody (data) keeps flowing! That’s the beauty of hot observables. They’re the cool rock stars of the RxJS world, belting out data, whether anyone is there to groove to it (subscribe) or not. The charm of hot observables is their easy-going nature. Their data production doesn’t care for the formalities of subscription; it’s like they’re in their own world, performing data sequences independently. This means you’re not stuck initiating a new data sequence for each new fan (subscriber). Sounds like a pretty sweet gig for memory and processing power, eh? Now, in the RxJS band, you’ve got some built-in functions like , , , , etc., that are born hot observables. But guess what? You can also turn a cold observable into a hot one using the or other similar operators ( , , , etc). Check this out: fromEvent() interval() of() timer() share() shareReplay() connect() connectable() // cold observable, chilling alone
const cold$ = new Observable((observer) => {
  observer.next(Math.random());
});

// hot observable, ready to rock
const hot$ = cold$.pipe(share());

// Fans (subscribers) join the party
const subscription1 = hot$.subscribe(val => console.log(`Fan 1: ${val}`));
const subscription2 = hot$.subscribe(val => console.log(`Fan 2: ${val}`));

setTimeout(() => {
  // A late fan gets the same experience
  const subscription3 = hot$.subscribe(val => console.log(`Fashionably late fan 3: ${val}`));
}, 1000); See what we did there? We transformed a lone, cold observable into a hot one with the operator. Now, no matter when the fans (subscribers) decide to join the party, they're jamming to the same data, reducing the need for multiple encores (executions). share() There you go, code rockstars! You’ve got the power of hot observables at your fingertips. Ready to rock ’n’ roll with memory efficiency? Let’s hit it! Let’s view a bit more boring example that is very common in daily life: getUserData() {...} // makes api request and returns user data as Observable
getUserAccounts() {...} // makes api request and returns user accounts as Observable
getUserTransactions() {...} // makes api request and returns user transactions as Observable
const user$ = getUserData();

// option 1: using cold observable 
const coldUser$ = user$; // API will be called 2 times
const userAccounts$ = coldUser$.pipe(concatMap((user)=>getUserAccounts(user)));
const userTransactions$ = coldUser$.pipe(concatMap((user)=>getUserTransactions(user)));

// option 2: using hot observable case
const hotUser$ = user$.pipe(share()); // API will be called once and result will be shared
const userAccounts$ = hotUser$.pipe(concatMap((user)=>getUserAccounts(user)));
const userTransactions$ = hotUser$.pipe(concatMap((user)=>getUserTransactions(user))); <div>{{ userAccounts$ | async }}</div>
<div>{{ userTransactions$ | async }}</div> Both and utilize a response from a common observable. The advantage of using the observable (as in option 2) is that the API for fetching user data will be called only once since there will be a single subscription, and the response will be shared. userAccounts$ userTransactions$ hotUser$ The Wrap: You’re Now a ‘Leak Detective’ And that’s a wrap, folks! Armed with , , , and many others, you're now a certified RxJS memory leak detective. You're ready to charge into the battlefield, slaying memory leaks left and right. async unsubscribe takeUntil Just remember, the secret to keeping your code clean is understanding and vigilance. With these trusty tools and strategies, you’re on your way to crafting efficient, leak-free code. Good luck, fellow code warriors. May your code be bug-free and your coffee strong! Also published here. Lead image by Lokajit Tikayatray

Mastering RxJS Memory Leaks: The Leak Detective Handbook

How to Build a Web3 NFT Cross-Breeding Dapp with React, Solidity, and CometChat

“Whoever controls the DNS, controls the universe” (image credit: OpenAI Dalle2) spice The following article will provide a very brief overview of what DNS actually is, and what makes it “authoritative”. Then, I will discuss why you may choose to disregard its authority in some cases in order to have a better browsing experience and gain a bunch of superpowers using a service our team has built over the last 2 years. Strap yourself in. What is DNS First things first: what is DNS? DNS (Domain Name System) is a distributed “phone book” that maps (domain) names to IP addresses. When you enter hackernoon.com into your browser, it will query the router on your network for the IP address of hackernoon.com. Your home router doesn’t perform any DNS resolution and forwards the request upstream to whatever DNS server is configured there. This could be your ISP or a 3rd party resolver like Cloudflare 1.1.1.1 or Google 8.8.8.8. These resolvers are typically recursive in nature, meaning they reach out to the root DNS servers for the .com zone, and perform a recursive lookup against the authoritative DNS servers for the DNS zone (hackernoon), and then you finally get the IP(s) that hackernoon.com resolves to. So your DNS query takes the following route (simplified view): Your Device → Router → DNS Provider → Root Name Server → Authoritative Server → IP Address Saul Goodman explains this best. This process is fairly slow and can take ~1s, so typically the response is cached by the DNS provider for some period of time so the next lookup can be served from a cache. Your browser will also cache the response for the duration of the TTL associated with a particular DNS record, so as not to initiate a DNS query every single time. The responses that the authoritative DNS server emits are typically static. This means that any user, anywhere, asking any DNS server “where is hackernoon.com” will get the same response: yegor@Work-Desktop:~$ dig +short hackernoon.com 172.67.69.96 104.26.11.89 104.26.10.89 There are some notable exceptions to this when it comes to CDNs, which will geo-code your source IP, and return variable results based on your location. A user in the UK will see different IPs than a user in the US. This is done for performance reasons, so people in different countries connect to the nearby CDN location in order to reduce latency. That being said, you’re still bound by what the authoritative DNS server returns (or doesn’t). The above flow is true for pretty much every single thing that you do online that communicates with a remote server. Every web resource you download,  every API call you make, and every Git commit you do resolves a domain to an IP address that the authoritative DNS server returned. What if you could disregard what the authoritative server tells you? What advantages (superpowers) does that have? Let’s dive in. What is Control D Control D, as you probably guessed, is a DNS service. It can do all the things your standard DNS provider can (resolve  domains), but it can also do a lot more. Control D is a user-configurable DNS service that offers transparent proxies deployed on top of an anycast network, with exit locations in over 69 countries. Sure, that all sounds impressive, but what does it ACTUALLY do? When you get started with Control D, you will get a set of DNS resolvers that are unique to your account and can enforce your unique configuration. Think of it as your personal authoritative DNS server, for the entire Internet. You can customize your configuration via a simple web interface, as there are no required apps to install to use the service.  Control D supports multiple DNS protocols: - least secure, but most widely supported Legacy IPv4/IPv6 - most secure, supported by modern OSes DNS-Over-HTTPS (DoH) - most secure, supported by modern OSes DNS-Over-TLS (DoT) The first protocol offers the best compatibility and can be used on any Internet connectable device. Legacy DNS is not encrypted, so it can be easily intercepted and manipulated by your ISP, or network administrator. The latter two offer you the best privacy and security, as your DNS queries are encrypted with TLS and cannot be intercepted or manipulated. Think of it as: Legacy = HTTP DoH/DoT = HTTPS What’s the difference between DoH and DoT and which one is better? Honestly, just stick with DoH, as it operates on TCP port 443 and is indistinguishable from normal HTTPS traffic. DoT operates on a special port (853) and is easily detectable (and therefore easily blocked). The advantages of DoT (less overhead and therefore faster resolution time) are debatable, and we have not seen them in practice. Mind you, on some platforms like Android, you have no choice but to use DoT, as DoH is not supported ( ). but will be soon Once you configure one of the DNS resolvers on your device (router, computer, browser, phone) your DNS queries will be steered to the Control D network. By default, if no settings are changed, Control D will behave like a standard DNS resolver, no different than Cloudflare, Google, or your local ISP. Once you start fiddling with the knobs, you can do of neat things, by selectively disregarding authoritative DNS records and substituting your own. all kinds Block a category of sites (ads, or porn for example) Block malicious domains non-malicious domains that point to malicious IPs and Block a specific service (Facebook, or TikTok) Block a specific TLD, FQDN, subdomain, or a wildcard entry (i.e. server-*.domain.com) Spoof a service, TLD, FQDN, subdomain, or all DNS queries to a specific IP address of your choice (think a wildcard-supporting hosts file) Redirect a specific service through a proxy location (BBC iPlayer through London, for example) Redirect a specific TLD, FQDN, subdomain, or wildcard entry through a proxy location (All .ca domains get proxied through Toronto) Redirect resolved DNS queries through a specific proxy location (there are over 100 cities to choose from) all Override blocks enforced by category filters, or services Schedule any of the above behavior to kick in at a certain time of day A whole bunch more TL;DR: Control D allows you to selectively disregard the authoritative DNS records associated with any domain you attempt to resolve (regardless of it actually existing in public DNS), and replace the answers with anything you want. This can prevent the domain from loading by spoofing  it to an IP of your choice (like 127.0.0.1), or to one of over 100 supported by Control D. Then, Control D will transparently proxy SNI (and some non-SNI) enabled traffic through servers in that location/country. exit locations You can also block, spoof, and redirect ALL of your DNS queries by using the catchall "Default Rule". Bad Use Cases You wouldn’t use a hammer to perform dental surgery (hopefully) - every tool has its use case. The same applies here, so before we jump into why you use a service like Control D, let's spend a moment talking about why you . should shouldn't Life Critical Anonymity If you live in a country where freedom of speech is non-existent, or you are a whistleblower, dissident or political activist, you should not use Control D to stay safe online. Despite Control D encrypting your DNS queries, even if you are using the proxy capabilities to spoof your location, the Server Name Indication (SNI) TLS extension is still transmitted in plaintext. This means that on adversarial networks where this information is captured and filtered, Control D will not provide you any security benefits. It will not be able to unblock restricted sites, and your browsing history could still be captured by the network administrator. If this is your particular use case, you are much better off using a (shameless self-plug as Windscribe is our sister company). Do keep in mind that a VPN is not a magical security solution either, despite what you may have heard from your favorite YouTuber while they react to videos of people describing the taste of meat to vegetarians. trusted, no-logging VPN Their scripted “opinions” are worth less than the Zimbabwean dollar.  A VPN is just tools that should be in your toolbelt if you care about these things.  I could rant all day about this, but let’s move on. one of the many BitTorrent Control D will not affect the BitTorrent protocol. Since this is a P2P protocol, which does not rely on DNS, all your torrent activity will be in the clear. Control D offers an optional filter that will block all common torrent indexes and trackers, which will make the use of the BitTorrent protocol difficult on the network where Control D is deployed (and this Filter enabled), but it will not 100% eliminate all torrent activity. If you wish to apply a layer of privacy to your torrent activities, you should use a VPN. Gaming (Improvements) Many people use VPNs for gaming in order to "improve ping" or mask their IP from trolls. The efficacy of this is , but Control D is unlikely to help here. In fact, there is a good chance that if you redirect all your traffic to our proxies, it will break some games entirely. debatable We recommend disabling Control D functionality if you experience problems playing your favorite games. You can do this from the section of the control panel; simply find your game and create a rule. Services BYPASS Actual Use Cases So now that we got that out of the way, what CAN you use Control D for? The following list is not exhaustive but should give you an idea of the flexibility you can achieve. Block Ads, Trackers, and Malware (and many other things) Yes, you can use a browser extension like uBlock that will do a really good job blocking things in your browser (until anyway, when we all eat a Google turd sandwich). January of 2023 However, this will just block ads in your favorite desktop browser. All tracking (and ad delivery) that happens outside of the browser (OS, installed programs, mobile applications, and browsers) will get through. If you set up Control D inside the operating system, or on your router, all DNS queries that any application makes (including the browser) will query your personal resolver, and all your rules apply. This means you can eliminate 99% of all ads and trackers (as well as 14 other categories)  from even loading on your devices. This effectively creates a network/system-wide ad block, which is highly effective. With this in mind, you can block many other categories, including: Malware distributing, typosquatting, and phishing domains (if you accidentally click a shady link) Adult content (handy on networks with kids) Social networks (stop wasting time looking at your "feed") IoT telemetry (prevent your fridge from talking to servers in China) Gambling, Drugs, Dating sites (keep your vices in check) A whole bunch more Help with Dev Efforts You’re probably familiar with the host’s file, which allows you to define domain names that may not exist in public DNS. You can also use it to override the DNS responses that are in public DNS to point to your local dev machine or a remote dev server. With Control D you can have a remote hosts file. This has several advantages: You can enforce the same host’s file on all your dev/test devices, including a mobile (or your smart toaster) Control D supports wildcards entries, so you can redirect all subdomains with a single rule Simulate regional access to your project from over 100 city-level locations Eliminate Your Pi-Hole Pi-Hole is a great tool to control your network, deploy custom blocklists, and have visibility on what is being resolved, but there are downsides: Pi-Hole only works on your home network – Control  D works on all networks, including cellular. You have to manage blocklists yourself – Our bespoke filters are built on top of community-maintained blocklists, with tens of thousands of false positives removed, based on feedback from 45M Windscribe users. We did all the work for you! Lack of advanced blocking – Pi-Hole only blocks domain names. Control D malware filter also blocks domains that resolve to malicious IPs from threat intelligence feeds. Lack of scheduling or flexibility – With Control D, your rules don't have to be static. They can change day to day, and be different on different devices. You have to run it yourself – Control D is deployed on top of a global anycast network, is available everywhere, including cellular networks, and supports Secure DNS protocols out of the box. (Selectively) Spoof Your Location Unlike a VPN, which sends all your activity to a single server in a chosen country, you have a lot more, well, when you use Control D. Since it operates at the DNS layer, you can create all kinds of rules in your configuration to do all kinds of things. control Here is a silly example of 7 different websites seeing you in 7 different places, all at once: You can instruct Control D to resolve different FQDNs through proxies in different countries, with as little as 3 clicks. When your browser asks to resolve a domain that has a rule, Control D will return a proxy IP instead of the true IP of the destination (disregarding the authoritative answer). It will read the SNI, and forward the end-to-end encrypted request to the site you wanted to load. From here, we can get fancier. Instead of creating individual rules, you can create a folder of rules, and assign an action (block, redirect, or bypass) to it. Any domain you add to this folder will inherit and apply the chosen folder rule. Don't want to make your own rules? That's where the Services section comes in. We've created rules for over 200 most common services online, and this list is always growing based on . user requests With a single toggle switch, you can apply a chosen rule to a video streaming service, an audio service, a store, a tool, a social network, or a game.  Each service can be redirected through a unique location (or blocked entirely), so you can appear to be in 69 countries, all at once. Lastly, you can redirect all your activity through the closest , if you don't care about the geolocation of your IP. This will have the best performance and supports IPv6 end-to-end. Control D Primary Location Optionally, you can choose a specific exit location (city), which will double hop your traffic from the closest Control D Primary Location to a Windscribe VPN server in the chosen country. All of this is without having to install a VPN app. You can use all 3 behaviors in parallel to create some very unique browsing profiles. The rule engine works as follows: Custom rules take precedence over everything Service rules are second in line, and are checked if there are no custom rules that match the DNS query Filters (which block things) are 3rd in-line and will match a domain if there is no overriding custom rule or Service rule Last in line is the Default Rule, which will, like the name suggests, match queries that aren't affected by any of the above Parental/Productivity/Impulse Controls The internet is full of distractions and outright harmful content. You may choose to block certain types of content at certain times of day (or all the time) so you can get stuff done, or prevent your kids from wasting time when they should be doing their homework. Control D gives you the tools to block large categories of distractions (social networks and games) so you can concentrate on your school or work. You can also use the same tools to block harmful content like porn, drugs, and malware on your network if you have kids. You can make these rules permanent, or time-based using the Scheduler. Here are some examples: Block social networks and games every Monday to Friday, and allow playtime on the weekends during certain hours Block porn, Reddit, and TikTok Monday to Friday 9 am to 5 pm so you can remain gainfully employed and boost your productivity British TV Fridays: Every Friday your Netflix and Disney+ shows British content Shopping Tuesday Mornings: All popular shopping sites are blocked every day except for 1hr on Tuesday morning. Then you can decide if you REALLY needed those $800 custom sock puppets you found at 3 am after a few drinks, and thought were super cool. Unique Device Configurations You're not limited to a single set of rules. Each account allows you to have up to 10 unique browsing profiles (configurations), and you can then create up to 10 devices and enforce your configurations using unique per-device DNS resolvers. Your personal laptop and phone can have one profile,  your partner's iPad could use another, and your kids' phones can use the rest. Each physical device can be configured to access or block a unique set of filters, services, and custom rules. Conclusion As you can see, there's a you can achieve with Control D, and this article really only scratches the surface. I recommend you (no payment details required!) and play around with it - I think you will be pleasantly surprised. It's time to take back control of your Internet experience. lot get yourself a trial account PS. The service is very much in active development, so if you have an idea or a suggestion, don’t hesitate to send us any and all feedback. We release new stuff weekly.

What Is DNS and Why You Should Control It

How to Accept Crypto Payments in a Classic Commerce App

In this article, I will be showing you how to create a Dapp that allows us to store data on the Arweave network, using bundlr on testnet. Before going forward, let’s see what are we going to build today. https://www.loom.com/share/808aff5aa5d84ead93c106cfb96ff05f?t=70 Here is the deployed link if you want to try it out: https://bundlr-arweave.netlify.app/ Tech Stack and Libraries I’ve Used: Nextjs Chakra UI RainbowKit Wagmi Bundlr Client Well, Well, Let’s Go Through What Is Arweave and Bundlr First (From the Doc). If you enjoy videos like me, here is a video for you: https://www.youtube.com/watch?v=DQbwiiXMtMo Arweave Arweave makes information permanence sustainable. Arweave is a new type of storage that backs data with sustainable and perpetual endowments, allowing users and developers to truly store data forever — for the very first time. Bundlr Bundlr makes web3 data storage on Arweave accessible by making it as fast, easy, and reliable as traditional data storage. Arweave is the only truly decentralized, permanent data storage solution. Bundlr increases the number of transactions conducted on Arweave by 4,000% without sacrificing security or usability and is around ~3,000x faster at uploading data. Bundlr currently accounts for over 90% of data uploaded to Arweave. It enables infinite scalability and enables instant and guaranteed transaction finality. It is a multichain solution and is compatible with leading blockchains including Ethereum, Solana, Avalanche, Polygon, and many more. Steps We Have to Follow to Upload to Arweave using Bundlr Connect wallet Initialize the Bundlr client Add funds ($BNDLR tokens) Upload the files we will be bulding this app on polygon mumbai testnet. Bundlr has a devnet which allows you to use devnet/testnet cryptocurrency networks to pay for storage. The devnet node behaves exactly as a mainnet node - other than data is never moved to Arweave and will be cleared from Bundlr after a week. Note: Let's Get Building Keep the completed code open on the side for a better understanding . Github 1. Setting up the project Setup a Nextjs project with tailwind CSS and Chakra UIYou can use package to get done with setup quickly or just clone this Also, install these two dependencies create-web3-frontend . project repo yarn add @bundlr-network/client bignumber.js 2. Connect wallet As we are using Rainbow kit this step is very easy in index.tsx const Home: NextPage = () => {
  const { data } = useAccount();
  if (!data) {
    return (
      <div className='justify-center items-center h-screen flex '>
        <VStack gap={8}>
          <Text className='text-4xl font-bold'>
            Connect your wallet first
          </Text>
          <ConnectButton />
        </VStack>
      </div>
    )
  }

  if (activeChain && activeChain.id !== chainId.polygonMumbai) {
    return (
      <div className='justify-center items-center h-screen flex '>
        <VStack gap={8}>
          <Text className='text-4xl font-bold'>
            Opps, wrong network!! Switch to Polygon Mumbai Testnet
          </Text>
          <ConnectButton />
        </VStack>
      </div>
    )
  }
} And with these 5–6 lines of code, we are done with connecting the wallet 🎉 We have also added a condition to check if a user is on the Mumbai test, as we will be using polygon Mumbai testnet for this article. In while configuring Rainbow kit we have configures it for using polygon Mumbai testnet _app.jsx const { chains, provider } = configureChains(
  [chain.polygonMumbai],
  [
    jsonRpcProvider({ rpc: () => ({ http: process.env.NEXT_PUBLIC_ALCHEMY_RPC_URL }) }),
    publicProvider(),
  ]
); So, Rainbow kit will also take care of changing the network for us, this is how this warning will look like 3. Initializing the Bundlr Let’s create a context for bundlr, so we can maintain all bundlr related logic form there. Create . Inside this file let's create the context now, you can see the completed version of the file bundlr.context.tsx here import { WebBundlr } from '@bundlr-network/client';
import { useToast } from '@chakra-ui/react';
import BigNumber from 'bignumber.js';
import { providers, utils } from 'ethers';
import React, { createContext, useContext, useEffect, useState } from 'react'

const BundlrContext = createContext<IBundlrHook>({
    initialiseBundlr: async () => { },
    fundWallet: (_: number) => { },
    balance: '',
    uploadFile: async (_file) => { },
    bundlrInstance: null
});

const BundlrContextProvider = ({ children }: any): JSX.Element => {
    const toast = useToast()
    const [bundlrInstance, setBundlrInstance] = useState<WebBundlr>();
    const [balance, setBalance] = useState<string>('');

    useEffect(() => {
        if (bundlrInstance) {
            fetchBalance();
        }
    }, [bundlrInstance])

    const initialiseBundlr = async () => {
        const provider = new providers.Web3Provider(window.ethereum as any);
        await provider._ready();
        const bundlr = new WebBundlr(
            "https://devnet.bundlr.network",
            "matic",
            provider,
            {
                providerUrl:
                    process.env.NEXT_PUBLIC_ALCHEMY_RPC_URL,
            }
        );
        await bundlr.ready();
        setBundlrInstance(bundlr);
    }

    async function fundWallet(amount: number) {
        try {
            if (bundlrInstance) {
                if (!amount) return
                const amountParsed = parseInput(amount)
                if (amountParsed) {
                    toast({
                        title: "Adding funds please wait",
                        status: "loading"
                    })
                    let response = await bundlrInstance.fund(amountParsed)
                    console.log('Wallet funded: ', response)
                    toast({
                        title: "Funds added",
                        status: "success"
                    })
                }
                fetchBalance()
            }
        } catch (error) {
            console.log("error", error);
            toast({
                title: error.message || "Something went wrong!",
                status: "error"
            })
        }
    }

    function parseInput(input: number) {
        const conv = new BigNumber(input).multipliedBy(bundlrInstance!.currencyConfig.base[1])
        if (conv.isLessThan(1)) {
            console.log('error: value too small')
            toast({
                title: "Error: value too small",
                status: "error"
            })
            return
        } else {
            return conv
        }
    }

    async function fetchBalance() {
        if (bundlrInstance) {
            const bal = await bundlrInstance.getLoadedBalance();
            console.log("bal: ", utils.formatEther(bal.toString()));
            setBalance(utils.formatEther(bal.toString()));
        }
    }

    async function uploadFile(file) {
        try {
            let tx = await bundlrInstance.uploader.upload(file, [{ name: "Content-Type", value: "image/png" }])
            return tx;
        } catch (error) {
            toast({
                title: error.message || "Something went wrong!",
                status: "error"
            })
        }
    }

    return (
        <BundlrContext.Provider value={{ initialiseBundlr, fundWallet, balance, uploadFile, bundlrInstance }}>
            {children}
        </BundlrContext.Provider>
    )
}

export default BundlrContextProvider;

export const useBundler = () => {
    return useContext(BundlrContext);
} For initializing the Bundlr we will be using the method from the code above initialiseBundlr and the code is also pretty straightforward const bundlr = new WebBundlr(
            "https://devnet.bundlr.network",
            "matic",
            provider,
            {
                providerUrl:
                    process.env.NEXT_PUBLIC_ALCHEMY_RPC_URL,
            }
        );
        await bundlr.ready();
        setBundlrInstance(bundlr); We are creating an instance of the Bundlr client and storing it in a state variable. Read more about For using Bundlr with testnet . bundlr client read here In order to use the devnet, you need to use as the node and set the provider url to a correct testnet/devnet RPC endpoint for the given chain. https://devnet.bundlr.network Our, RPC URL will look something like this, as we will be using polygon testnet NEXT_PUBLIC_ALCHEMY_RPC_URL=https://polygon-mumbai.g.alchemy.com/v2/{{alchemy_project_id}} Read, about all the supported . currencies/ networks by bundlr here 4. Add funds ($BNDLR tokens) 💸 We already have data about our in the bundlr context, and we also have a method which we will be using to add the funds. Adding funds is also pretty straightforward, just use the method on the bundlrInstance and pass the amount you want to fund the wallet with balance fundWallet fund let response = await bundlrInstance.fund(amountParsed) In , make these changes index.tsx const Home: NextPage = () => {
    const { initialiseBundlr, bundlrInstance, balance } = useBundler();
    ...

    // at last
    if (!balance || Number(balance) <= 0) {
        return (
          <div className='justify-center items-center h-screen flex '>
            <VStack gap={8}>
              <ConnectButton />
              <Text className='text-4xl font-bold'>
                Opps, out of funds!, let's add some
              </Text>
              <FundWallet />
            </VStack>
          </div>
        )
      }
} Now let’s create the component. Create <FundWallet /> components/FundWallet.tsx import React from 'react'
import { Button, NumberDecrementStepper, NumberIncrementStepper, NumberInput, NumberInputField, NumberInputStepper, Text, VStack } from '@chakra-ui/react'
import { useBundler } from '@/state/bundlr.context';

const FundWallet = () => {
    const { fundWallet, balance } = useBundler();
    const [value, setValue] = React.useState('0.02')

    return (
        <div className='mt-12'>
            <VStack gap={6}>
                <Text fontSize={'xl'}>
                    Your current balace is: {balance || 0} $BNDLR
                </Text>
                <NumberInput className='mx-auto' step={0.01} defaultValue={value}
                    onChange={(valueString) => setValue(valueString)}
                >
                    <NumberInputField />
                    <NumberInputStepper >
                        <NumberIncrementStepper />
                        <NumberDecrementStepper />
                    </NumberInputStepper>
                </NumberInput>

                <Button onClick={() => fundWallet(+value)}>💸 Add Fund</Button>
            </VStack>
        </div>
    )
}

export default FundWallet 5. Upload images 📷 Now, as we’ve already added the funds, now we can upload the images (or any other files), to the Arweave network. In , add the following code at the end of the file index.tsx return (
    <div className='justify-center items-center h-screen flex'>
      <Stack direction={['column', 'row']} justifyContent={'space-around'} width={'full'} alignItems={'center'}>
        <VStack gap={8}>
          <ConnectButton />
          <FundWallet />
        </VStack>
        <VStack gap={8}>
          <Text fontSize={'4xl'}>
            Select Image To Upload
          </Text>
          <UploadImage />
        </VStack>
      </Stack>
    </div>
  ); Now, let’s create the component <UploadImage /> import React from 'react'
import { Box, Button, Text } from '@chakra-ui/react';
import { useBundler } from '@/state/bundlr.context';
import { useRef, useState } from 'react';

const UploadImage = () => {
    const { uploadFile } = useBundler();
    const [URI, setURI] = useState('')
    const [file, setFile] = useState<Buffer>()
    const [image, setImage] = useState('')
    const hiddenFileInput = useRef(null);

    function onFileChange(e: any) {
        const file = e.target.files[0]
        if (file) {
            const image = URL.createObjectURL(file)
            setImage(image)
            let reader = new FileReader()
            reader.onload = function () {
                if (reader.result) {
                    setFile(Buffer.from(reader.result as any))
                }
            }
            reader.readAsArrayBuffer(file)
        }
    }

    const handleClick = event => {
        hiddenFileInput.current.click();
    };

    const handleUpload = async () => {
        const res = await uploadFile(file);
        setURI(`http://arweave.net/${res.data.id}`)
    }

    return (
        <div className='flex flex-col mt-20 justify-center items-center w-full'>
            <Button onClick={handleClick} className='mb-4'>
                {image ? 'Change Selection' : 'Select Image'}
            </Button>
            <input
                accept="image/png, image/gif, image/jpeg"
                type="file"
                ref={hiddenFileInput}
                onChange={onFileChange}
                style={{ display: 'none' }}
            />

            {
                image &&
                <Box
                    display='flex'
                    alignItems='center'
                    justifyContent='center'
                    width='100%'
                    py={40}
                    bgImage={`url('${image}')`}
                    bgPosition='center'
                    bgRepeat='no-repeat'
                    mb={2}
                >
                    <button className='bg-gray-200 rounded px-8 py-2 text-black hover:bg-gray-100' onClick={handleUpload}>Upload File</button>
                </Box>
            }

            {
                URI && <Text className='mt-4'>
                    <Text fontSize='xl'> Uploaded File:</Text> <a href={URI} target="_blank">{URI}</a>
                </Text>
            }
        </div>
    )
}

export default UploadImage And, with this in place, we can now upload the files to the Arweave network 🚀 Further Improvement: Right now we are only uploading images, we can add support for other formats as well (video, audio, anything) Store URLs of uploaded images with wallet address in Supabase and show the list of files previously uploaded by users when they connect their wallet Completed code: GitHub Also published . here

Permanent File Storage for Web3 Apps With Arweave, Bundlr, Next.js, RainbowKit, and Wagmi

Over the past few years, IoT has become one of the most important technologies of the 21st century. The Internet of things (IoT) describes physical objects that connect and exchange data with other systems over the Internet. A thing, on the internet of things, can be a person with a heart monitor implant, a farm animal with a biochip transponder, an automobile that has built-in sensors to alert the driver when tire pressure is low or any other natural or man-made object that can be able to transfer data over a network (even something basic in your kitchen). The concept of the "Internet of things" and the term itself, first appeared in a speech by Peter T. Lewis, in September 1985. According to Lewis, "The Internet of Things, is the integration of people, processes and technology with connectable devices and sensors to enable remote monitoring, status, manipulation and evaluation of trends of such devices." Now that we can connect everyday objects to the internet via embedded devices, seamless communication is possible between people, processes, and things. By means of low-cost computing, the cloud, big data, analytics, and mobile technologies, physical things can share and collect data with minimal human intervention. IoT can also make use of artificial intelligence and machine learning to aid in making data collecting processes easier and more dynamic, considering that now cars can communicate with the buildings, that connect and communicate with human personal assistants (like Alexa) which can also communicate with your kitchen stuff and back communicate with other sensors around the city. Going forwards, sensors  could be used to monitor events or changes within structural buildings, bridges and other infrastructure. This brings benefits with it, such as cost saving, saved time, quality-of-life workflow changes and paperless workflow. A home automation business can utilize IoT to monitor and manipulate mechanical and electrical systems in a building. On a broader scale, smart cities can help citizens reduce waste and energy consumption. But security is the biggest concern in adopting Internet of things technology, with concerns that rapid development is happening without appropriate consideration of the profound security challenges involved and the regulatory changes that might be necessary to protect personal data and privacy. IoT wearables enable people to better understand their own health and allow physicians to remotely monitor patients. This technology also enables companies to track the health and safety of their employees, which is especially useful for workers employed in hazardous conditions. The precious thing here, is that now we can collect this large amount of data (non-personal), bring some Data Science to the conversation and predict healthcare concerns in a population or a trend in terms of risk to human health. In this hyperconnected world, digital systems can record, monitor, and adjust each interaction between connected things. The physical world meets the digital world, and they cooperate. Thank you for reading another article here! I hope you enjoyed! There's even more good things I've prepared for you! Do you want to read some book notes and recommendations? Discover more here! Do you want to have amazing weekly content curation? Discover more here! Follow me on - - LinkedIn Twitter Instagram Originally published . here

The IoT At  A Glance

My name is Dmitriy Dudarev. I develop electronics, and I love to create different portable devices. I also love music. A long time ago, in April 2020 or so, when the whole world was shaken by the terrible quarantine, I decided to learn to play guitar. I borrowed an acoustic guitar from a friend of mine and started to study the instrument by lessons on YouTube and tablatures. It was hard. Maybe, I was doing something wrong, maybe, I didn’t try hard enough, or maybe, fine motor skills prevented my predecessors from reproduction. All in all, I couldn’t produce anything but sounds of rattling strings. The constant mistuning of the strings strengthened my resentment. And my neighbors got no pleasure from listening to my uneven “Nothing Else Matters” thousands of times. But, in the middle of all these sufferings, I haven’t forgotten the main rule of a techie. If something exists, you can insert a microcontroller there. Or, at least make a portable electronic modification. Electronic guitar? Hum, an interesting idea, I thought. But it would be even better if I could learn to play this guitar myself. On the same day, the acoustic guitar was returned to my friend, and I started to develop the idea. As I’m an innate engineer; I made a list of requirements for the device. What do I want from my guitar? I want something that looks like a guitar as much as possible, that is, six strings and at least 12 frets on the fingerboard. 1) I want it to be compact and portable. So that I can take the device wherever I go, not having to book a truck for transportation. 2) The device should be able to connect to anything without any tricks — from iOS to Windows. Ok, ok, let’s be realistic– to all the popular OSs. 3) Work using a battery. 4) The connection should be wireless (However, there will be a USB-port for recharging and connectable using a wire too) 5) The most important point — learning to play the guitar should be easy, without the necessity for long training on wrist ligament adaptation. So, how do I make it come true? It occurred to me to equip the guitar and the strings with LEDs. For example, you upload tablatures in your guitar, and it shows you itself where to put your fingers. That is, there is nothing like looking at the screen, then at the guitar, then again at the screen, and again at the guitar. I don’t need all this stuff. You look only at the guitar. And you play the same guitar. That’s all. That’s what my idea was! 6) I’d like to have the support of different playing techniques: hummer on, pull off, slide, vibrato. 7) No retards. Speaking scientifically, the delay of midi-commands shouldn’t exceed 10ms. 8) Everything should be assembled “from shit and sticks” — easily available materials without complicated technical processes and expensive electronics. 9) As a result, we should get a compact instrument that I can play like a guitar free from the shortcomings of an analog one, equipped with a visual learning system; it sounds realistic. Of course, we need to write an app for mobile platforms, and you can choose a tablature for training with LEDs, choose an instrument (acoustic, classical, electric guitar with different filter presets, ukulele, etc.), and make sounds. Existing analogs But do I need to invent a bike? Because for each great idea, there is always a Chinese person who has already done it “in hardware” and made it better than you were going to initially. I’m looking it up on Google. The first digital guitar turned out to have been created back in 1981, but it hasn’t become popular because of its weak functionality. More modern variants have also been found, for sure. For example, with an iPad instead of strings, or another, in the shape of a mollusk: However, fulfilling all my wishes–first of all, compactness and “press-on-LEDs” training mode — there is no such a thing. Besides, such midi-guitars are still purposed for a more skilled audience. Moreover, they are expensive. So let’s go! First prototype In order to check the viability of a concept, I need to determine the element base at first. Let’s take the STM32F042 controller. It has everything I need, and it costs less than a buck. Except for the wireless connection, but we will return to it later. Let’s go ahead — strings on the soundboard. For the first concept, I decided to print plastic reeds, attach them to potentiometers with springs and measure deviation angles. That’s how 3D-model looks like: And that’s in reality: It feels pleasant. It should work. For frets on the fingerboard, I’ve ordered on AliExpress such tenso-resistors. Unlike different buttons, they don’t click. It is also possible to define the strength of pressure, which means that I can play complicated techniques like slide or vibrato. I also need ADC to read the info from sensors and transmit it to the controller. While I was waiting for sensors from China, I made a PCB layout: Before ordering board printing, I decided to wait for piezoresistors. And, as it turned out, it wasn’t in vain. Of 80 sensors, only a few were working, and even they had different parameters. To put it mildly, it doesn’t look the way it was declared. But what was I expecting when I bought the components on AliExpress? And then it dawned upon me. I can apply another detection method — capacity measuring like in touch sensors. That’s much cheaper and more accessible. And if I design the mechanicals correctly, I’ll be able to define the effort. Well, I’m removing everything that was done before. Second prototype Well, let’s do away with the piezoresistors! For sensor elements, this time, I took small copper cylinders sawed from a wire. For capacity measuring, I could find an affordable 12-channel universal capacitometer. It measures capacity in picofarad units, which should be enough for a scheme of strength measuring, which I’m going to implement in the following modifications. Additionally, just in case, I’ve hung a seat for a button or something of the kind on each element of the fingerboard, and made cuts in the board so that I could not only touch the cylinder but also press on it inside. I’ll try to experiment with different playing techniques. Having solved the question of connecting a lot of chips of capacitometer to the controller, I’m starting the board wiring. This time I could order the board and even wait till it is ready. After the components, copper cylinders, and potentiometers are soldered, I understood that construction with plastic strings is too complicated. So for a while, I decided to hang the same sensor cylinders on the soundboard, but a bit longer. Two little wires in the lower part — I’ve connected a plate with cylinders to the board. It is a temporary solution. The hard part is done. The next step is to make it play. Software The program part was created as follows: Downloading the virtual synthesizer, which can work with midi-device and produce guitar sounds. 1. Writing firmware for controller, which will poll the sensors and transmit the data via USB to the PC. 2. On the part of the PC, I wrote the program which will receive these data, generate midi-packages of them, and send them to the virtual synthesizer from point 1. 3. Now every step in detail: I found quite a lot of virtual synthesizers for Windows with midi support. I tried Ableton live, RealGuitar, FL studio, and Kontakt. I stopped on RealGuitar because it is easy and designed especially for guitar. It can even imitate the imperfection of human play — fingers sliding along the strings, randomized parameter of note production. To connect my app to the virtual synthesizer, I emulated a virtual midi-port which is connected to the input of the virtual synthesizer RealGuitar via an emulator of midi-cable — such as a multi-level emulation. In the program interface, I’ve made graphic imaging of the measured capacity level for each sensor. This way, it will be easier to tune the sound. Besides, for the future, I added the elements for control of LEDs, vibromotor (I don’t know yet, why, but it will be in the guitar, too), visualization of accelerometer work, and battery charge level. To make the hits on guitar strings cause correct notes, I need to map all the 72 sensors on the fingerboard to the respective note. I found that, of 72 elements, on 12 frets, there are only 37 unique notes. They are located by a certain structure so that instead of building a large table, I could make up a simple equation, which generates a number of respective notes by the number of sensors. Checking the work It looks like everything is ready for the first test. I was too lazy to saw the rods and solder all the 12 frets, so I was happy with eight. The moment of truth: IT’S ALIVE! The proof of concept is confirmed. My happiness had no bounds! But I mustn’t relax. The next stage is adding LEDs, accelerometer, vibromotor, battery, wireless connection, body, and the possibility of work without drivers or midi emulation programs on all the popular platforms. LEDs According to my plan, the guitar should prompt the user where he should put his fingers by lighting a LED at that point. In total, we need 84 LEDs. It is easy. I took 14 8-bit shift registers and connected them in a daisy chain. STM transmits the data to the first register, the first one — to the second one, the second one — to the third one, etc. And all this — through DMA, without participation of controller core. Accelerometer The simplest accelerometer — LIS3D — will enable the guitar to define its descending angle. In the future, I’ll use it for sound filter applications while I play, depending on the guitar position. Wireless connection For wireless data transmission, I decided to put ESP32. It supports different Bluetooth and WI-FI protocols; there will be something to experiment with (at that time, I hadn’t known yet that in my case, there is only one correct way of connection). Body One of the key requirements of the guitar is its portability. So it should be foldable, which means that I must allocate electronic components of the soundboard and the fingerboard into two boards and connect them using a ribbon cable. Power will be supplied when the body opens when the magnet of the fingerboard approaches the Hall sensor on the soundboard. Prototype revision Well, it is time to dress the device in a nice outfit. I did a lot of experiments with tactile elements of the fingerboard and diffusers for LEDs. I’d like the whole surface of the element to shine evenly, but at the same time, there should be a possibility of touch detection and pushing the buttons. There are some of these experiments here: I also consulted with a friend of mine, an expert in industrial design. We invented the construction of guitar folding, after which he projected and printed the body prototype. I’m creating the final variant of the board and assemble the guitar: Looks almost cool. But the device is still connected to the PC via a chain of emulators which emulate other emulators. Turning the guitar into a midi-device In the new version, first of all, I’d like the guitar to be defined as a midi-device without unnecessary programs when connected via USB. I found that it was not so difficult to do it. All the specifications can be found on the official website usb.org. But all the algorithms performed on the part of python-app had to be rewritten in C to the controller. I was surprised that it started to work on all the devices: Windows 10, MacOS, Debian 9, Android (via USB-adapter). You can only insert the cable, and a midi-device named Sensy appears in the system and is read by all the synthesizers. I couldn’t test it on the iPhone yet because I’ve got no adapter. But it should work the same way. Wireless interface Now it is time to get rid of the wires. The right solution hasn’t come to me because I was too lazy to properly look it up on Google. But, as a result, I used the BLE MIDI protocol, which is supported by all the new OSs and works without any drivers, just like via USB MIDI. However, probably, the solution will fail on older OSs because there is no support for BLE MIDI. But all the tests with available devices were successful. Rewritten app functions, that is, translation of sensor data into midi-data, occupied the whole controller memory accurately. Only 168 bytes left unoccupied. Evidently, the silicon gods were gracious to me, which meant that I was moving in the right direction. Sure, it can be optimized, but I’ll leave it for the next version. Though, it is better not to waste my time and just take a bigger controller. The difference in money is five cents. We’ll see, anyway, I’ll need a space for new features — for instance, processing playing techniques. First of all, I’d like to implement a slide. It is when you start playing a note with a certain pressed fret and slide with your hand along the fingerboard jumping from fret to fret. Now we can check how it works wirelessly: When all the LEDs are on, you can use the guitar if you get lost in a dark cavern. Prototype shortcomings Currently, the construction has the following disadvantages: The strength of pressure cannot be measured anywhere on the sensors. It brings about three problems: 1) There are constant touches of neighboring strings both on the soundboard, and on the fingerboard. It makes the play very difficult. All the notes you play sound with the same loudness. Most of the experiment subjects don’t notice it, but I’d like to get sound that is closer to a real guitar It is impossible to use hammer on, pull off, and vibrato techniques The LEDs are of the same color. It limits visualization when you play by tablatures. I’d like to have the ability to indicate different playing techniques with different colors. 2) The shape of the body doesn’t suit left-handed persons. From a software point of view, I’ve already implemented string inversion by accelerometer. But mechanical petal necessary for holding the guitar with your hand when you play turns only to be comfortable for right-handed persons. 3) Absence of footrest. Now when you play sitting, the lowest string almost touches your leg, and it is uncomfortable. 4) The flexion joint of the guitar requires comprehension and revision. Probably, it is not reliable and stable enough. 5) It is time to pass on to the development of the next version. Moving to a controller of STM32F07 series, it already has 128 KB of flash — it should be enough for any functions. Using ESP32 in the final version of the guitar would be too much, so I went to look for something more conventional. I made my choice in favor of NRF52 by accessibility criteria, presence of documentation, and adequacy of the website. Certainly, three main updates will be implemented: - Now the LEDs are RGB, - On each fingerboard sensor, there will be strength measuring (bar buttons are not necessary anymore), - The strings on the soundboard will be mobile. Currently, the board of the soundboard looks like this (I’ve left ESP footprint just in case): I’m already completely sure that all the intended functions will be implemented, so made a decision about further development. We will open a startup and publish it on Kickstarter:) The project is called and is now under active development. We are based in St.-Petersburg; the team consists of three people: I’m responsible for the technical part, my partner Ildar — for marketing, finance, legal issues and Roman - for the musical and content part. Sensy At the moment, the electronics, software and case have been completely redone. The story will be continued soon in the next article! Those who are fond of following the project updates, please, leave your email in the form on the website and subscribe to social media. I really hope to get feedback from you with your comments and suggestions! Thank you for your attention! Funny episode from the development process I was sitting and debugging NRF52, trying to output the data via UART. No results. I checked the code, soldering, even re-soldered the chip — nothing works! And then randomly, I restarted the board in an unusual way –letter N came to the terminal in ascii. It corresponds to number 0x4E, which I haven’t sent. I restarted again — letter O has come. It is strange. Perhaps, the problem is in the quartz resonator, and the baud rate has failed? I changed the frequency in the terminal, restarting the board — again, N came. With every new restart, a new letter came, which eventually made a repeated phrase — “NON GENUINE DEVICE FOUND.” What does this NRF venture do? I’ve cleared the firmware. How on Earth can it remember after the restart what was sent last time? It looked like a kind of seance. Perhaps, I’m the very NON GENUINE DEVICE? When I looked up on Google, I found out that manufacturers of FTDI chips, which are installed in USB-UART dongles, found a way of fighting with Chinese counterfeits. Windows driver checks chip originality and on the go replaces the input data with this phrase if it is counterfeit. Evidently, my dongle turned out to be a counterfeit, and replacing another has solved this problem. I thank the counterfeits again.

How I Created a Digital Guitar and Turned It Into a Business

(OSM) is maybe the most extensive open data project for geo-data. It has rich information on points of interest (POIs), such as apartments, shops, or offices, globally. You can truly call it a data treasure. Also, the big players, like Apple, Amazon, and Facebook, realized that and built heavily upon this global community project (Visual by: ) OpenStreetMap Jennings Anderson State of the Map To also enable smaller data science teams to benefit from this resource,  we created an ETL pipeline to directly download the raw OSM data in the file format and store the transformed objects in a database. Leveraging indexing, you can then easily query those objects with radius or polygon queries. .pbf Uber’s H3 In the remaining parts of this article, I will show you how we approached the transformation of the raw data using the power of streams in . All of the code snippets are open-source, just as everything else at Kuwala. You can find it on . Node.js our GitHub Streams in are an elegant way to process big files while not using a lot of memory. The reason is that you don’t need to load the entire file into  the memory to perform transformations on or work with the data, but it packs them in batches. That way, even on files with millions of rows, the memory consumption stays consistently low. Of course, you need to write the transformed data directly to a database or file system or perform requests based on the data in the batch and not store everything in intermediate in-memory objects. Node.js We can already use streams when downloading the OSM files since the file size may be several gigabytes big depending on the region you want to download. You first need to create a write stream that writes the data to a specified file path. You then pipe it to the data stream of the request-response object and continue when the stream is finished. { downloadUrl = pickFile(); (!downloadUrl) { ( );
    } filePath = ; fse.ensureDir(filePath.split(filePath.split( ).pop())[ ]); writer = fs.createWriteStream(filePath); response = axios.get(downloadUrl, { : , : });

    response.data.pipe(str).pipe(writer); ( {
        writer.on( , () => resolve(filePath));
        writer.on( , reject);
    });
} async ( ) function downloadFile const await if throw new Error 'No file selected' const `tmp/osmFiles ` ${downloadUrl.split(baseUrl)[ ]} 1 await '/' 0 const const await method 'GET' responseType 'stream' return new Promise ( ) => resolve, reject 'finish' 'error' Now that we downloaded the file, let’s parse it into handleable objects and write them to a database. First, we create a read stream that reads the file. For parsing the OSM protocol buffer into JSON objects, we use the npm package. With the pipe command, you can connect a writable stream to a readable stream. There is a particular class, the Transform stream, which implements both the Readable and Writable interface. Using that, we can break the entire filtering and transformation down into semantic streams and pipe them together. osm-pbf-parser After parsing the format to JSON, we want to create more concise objects based on the OSM tags, which is just a list of key-value pairs. The objects in the OSM file are ordered by type. First nodes, then ways, and lastly relations. Which makes a lot of sense since ways consist of nodes and relations consist of ways. So with our first transformer, we store all the nodes in a temporary database. We use here, a fast key-value store developed by Google. Secondly, we filter all objects that do not contain relevant tags for classifying them as a POI, e.g., nodes that only exist to represent a point in a building footprint. Thirdly, we create building footprints for ways and relations, so the outline of a building, for example. In the OSM objects, only the references to the nodes that form the building footprint are stored. We retrieve the relevant nodes from the LevelDB and generate the geometries in GeoJSON format. Next, we get the centroid based on these geometries, which we then transform to H3 indexes with another Transformer. pbf LevelDB { ( (resolve, reject) => { levelDbPath = ; { db = level(levelDbPath); pbfParserStream = parseOSM(); stream = fs.createReadStream(file);

            stream
                .pipe(pbfParserStream) .pipe(levelDbStream(db)) .pipe(tagFilterStream) .pipe(buildingFootprintStream(db)) .pipe(locationStream) .pipe(h3Stream) .pipe(tagStream) .pipe(modelStream) .pipe(mongodbStream(bar)) .on( , () => { Poi.insertMany(pois).catch(reject);

                    addedObjects += pois.length; db.close();
                    rimraf.sync(levelDbPath);
                    addUnmatchedTags(); resolve();
                })
                .on( , (error) => {
                    rimraf.sync(levelDbPath); reject(error);
                });
        } (error) {
            rimraf.sync(levelDbPath); reject(error);
        }
    });
} async ( ) function parseFile file return new Promise async const 'tmp/levelDb' try const await const const // Parse pbf format to JSON objects // Store every node in temporary database to generate building footprints // Filter irrelevant items // Construct building footprints for ways and relations // Get lat lng pair for center based on point or building footprint // Convert location to h3 index // Convert relevant tags into categories and properties // Create model objects // Save objects to mongodb 'finish' async await await // Add unmatched category tags to category list under "misc" 'error' // Delete temporary database catch // Delete temporary database is a spatial index developed by Uber, which is a great way to connect several geospatial data sources because you can quickly traverse from one resolution to another. We aggregate tags relevant to POI properties such as categories, addresses, or contact details in our next pipe. Lastly, the transformed objects are wrapped in Mongoose objects to validate the schema and so that we can write them to the database in the last pipe. H3 Having passed these transformations, we now have handy objects that you could either load into your data warehouse or query over an API with, for example, radius and geometry queries. At , we want to unify geospatial data and make them easily integratable and connectable. To have a significant impact, we are entirely open-source and believe in the power of the community. If you work with data, make sure to star us on and our Slack community. Kuwala GitHub join Also published on: https://medium.com/kuwala-io/using-node-streams-to-transform-the-largest-poi-database-37218f28c996

Stories, News & Mentions about CONNECTBLUE

Connectblue’s Stories on HackerNoon

Connectblue's News & Mentions