Welcome to 'This is My Architecture'.
Today, my guest is Nicolas Byl, from nexineer.
Welcome, Nicolas.
Thanks for having me.
Nicolas, what are you doing at nexineer?
nexineer is the digital company of the KAMAX Group.
And KAMAX is one of the world's leading manufacturers
of high-strength fasteners and other code forming products.
Okay, cool, so is that one of the products?
Yeah, that's one of the products that I've brought for you.
Essentially, we are holding the world together,
especially in the automotive space.
So if you have ever driven in a car,
it's very likely that you have already used one of our products.
Okay, cool.
So tell me a little bit about your architecture.
What problem are you going to tackle with that?
What I've brought you here is a project that we call Piece Counting,
because we wanted to count the products
as they come out of our production machines
in real-time,
and make this data available to our users, our operators in the factory,
as well as sending these this data off to the ERP system
once a charge or a container has been done.
Okay, got it.
So let's walk us through the architecture.
What's happening exactly?
Yeah, so we start off with our products,
like one of these bolts.
And what we did, we attached sensors
to our production machines.
And as KAMAX has a rich, long history, the company is almost a century old.
We have accumulated quite some different machines over time,
so it's not like we have one solution that can fit everywhere.
But we tried and tried out a few different sensor technologies
to find the right way to detect this.
Okay, so what happens now when a bolt hits the sensor?
What we do, is we have a light grid.
This is essentially a metal frame
and there are a lot of laser beams next to it inside this metal frame.
And if one of these bolts falls through this light grid,
we get a pulse from this light grid.
And this data is then collected
using a Greengrass function running on one of our edge gateways,
and we have one of these edge gateways per machine.
So no, how do you get that information into the cloud?
What we have here is a Greengrass function,
and this Greengrass function help access our local counting engine.
This transforms the data that can be changed
from different sensor variants that we have,
into one type of message
that contain things like, how many pieces have been produced.
over the last time slot?
What is the state of the machine overall, and when has this happened?
And then we sent this off into AWS using IoT Core.
And in IoT Core, we have a few rules
that essentially trigger a Lambda function.
And this Lambda function then derives from the current state,
and the changes that have been sent using these messages,
the new state of the machine.
Okay, nice.
So you now have a user in the factory.
So how does he get that information then?
The user has an application using AWS Amplify.
And this is a smartphone application
that he can use to see the current state,
and in almost real-time,
and we have something of a delay, like five to 10 seconds for that.
And this is something that runs on every smartphone or tablet
that is available on the shop floor.
This application then uses an API that we've provided
to gather this data.
And behind the API Gateway,
we have a few Lambda functions
that then make the data that is in the DynamoDB
available for the application for the user.
Okay, got it, yeah.
So final part was how do you get that information
then into the ERP system?
The application itself,
doesn't only have a display function,
it also has the possibility to report.
For example, a container that has been filled in the process,
and it is then sent to the ERP system
using another part of this API,
which translated into an SQS queue,
which is later sent to the ERP system.
Okay, cool.
Yeah, very interesting.
So tell me, from idea to production,
how much time did you actually need?
I think we need to split that into parts.
The first was the research.
What kind of sensors do we have?
That took something like nine months
because we had to try out different technologies like image recognition,
or other parts that did not work for us.
Once we had this had an idea how to build this,
this was a project of something like five months
from the start until we had something running in the real world production,
which is really lightning fast for the manufacturing industry.
Okay, amazing, great.
So what kind of benefits did you see when you implemented that solution?
Of course, the first thing is for the operators and users,
who can now report something that they have produced
in almost real-time to the ERP system,
instead of having to go over a very long manual process.
And the other thing that we have
is now we can really have points to hook into
to provide other use cases,
like predictions,
how long it is going to take to finish the current production order,
or what to do next, once these parts have been produced.
That's usually not the end of the production chain.
So you already have some more ideas what you can do in the future.
So actually what's next on your roadmap?
Of course, we are rolling this currently out
into the whole KAMAX organization worldwide.
And then we want to go further into this predictive topic,
how to predict when something is ready for the next part.
And we are going to be building a smart factory platform soon.
This is something where we can react to,
and for example, call a forklift once a certain container has been filled
to take it to the next production step.
Cool.
Okay, Nicolas,
thanks for your insights, and thanks for being my guest.
You're welcome.
And thanks for watching 'This is My Architecture'.