The Feetme Insole is a groundbreaking product that revolutionizes how we understand and improve our gait and foot health. Designed with comfort in mind, these insoles are made to be worn all day ...

Best Smart Shoes of 2023 – Adidas, Under Armour & More

The"Physical Function Assessment System Market" New Report (112 Pages)| Analytics| Consumer Goods| Reports present an in-depth analysis of the top Physical Function Assessment System companies ...

Global Physical Function Assessment System Market 2023-2030 Significant Increase in CAGR Shaping the Consumer Goods Industry

It has a partnership collaboration with Otsuka Pharmaceuticals Co., Ltd.; and collaboration with FeetMe focusing on the use of sensor shoe soles. H. Lundbeck A/S also has a collaboration with Alloy Therapeutics, Inc. for the discovery of novel biologics ...

H Lundbeck B (0ND5)

It has a partnership collaboration with Otsuka Pharmaceuticals Co., Ltd.; and collaboration with FeetMe focusing on the use of sensor shoe soles. H. Lundbeck A/S also has a collaboration with ...

HLBBF H. Lundbeck A/S

H Lundbeck A/S ADR (HLUYY)

The purpose of this study was to evaluate the validity and reliability of FeetMe ® insoles for assessing the total six-minute walking distance (6MWD) by comparing the FeetMe ® estimates to those obtained by a rater and to the ground truth measured with a ...

Validation of the Six-Minute Walking Distance Measured by FeetMe® Insoles

New York, April 24, 2023 (GLOBE NEWSWIRE) -- Reportlinker.com announces the release of the report "Global Smart Shoes Market 2023-2027" - Our report on the smart shoes market provides a holistic ...

The Global Smart Shoes Market Is Forecast To Grow By USD 549.45 Mn During 2022-2027, Accelerating At A CAGR Of 21.7% During The Forecast Period

The major global manufacturers of Posture Assessment System include AlFOOTs, Diasu Health Technologies, DIERS International, Lafayette Instrument, LiteGait, MediTouch, DMS Imaging, Feetme and ...

Posture Assessment System Market Sales Growth Rate Comparison By Type

The proliferation of wearable fitness devices will be a major challenge for the smart shoes market during the forecast period. The demand and continuous innovation in the global smart shoes ...

Smart shoes market size to grow by USD 587.87 million from 2021 to 2026; The rising product innovation will boost the market- Technavio

FeetMe

feetme

Personal Recollections of Joan of Arc — Volume 1 by Mark Twain, is part of the HackerNoon Books Series. You can jump to any chapter in this book . Our Paladin in His Glory here Our Paladin in His Glory WE WERE doomed to suffer tedious waits and delays, and we settled ourselves down to our fate and bore it with a dreary patience, counting the slow hours and the dull days and hoping for a turn when God should please to send it. The Paladin was the only exception—that is to say, he was the only one who was happy and had no heavy times. This was partly owing to the satisfaction he got out of his clothes. He bought them at second hand—a Spanish cavalier’s complete suit, wide-brimmed hat with flowing plumes, lace collar and cuffs, faded velvet doublet and trunks, short cloak hung from the shoulder, funnel-topped buskins, long rapier, and all that—a graceful and picturesque costume, and the Paladin’s great frame was the right place to hang it for effect. He wore it when off duty; and when he swaggered by with one hand resting on the hilt of his rapier, and twirling his new mustache with the other, everybody stopped to look and admire; and well they might, for he was a fine and stately contrast to the small French gentlemen of the day squeezed into the trivial French costume of the time. He was king bee of the little village that snuggled under the shelter of the frowning towers and bastions of Courdray Castle, and acknowledged lord of the tap-room of the inn. When he opened his mouth there, he got a hearing. Those simple artisans and peasants listened with deep and wondering interest; for he was a traveler and had seen the world—all of it that lay between Chinon and Domremy, at any rate—and that was a wide stretch more of it than they might ever hope to see; and he had been in battle, and knew how to paint its shock and struggle, its perils and surprises, with an art that was all his own. He was cock of that walk, hero of that hostelry; he drew custom as honey draws flies; so he was the pet of the innkeeper, and of his wife and daughter, and they were his obliged and willing servants. Most people who have the narrative gift—that great and rare endowment—have with it the defect of telling their choice things over the same way every time, and this injures them and causes them to sound stale and wearisome after several repetitions; but it was not so with the Paladin, whose art was of a finer sort; it was more stirring and interesting to hear him tell about a battle the tenth time than it was the first time, because he did not tell it twice the same way, but always made a new battle of it and a better one, with more casualties on the enemy’s side each time, and more general wreck and disaster all around, and more widows and orphans and suffering in the neighborhood where it happened. He could not tell his battles apart himself, except by their names; and by the time he had told one of then ten times it had grown so that there wasn’t room enough in France for it any more, but was lapping over the edges. But up to that point the audience would not allow him to substitute a new battle, knowing that the old ones were the best, and sure to improve as long as France could hold them; and so, instead of saying to him as they would have said to another, “Give us something fresh, we are fatigued with that old thing,” they would say, with one voice and with a strong interest, “Tell about the surprise at Beaulieu again—tell it three or four times!” That is a compliment which few narrative experts have heard in their lifetime. At first when the Paladin heard us tell about the glories of the Royal Audience he was broken-hearted because he was not taken with us to it; next, his talk was full of what he would have done if he had been there; and within two days he was telling what he did do when he was there. His mill was fairly started, now, and could be trusted to take care of its affair. Within three nights afterward all his battles were taking a rest, for already his worshipers in the tap-room were so infatuated with the great tale of the Royal Audience that they would have nothing else, and so besotted with it were they that they would have cried if they could not have gotten it. Noel Rainguesson hid himself and heard it, and came and told me, and after that we went together to listen, bribing the inn hostess to let us have her little private parlor, where we could stand at the wickets in the door and see and hear. The tap-room was large, yet had a snug and cozy look, with its inviting little tables and chairs scattered irregularly over its red brick floor, and its great fire flaming and crackling in the wide chimney. It was a comfortable place to be in on such chilly and blustering March nights as these, and a goodly company had taken shelter there, and were sipping their wine in contentment and gossiping one with another in a neighborly way while they waited for the historian. The host, the hostess, and their pretty daughter were flying here and there and yonder among the tables and doing their best to keep up with the orders. The room was about forty feet square, and a space or aisle down the center of it had been kept vacant and reserved for the Paladin’s needs. At the end of it was a platform ten or twelve feet wide, with a big chair and a small table on it, and three steps leading up to it. Among the wine-sippers were many familiar faces: the cobbler, the farrier, the blacksmith, the wheelwright, the armorer, the maltster, the weaver, the baker, the miller’s man with his dusty coat, and so on; and conscious and important, as a matter of course, was the barber-surgeon, for he is that in all villages. As he has to pull everybody’s teeth and purge and bleed all the grown people once a month to keep their health sound, he knows everybody, and by constant contact with all sorts of folk becomes a master of etiquette and manners and a conversationalist of large facility. There were plenty of carriers, drovers, and their sort, and journeymen artisans. When the Paladin presently came sauntering indolently in, he was received with a cheer, and the barber hustled forward and greeted him with several low and most graceful and courtly bows, also taking his hand and touching his lips to it. Then he called in a loud voice for a stoup of wine for the Paladin, and when the host’s daughter brought it up on the platform and dropped her courtesy and departed, the barber called after her, and told her to add the wine to his score. This won him ejaculations of approval, which pleased him very much and made his little rat-eyes shine; and such applause is right and proper, for when we do a liberal and gallant thing it is but natural that we should wish to see notice taken of it. The barber called upon the people to rise and drink the Paladin’s health, and they did it with alacrity and affectionate heartiness, clashing their metal flagons together with a simultaneous crash, and heightening the effect with a resounding cheer. It was a fine thing to see how that young swashbuckler had made himself so popular in a strange land in so little a while, and without other helps to his advancement than just his tongue and the talent to use it given him by God—a talent which was but one talent in the beginning, but was now become ten through husbandry and the increment and usufruct that do naturally follow that and reward it as by a law. The people sat down and began to hammer on the tables with their flagons and call for “the King’s Audience!—the King’s Audience!—the King’s Audience!” The Paladin stood there in one of his best attitudes, with his plumed great hat tipped over to the left, the folds of his short cloak drooping from his shoulder, and the one hand resting upon the hilt of his rapier and the other lifting his beaker. As the noise died down he made a stately sort of a bow, which he had picked up somewhere, then fetched his beaker with a sweep to his lips and tilted his head back and drained it to the bottom. The barber jumped for it and set it upon the Paladin’s table. Then the Paladin began to walk up and down his platform with a great deal of dignity and quite at his ease; and as he walked he talked, and every little while stopped and stood facing his house and so standing continued his talk. We went three nights in succession. It was plain that there was a charm about the performance that was apart from the mere interest which attaches to lying. It was presently discoverable that this charm lay in the Paladin’s sincerity. He was not lying consciously; he believed what he was saying. To him, his initial statements were facts, and whenever he enlarged a statement, the enlargement became a fact too. He put his heart into his extravagant narrative, just as a poet puts his heart into a heroic fiction, and his earnestness disarmed criticism—disarmed it as far as he himself was concerned. Nobody believed his narrative, but all believed that he believed it. He made his enlargements without flourish, without emphasis, and so casually that often one failed to notice that a change had been made. He spoke of the governor of Vaucouleurs, the first night, simply as the governor of Vaucouleurs; he spoke of him the second night as his uncle the governor of Vaucouleurs; the third night he was his father. He did not seem to know that he was making these extraordinary changes; they dropped from his lips in a quite natural and effortless way. By his first night’s account the governor merely attached him to the Maid’s military escort in a general and unofficial way; the second night his uncle the governor sent him with the Maid as lieutenant of her rear guard; the third night his father the governor put the whole command, Maid and all, in his special charge. The first night the governor spoke of him as a youth without name or ancestry, but “destined to achieve both”; the second night his uncle the governor spoke of him as the latest and worthiest lineal descendent of the chiefest and noblest of the Twelve Paladins of Charlemagne; the third night he spoke of him as the lineal descendent of the whole dozen. In three nights he promoted the Count of Vendome from a fresh acquaintance to a schoolmate, and then brother-in-law. At the King’s Audience everything grew, in the same way. First the four silver trumpets were twelve, then thirty-five, finally ninety-six; and by that time he had thrown in so many drums and cymbals that he had to lengthen the hall from five hundred feet to nine hundred to accommodate them. Under his hand the people present multiplied in the same large way. The first two nights he contented himself with merely describing and exaggerating the chief dramatic incident of the Audience, but the third night he added illustration to description. He throned the barber in his own high chair to represent the sham King; then he told how the Court watched the Maid with intense interest and suppressed merriment, expecting to see her fooled by the deception and get herself swept permanently out of credit by the storm of scornful laughter which would follow. He worked this scene up till he got his house in a burning fever of excitement and anticipation, then came his climax. Turning to the barber, he said: “But mark you what she did. She gazed steadfastly upon that sham’s villain face as I now gaze upon yours—this being her noble and simple attitude, just as I stand now—then turned she—thus—to me, and stretching her arm out—so—and pointing with her finger, she said, in that firm, calm tone which she was used to use in directing the conduct of a battle, ‘Pluck me this false knave from the throne!’ I, striding forward as I do now, took him by the collar and lifted him out and held him aloft—thus—as if he had been but a child.” (The house rose, shouting, stamping, and banging with their flagons, and went fairly mad over this magnificent exhibition of strength—and there was not the shadow of a laugh anywhere, though the spectacle of the limp but proud barber hanging there in the air like a puppy held by the scruff of its neck was a thing that had nothing of solemnity about it.) “Then I set him down upon his feet—thus—being minded to get him by a better hold and heave him out of the window, but she bid me forbear, so by that error he escaped with his life. “Then she turned her about and viewed the throng with those eyes of hers, which are the clear-shining windows whence her immortal wisdom looketh out upon the world, resolving its falsities and coming at the kernel of truth that is hid within them, and presently they fell upon a young man modestly clothed, and him she proclaimed for what he truly was, saying, ‘I am thy servant—thou art the King!’ Then all were astonished, and a great shout went up, the whole six thousand joining in it, so that the walls rocked with the volume and the tumult of it.” He made a fine and picturesque thing of the march-out from the Audience, augmenting the glories of it to the last limit of the impossibilities; then he took from his finger and held up a brass nut from a bolt-head which the head ostler at the castle had given him that morning, and made his conclusion—thus: “Then the King dismissed the Maid most graciously—as indeed was her desert—and, turning to me, said, ‘Take this signet-ring, son of the Paladins, and command me with it in your day of need; and look you,’ said he, touching my temple, ‘preserve this brain, France has use for it; and look well to its casket also, for I foresee that it will be hooped with a ducal coronet one day.’ I took the ring, and knelt and kissed his hand, saying, ‘Sire, where glory calls, there will I be found; where danger and death are thickest, that is my native air; when France and the throne need help—well, I say nothing, for I am not of the talking sort—let my deeds speak for me, it is all I ask.’ “So ended the most fortunate and memorable episode, so big with future weal for the crown and the nation, and unto God be the thanks! Rise! Fill your flagons! Now—to France and the King—drink!” They emptied them to the bottom, then burst into cheers and huzzas, and kept it up as much as two minutes, the Paladin standing at stately ease the while and smiling benignantly from his platform. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Mark Twain (2004). Personal Recollections of Joan of Arc — Volume 1. Urbana, Illinois: Project Gutenberg. Retrieved October 2022 https://www.gutenberg.org/cache/epub/2874/pg2874-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

Our Paladin in His Glory

The First And Rightful Lover

In the Shadow of the Room Stood a Great Shadowy Figure

Moby-Dick; or The Whale: Chapter 16 - The Ship

Exchanging everyday items — on a peer-to-peer basis — is coming to the blockchain. And it’s all about the cost-saving efficiency of disintermediation. The project is building the first decentralized, P2P renting and pawning ecosystem through a pair of DApps known as SmartRent and SmartPawn. BizShake Today’s article is the last in a 5-part series all about BizShake. In case you missed the first 4 blog posts, here’s where you can find them: Part 1: The Honor of Becoming an NEP-5 Token Part 2: Team & Website Part 3: Tokenomics Part 4: Strategic Partnerships Can the project ride the tsunami of Security Tokens rushing towards the land of crypto? We’ll find out together. But first, let’s ensure we’re speaking the same language… Disclaimer : This is not investment or financial advice. I’m not a financial expert by any stretch of the imagination. Most information within this article is speculative and merely personal opinion. Always conduct your own research before contributing to any startup projects. Always remember that what you do with your funds is your decision to make. And if that decision proves too difficult for you alone, seek guidance from a financial professional. I may or may not receive a small allocation of tokens for creating this content. That said, I do my best to remain unbiased and fair. I try to avoid all FOMO and FUD and never wish to impart those emotions on my fellow crypto-heads. FYI : Certain countries are excluded from participating in BizShake’s upcoming STO. Don’t forget to check the (exciting!) terms and conditions page. No need to fret if your country is blacklisted; you’ll merely need to wait until BZS tokens are available on exchanges. Frozen in Time Before we get into the nuts and bolts of the BizShake roadmap, let’s have a chat about the general theories of these documents. Roadmaps are essential at the onset of any project, blockchain or not. The team needs to clearly define where it wants to go, followed by exactly how it plans to get there. But this is crypto — the space moves at breakneck speed. Teams who assess, adjust, adapt — test and test and test some more — can stay a few steps ahead of the competition. Point is, don’t view a blockchain startup’s roadmap as a static, unyielding object. Instead, look at them as a framework for what’s to come, which may very well need to morph into something entirely different by the time the first product takes flight. Case in point — although the current roadmap states otherwise, the BizShake STO is officially postponed while awaiting SEC approval for US citizens. A single development can have a domino effect on the entire map. That said, roadmaps are still necessary and highly relevant. Potential contributors need assurance that a project’s team has a clear vision of what they’re trying to accomplish. Without one, it’s tough to assess what a team feels they’re capable of achieving. Any startup is only as good as its team — they must earn the trust of those on the outside looking in. We’re nearing the half-way mark of BizShake’s 2-year forecast Happy Anniversary October marks a full year of progress for the BizShake project. I appreciate it when teams spend a good 12 months+ coding and testing, deploying and strategizing. The is live now — go ahead and check out the selection of useful items spread throughout Europe, although the selection has plenty of room for expansion. BizShake Alpha Let’s use the current ski bib as an example of how cost-effective this platform can be. As a parent who’s had to scramble to find last-minute kids’ gear for the slopes, I’m speaking from firsthand experience here. Snow days can get expensive Vacations in snow country aren’t exactly cheap. Between transportation for icy roads, lodging in mountain cabins, high-priced yet low-quality resort food, and all that specialized gear, snow games can drain your wallet quickly. Involving kids in these winter activities can add a whole new level of expense. Renting planks and boards is easy. The ski shop has no shortage of them. But a ski bib or snowboard pants? Not so easy to find as a rental. Plus, there’s a 99.99% chance that your little tyke outgrows whatever you put them in this year. Unlike us grownups, they can’t get away with wearing the same jacket for years on end. Which brings us to the whole point of BizShake — some things, especially on vacation, are much better rented than purchased. For a couple of bucks a day, so long as your winter wonderland is St. Petersburg, Russia, you can rent a ski bib and return it when the fun’s over. The alternative is one just so Li’l Slugger can wear it a handful of times, which is a downright absurd juxtaposition. buying As the platform matures, P2P asset exchange serves a larger population. Ideally, you’ll pull up the city you’re traveling to and discover a host of items on loan within the BizShake DApp. The Road Ahead Too big too fast can destroy the best of companies. Such a scenario doesn’t seem at play here. The team is taking a systematic approach by going from Alpha to Beta with their platform’s applications, before integrating a full marketing department into their organization. While some projects are content to make announcements of upcoming announcements intended to announce further announcements, BizShake doesn’t seem to be riding the hype train. The goal is to get the bulk of the platform up and running before starting to spread the message throughout the cryptosphere. And, as indicated in this series’ first article, BizShake already has the attention of the world’s millions of NEO followers because they chose to run their ecosystem with NEP-5 tokens. Opening the platform to the rampant capitalism & consumerism of America is vital to the project’s overall success. The market is far too large to ignore. Sailing into 2019 — assuming the SEC stops dragging its feet and grants the Reg. A+ classification BizShake already applied for — the project expects to realize some significant milestones. Aspirations include getting half of the platform’s six ‘Smart’ components fully operational — Dispute, Pawn, and Rent. Those last two are the lifeblood of the ecosystem and, considering the platform is already alive and growing, the team is on pace to hit their marks. Final thoughts… Having seen the platform in action, I’m looking forward to its full release. Take a look around your house or apartment and, most likely, you’ll discover plenty of items you rarely or no longer use. Well, now you can rent them out. Got yourself something durable? Rent it out enough, and you may very well collect more than you originally paid for it, assuming the BizShake ecosystem makes its way to your neighborhood. And, as you were collecting fees, visitors were getting a bargain. Can you say win/win? The BizShake project is well on its way to seeing widespread adoption. SEC Reg A+ clearance is an upcoming catalyst for growth. After all, it’s tricky to hire marketing and customer service teams if govt. interference is token-blocking your fundraising efforts. Once the legal team hacks through all the red tape, look for BizShake to be a strong contender in the blockchain niches of P2P as well as security tokens. DYOR BizShake has excellent potential to become a standout blockchain project. I like the industry they’ve chosen, and agree with how they plan to gain market share. But that’s just me — it’s essential for you to dig a little deeper into any project you may involve yourself with so you can formulate a unique opinion of your very own. If this 5-part series wasn’t enough reading material, feel free to read your way through the BizShake Website . And don’t forget the to discover more about the project and upcoming STO. BizShake Whitepaper 👇 👇 Get Social with Team BizShake Facebook LinkedIn Medium Reddit Telegram Twitter YouTube By the way… If you like what you read here and need help getting your crypto message to the masses, I’d love to hear about your project. Even if you just want to chat about your favorite projects, you’ll find me here: blockchainauthor at Gmail This article was created in exchange for a potential token reward through Bounty0x. *** BountyOx username = blockchainauthor ***

BizShake STO Review Part 5: Project Roadmap

GILBERT’S VOYAGES

VOYAGES FOR THE MUSCOVY COMPANY

THE OPENING OF RUSSIA

For years the world has been abuzz with IoT devices. These devices range from alarm clocks that show the current weather to refrigerators that list the prices of nearby groceries. Whatever the specifics, these devices rely on APIs to communicate with data sources. But how, exactly, do we connect the messages, data, and devices? In this post, we’ll show you an example of how to design and model data for an IoT device. We’ll use the —a small, modular IoT device with a display screen—and connect to the (NYC MTA) to render the latest subway times for various stations. M5Stack API for the New York City Metropolitan Transportation Authority While we’ll focus on the M5Stack, the concepts we’ll discuss will apply to designing an IoT application across a wide variety of devices. So, let’s get started! Prerequisites In this tutorial, we’ll focus on the bigger conceptual ideas around how to request data from an API. Some programming knowledge will be very helpful. Although you don’t need an M5Stack, if you do have one, then you can follow along and upload the finished project on your own device. With that in mind, you can download the and . If you’ve never booted an M5Stack before, to set up WiFi and the necessary firmware. For this project, we’ll use , which is the main programming language that the M5Stack uses. VS Code IDE the M5Stack plugin follow their guide Python 3 You’ll need to for a free Developer’s API key to access their real-time subway data. sign up for an NYC MTA developer account Lastly, you should sign up for a free Gravitee account to use the , which will make it easier to visualize and understand the data flow in your API calls! API designer The source material for this project was inspired by , so go ahead and star that repository if it’s been helpful. this open-source project Designing the API Interaction Before writing a single line of code, let’s take a step back and consider what sort of information we need to complete this project: Information about the relevant subway stations Which trains pass through those stations The latest real-time data about those trains According to the documentation, the API is separated into and . static data feeds real-time data feeds Static data feeds hold information about stations. With that information, we can get the actual live train data from the real-time data feeds API. The data provided by the MTA is in the following CSV format: stop_id,stop_code,stop_name,stop_desc,stop_lat,stop_lon,zone_id,stop_url,location_type,parent_station Since the only static information we need is the station ID, we can simply pluck a random station ID and use it for the real-time feeds. In this case, I’m choosing the for its relative complexity: two separate trains pass through it (the A and the C). Stations are also identified by whether they are northbound (N) or southbound (S). Hoyt–Schermerhorn station A42,,Hoyt-Schermerhorn Sts,,40.688484,-73.985001,,,1,
A42N,,Hoyt-Schermerhorn Sts,,40.688484,-73.985001,,,0,A42
A42S,,Hoyt-Schermerhorn Sts,,40.688484,-73.985001,,,0,A42 From these rows, all we need is the parent stop ID (A42) to identify the trains passing through the station, both northbound (A42N) and southbound (A42S). The real-time feeds are represented in , which is based on (also called protobuf). While the NYC MTA doesn’t have documented examples of its specific feeds, . From the GTFS documentation, we can identify how to get the time-to-arrival for the latest trains at a particular station in a protobuf format. Google’s GTFS format protocol buffers GTFS does Here’s an example of a response from the GTFS endpoint, converted into JSON for easier visualization: {
  "trip":{
     "trip_id":"120700_A..N",
     "start_time":"20:07:00",
     "start_date":"20220531",
     "route_id":"A"
  },
  "stop_time_update":[
     {
        "arrival":{
           "time":1654042672
        },
        "departure":{
           "time":1654042672
        },
        "stop_id":"H06N"
     },

     //…more stops…

     {
        "arrival":{
           "time":1654044957
        },
        "departure":{
           "time":1654044957
        },
        "stop_id":"A42N"
     }
  ]
} Because of the amount of information the NYC MTA API throws at you, it can be very helpful to use the Gravitee API Designer to model what the API returns, mapping out and visualizing the data. Here’s a snapshot of our API Designer mind map: The API Designer helps you identify all of the resources (endpoints) for your API, along with the data attributes associated with out resource. Those attributes will include the inputs an endpoint needs and the outputs it provides. In our map, we have a resource with the path . We can attach as many attributes as necessary, and we can annotate each of those attributes with data types. By looking at our map, we can draw a direct path from the endpoint to the arrival and departure times identified at the bottom right. /gtfs/ So, in order to represent the data we need, we’ll need to: Identify the ID of the station we want train information from Issue an HTTP request to the NYC MTA’s GTFS feed for the train line(s) we’re interested in Iterate over the results, comparing the stop_id in the response array with our station ID We can then act on the time information for our specific station and train This represents a few moving parts, but it shouldn’t be anything we can’t handle! Coding It Before running anything on our M5Stack, let’s first make sure our code works locally. We’ll install a few Python packages to make our project easier to build. pip3 install --upgrade gtfs-realtime-bindings
pip3 install protobuf3_to_dict
pip3 install requests The first two packages convert protocol buffers into Python dictionaries (or hashes), which makes for an easier data model to work with. The last package makes it easier to issue HTTP requests from Python. We’ll start our program by importing the Python packages: from google.transit import gtfs_realtime_pb2
import requests
import time Next, we’ll issue our HTTP request to the NYC MTA GTFS feed: api_key = "YOUR_API_KEY"

# Requests subway status data feed from the NYC MTA API
headers = {'x-api-key': api_key}
feed = gtfs_realtime_pb2.FeedMessage()
response = requests.get(
    'https://api-endpoint.mta.info/Dataservice/mtagtfsfeeds/nyct%2Fgtfs-ace',
    headers=headers)
feed.ParseFromString(response.content) So far, so good. The GTFS endpoint we’re using here is the one for the A/C/E trains, which we can identify by the suffix on the URL. (Except, for this demo, we don’t care about the E train—sorry, E train!) -ace Let’s convert that GTFS protocol buffer response into a dictionary: from protobuf_to_dict import protobuf_to_dict
subway_feed = protobuf_to_dict(feed)  # converts MTA data feed to a dictionary
realtime_data = subway_feed['entity'] At this point, I would highly recommend issuing a , so we can see what the actual data structure looks like. If this were a real project, such an analysis might help you identify which keys and values in the dictionary you’d need to iterate over—but since this is a tutorial, we’ve already covered that. print(realtime_data) def station_time_lookup(train_data, station):
   for trains in train_data:
       if trains.__contains__('trip_update'):
           unique_train_schedule = trains['trip_update']
           if unique_train_schedule.__contains__('stop_time_update'):
             unique_arrival_times = unique_train_schedule['stop_time_update']
             for scheduled_arrivals in unique_arrival_times:
                 stop_id = scheduled_arrivals.get('stop_id', False)
                 if stop_id == f'{station}N':
                     time_data = scheduled_arrivals['arrival']
                     unique_time = time_data['time']
                     if unique_time != None:
                         northbound_times.append(unique_time)
                 elif stop_id == f'{station}S':
                     time_data = scheduled_arrivals['arrival']
                     unique_time = time_data['time']
                     if unique_time != None:
                         southbound_times.append(unique_time)

# Keep a global list to collect various train times
northbound_times = []
southbound_times = []

# Run the above function for the station ID for Hoyt-Schermerhorn
station_time_lookup(realtime_data, 'A42') Suddenly, we have a lot of code! But don’t worry—what we’re doing isn’t so complicated: We iterate over the array of train information for the A/C lines. For each array entry, we verify that we have values for all of the keys we need. This is defensive coding because we can’t be 100% certain that this third-party service has what we need when we need it! After that, we iterate through all the station information and stop when we land on the parent ID we need ( ) for both northbound and southbound trains. A42 Finally, we keep lists for the upcoming train arrival times in two separate global variables. Next, let’s present this information: # Sort collected times in chronological order
northbound_times.sort()
southbound_times.sort()

# Pop off the earliest and second earliest arrival times from the list
nearest_northbound_arrival_time = northbound_times[0]
second_northbound_arrival_time = northbound_times[1]

nearest_southbound_arrival_time = southbound_times[0]
second_southbound_arrival_time = southbound_times[1]

### UI FOR M5STACK SHOULD GO HERE ###

def print_train_arrivals(
        direction,
        time_until_train,
        nearest_arrival_time,
        second_arrival_time):
    if time_until_train <= 0:
        next_arrival_time = second_arrival_time
    else nearest_arrival_time:
        next_arrival_time_s = time.strftime(
            "%I:%M %p",
            time.localtime(next_arrival_time))
    print(f"The next {direction} train will arrive at {next_arrival_time_s}")

# Grab the current time so that you can find out the minutes to arrival
current_time = int(time.time())
time_until_northbound_train = int(
    ((nearest_northbound_arrival_time - current_time) / 60))
time_until_southbound_train = int(
    ((nearest_southbound_arrival_time - current_time) / 60))
current_time_s = time.strftime("%I:%M %p")
print(f"It's currently {current_time_s}")

print_train_arrivals(
    "northbound",
    time_until_northbound_train,
    nearest_northbound_arrival_time,
    second_northbound_arrival_time)
print_train_arrivals(
    "southbound",
    time_until_southbound_train,
    nearest_southbound_arrival_time,
    time_until_southbound_train) Most of what we’re doing above is data formatting. The key steps are as follows: We sort the arrival times of the northbound and southbound trains at the station. We take the first two times (the “soonest” trains arriving). We compare those times with the current time to get a distance in minutes for the train’s arrival. We pass those train arrival times to print_train_arrivals. If the next train is arriving in less than a minute, we’ll show the second arrival time—you’re not going to make that train, I’m afraid! Otherwise, we’ll show the nearest arrival time. If you run this script on the terminal, then you should see a message similar to the following: It's currently 05:59 PM
The next northbound train will arrive at 06:00 PM
The next southbound train will arrive at 06:02 PM Deploying to the M5Stack Now that we have tested locally that our Python code can communicate with the NYC MTA API, it’s time to get this code running on our M5Stack. The easiest way to program the M5Stack is through , which is just a web page that communicates with your device through WiFi. You can learn more about how to configure your device for WiFi access through . the free UI Flow IDE their documentation Although the M5Stack can be programmed through WYSIWYG UI elements, it can also accept (and run) Python code. However, the main advantage of the WYSIWYG elements is that it makes visualizing the text drawn on the screen much easier: In this GIF, I’ve created a label with the default string of “Text” on the sample M5Stack screen. When I switch to Python, we see that the label is an instantiation of an object called . As the label is dragged around, its X and Y coordinates (the first two arguments in the constructor) change in Python. This makes it easy to see how your program will be displayed. You can also change the variable used in the Python code (as well as other properties) by clicking on the label itself: M5TextBox For the most part, the Python script we wrote can be used on the M5Stack with some slight modifications. We can copy the Python code from our local machine and paste it into the Python tab of the UI Flow IDE. In our code, we find the comment and replace everything below it with the following code: ### UI FOR M5STACK SHOULD GO HERE ### time_label = M5TextBox(146, 27, "", lcd.FONT_Default, 0xFFFFFF, rotate=0)
northbound_label = M5TextBox(146, 95, "", lcd.FONT_Default, 0xFFFFFF, rotate=0)
southbound_label = M5TextBox(146, 163, "", lcd.FONT_Default, 0xFFFFFF, rotate=0)

def print_train_arrivals(
        direction,
        label,
        time_until_train,
        nearest_arrival_time,
        second_arrival_time):
    if time_until_train <= 0:
        next_arrival_time = second_arrival_time
    else nearest_arrival_time:
        next_arrival_time_s = time.strftime(
            "%I:%M %p",
            time.localtime(next_arrival_time))
    label.setText(f"The next {direction} train will arrive at {next_arrival_time_s}")

while True:
    # Grab the current time so that you can find out the minutes to arrival
    current_time = int(time.time())
    time_until_northbound_train = int(
        ((nearest_northbound_arrival_time - current_time) / 60))
    time_until_southbound_train = int(
        ((nearest_southbound_arrival_time - current_time) / 60))
    current_time_s = time.strftime("%I:%M %p")
    time_label.setText(f"It's currently {current_time_s}")

    print_train_arrivals(
        "northbound",
        northbound_label,
        time_until_northbound_train,
        nearest_northbound_arrival_time,
        second_northbound_arrival_time)
    print_train_arrivals(
        "southbound",
        southbound_label,
        time_until_southbound_train,
        nearest_southbound_arrival_time,
        time_until_southbound_train)
  
    sleep 5 Most of this should look familiar! There are two major modifications to get this code running on the M5Stack. First, we created the labels which will be placeholders for our time and train data: time_label northbound_label southbound_label Second, we’ve put everything inside of a loop, which will grab the current times and set the label text. The loop will sleep for five seconds and then restart the process. while And that’s it! When we hit the button, we should see our train strings update every five seconds with the latest route data. Run Conclusion That’s that! IoT devices are often used by hobbyists, but if you continue working on this project, there are several real-world considerations. One consideration is rate-limiting, making sure you’re requesting data in an efficient way from the MTA API. Another consideration is connectivity. If your device temporarily loses WiFi access, how will it reestablish a connection to fetch the information it needs? Once you start thinking about these production-grade concerns, or if you want to scale your project across multiple devices, you’ll also need to consider API management. I mentioned Gravitee Designer earlier in this article, which is great in the design phase. Gravitee has other tools for API management, like an API gateway, monitoring, real-time analytics, and deployment. IoT application development may seem daunting for developers who are used to writing code for traditional servers and web browsers. However, the leap to IoT devices is actually quite small. Today’s devices, with their built-in support for popular languages and frameworks, make IoT a fun and innovative way to build or integrate with APIs and applications. Also published here

How to Build an IoT Application Using an HTTP API

A practical use case of Apache Kafka Data come in different shapes and forms. In the real world, a lot of data are generated in streams. Streaming data is a continuous flow of events generated by various sources. With the ubiquitousness of mobile devices, social media, IoT and big data platforms, more and more data sources offer streaming data for analytics consumption. Real time analytics of streaming data differs from batch data in that analytics are updated based on a few new data events, instead of the entire dataset. Some examples of streaming data are Facebook/Instagram/Twitter posts Sensor data sent from airplane engines Time series data from financial stocks trading on exchanges In recent years, has become the technology of choice when it comes to working with streaming data. It offers persistent storage that guarantees message ordering, and a pub-sub semantics that are easy to reason with. It can handle terabyte throughput easily and is a popular choice for any company that works with massive amount of event-driven data. Apache Kafka MTA, the agency operating NYC subways, publishes real time subway trip updates via a that are available to the public. set of RESTful APIs In this post we will use Apache Kafka to build a real time NYC subway tracker that shows you when the next train will arrive in the station. Here at Cloudbox Labs, building cloud native applications is our business. In that spirit, we will host our Kafka cluster on Amazon Web Services (AWS) and our application on EC2. The overall architecture of our system looks like this In order to interact with Kafka pub-sub model, we will write a message producer that generates message streams and publish them onto Kafka. MTA’s data stream refreshes every 30 seconds so our producer will query the API for the latest subway trip updates and publish these updates to a Kafka topic. On the other end we will spin up a message consumer that listens on a particular topic and process the update messages as they come through. The consumer keeps an in-memory data structure that stores timing of the next arrival train for each station by subway line. For demo purpose our Kafka cluster setup is fairly simple. We set up a two node Kafka cluster so we can take advantage of its distributed and replicated storage capability. We created one topic that will store our message queue. With that we are ready to interact with the Kafka cluster. MTA’s trip update API uses in specification so the data has a standard format. In order to parse the response from the API we need to first auto-generate the python protobuf classes based on protobuf gtfs-realtime feed gtfs-realtime.proto python -m grpc_tools.protoc -Iprotos/ --python_out=. --grpc_python_out=. protos/gtfs-realtime.proto Using the Confluent Kafka python client, writing Kafka producer and consumer are fairly easy. Here is the code snippet of our trip update producer import time import requestsfrom google.protobuf.json_format import MessageToJsonfrom confluent_kafka import Producer import gtfs_realtime_pb2 class MTARealTime(object): def \_\_init\_\_(self):  
    with open('.mta\_api\_key', 'r') as key\_in:  
        self.api\_key = key\_in.read().strip()  

    self.mta\_api\_url = 'http://datamine.mta.info/mta\_esi.php?key={}&feed\_id=1'.format(  
        self.api\_key)  
    self.kafka\_topic = 'test'  
    self.kafka\_producer = Producer({'bootstrap.servers': 'localhost:9092'})  

def produce\_trip\_updates(self):  
    feed = gtfs\_realtime\_pb2.FeedMessage()  
    response = requests.get(self.mta\_api\_url)  
    feed.ParseFromString(response.content)  

    for entity in feed.entity:  
        if entity.HasField('trip\_update'):  
            update\_json = MessageToJson(entity.trip\_update)  
            self.kafka\_producer.produce(  
                self.kafka\_topic, update\_json.encode('utf-8'))  

    self.kafka\_producer.flush()  

def run(self):  
    while True:  
        self.produce\_trip\_updates()  
        time.sleep(30) And here is our trip update consumer import csvfrom collections import defaultdictimport json import arrowfrom confluent_kafka import Consumer, KafkaError class MTATrainTracker(object): def \_\_init\_\_(self):  
    self.kafka\_consumer = Consumer({  
        'bootstrap.servers': 'localhost:9092',  
        'group.id': 'test\_consumer\_group',  
        'default.topic.config': {  
            'auto.offset.reset': 'smallest'  
        }  
    })  
    self.kafka\_topic = 'test'  

    # subway line number -> (stop\_id, direction) -> next arrival time  
    self.arrival\_times = defaultdict(lambda: defaultdict(lambda: -1))  

    self.stations = {}  
    with open('static/mta\_stations.csv') as csvf:  
        reader = csv.DictReader(csvf)  
        for row in reader:  
            self.stations\[row\['GTFS Stop ID'\]\] = row\['Stop Name'\]  

def process\_message(self, message):  
    trip\_update = json.loads(message)  

    trip\_header = trip\_update.get('trip')  
    if not trip\_header:  
        return  

    route\_id = trip\_header\['routeId'\]  
    stop\_time\_updates = trip\_update.get('stopTimeUpdate')  
    if not stop\_time\_updates:  
        return  

    for update in stop\_time\_updates:  
        if 'arrival' not in update or 'stopId' not in update:  
            continue  

        stop\_id, direction = update\['stopId'\]\[0:3\], update\['stopId'\]\[3:\]  
        new\_arrival\_ts = int(update\['arrival'\]\['time'\])  

        next\_arrival\_ts = self.arrival\_times\[route\_id\]\[(stop\_id, direction)\]  
        now = arrow.now(tz='US/Eastern')  

        if new\_arrival\_ts >= now.timestamp and \\  
                (next\_arrival\_ts == -1 or new\_arrival\_ts < next\_arrival\_ts):  
            self.arrival\_times\[route\_id\]\[(stop\_id, direction)\] = new\_arrival\_ts  

            # convert time delta to minutes  
            time\_delta = arrow.get(new\_arrival\_ts) - now  
            minutes = divmod(divmod(time\_delta.seconds, 3600)\[1\], 60)\[0\]  
            print('Next {} bound {} train will arrive at station {} in {} minutes'.format(  
                direction, route\_id, self.stations\[stop\_id\], minutes))  

def run(self):  
    self.kafka\_consumer.subscribe(\[self.kafka\_topic\])  

    while True:  
        msg = self.kafka\_consumer.poll(1.0)  

        if msg is None or not msg.value():  
            continue  
        if msg.error() and msg.error().code() != KafkaError.\_PARTITION\_EOF:  
            raise ValueError('Kafka consumer exception: {}'.format(msg.error()))  

        msg = msg.value()  
        self.process\_message(msg.decode('utf-8')) Both the Kafka cluster and the application components run on separate EC2 on AWS. Once we spin up all the pieces, we can see that the consumer is listing the next train arrival time for each station Next S bound 1 train will arrive at station Rector St in 0 minutes Next S bound 1 train will arrive at station South Ferry in 2 minutes Next S bound 1 train will arrive at station Cortlandt St in 0 minutes Next N bound 6 train will arrive at station Spring St in 4 minutes Next N bound 6 train will arrive at station Bleecker St in 5 minutes Next N bound 6 train will arrive at station Astor Pl in 6 minutes Streaming data has major applications in modern data analytics. At Cloudbox Labs, we love building stream processing platforms so our clients can analyze data faster and at scale. As always you can find the full code discussed in this post on . Cloudbox Labs github Tags: , , , , , , Amazon Web Services Apache Kafka gtfs-realtime NYC subway tracker protocol buffer rest API streaming data

Stories, News & Mentions about FEETME

Feetme’s Stories on HackerNoon

Feetme's News & Mentions