►
From YouTube: Rust Berlin - rust ❤️ sensors - Claus Matzinger
Description
With Rust being a safe and efficient language, it's perfect for embedded and more lower level applications. However, its ecosystem is missing a crucial thing to succeed: Drivers. More often than not reference implementations are in C or Python, and re-implementing them using that code or even the data sheet is often tricky. This talk will explore available drivers, common pitfalls, and show the audience how to implement their own drivers for i2c devices.
A software engineer by trade, Claus runs field engineering at Crate.io, the creators of CrateDB, a distributed SQL database. As a former CTO of a health startup and an Raspberry Pi and Rust (the programming language) enthusiast, Claus also maintains several drivers for sensors in the Rust community. He loves connecting with developers to talk about putting machine data to work in exciting IoT systems.
A
B
Hi
yeah
welcome
to
my
talk
about
sensors,
so
we
are
going
to
move
move
a
level
down
from
CSS
and
layered
rendering,
if
you
have
asked
on
anything
with
embedded
systems
or
something
like
that.
Quite
quite
a
few
I
yeah,
we'll
see
how
much
it
I
can
tell
you
but
yeah.
Let's
go
I'm
Klaus
I
work
as
a
Technical
Evangelist,
a
company
called
crate
IO.
Actually,
until
the
day
after
tomorrow,
then
I
switch
over
to
Microsoft,
which
is
fairly
larger
company,
probably
yeah
and
yeah
I'm
a
software
engineer.
B
So
my
view
of
this
you
know
of
this
thing
and
that
wire
attached,
it
is
fairly
limited.
So
I
had
that
during
my
studies,
but
after
tinkering
with
rust
for
about
a
year
I
kind
of
went
into.
You
know
why
not
program
something
on
that
arm
device
and
can
get
something
going
there,
and
especially
since
I'm
sort
of
curious
person,
I
kind
of
like
to
re-implement
stuff
on
you
know
just
to
get
to
know
it
a
bit
better,
which
is
yeah,
something
that
we
shouldn't
endorse:
a
lot
I
guess
and
but
it's
a
yeah.
B
It's
a
nice
way
to
kind
of
get
into
getting
to
stuff
all
kinds
of
stuff.
So
last
year
I
set
out
and
said
like
yeah:
let's
build
something,
really
complicated,
something
like
a
thermometer
and
you
know
like
make
it
not
as
easy
and
add
a
Raspberry
Pi
into
the
mix
and
add
some
something
like
a
sensor,
and
this
will
be
done
then
afternoon
I
want
to
do
it
with
rust,
so
yeah
I'm
gonna
look
for
a
driver
because
there
is
Python
drivers
and
who
wants
to
do
that
yeah.
B
B
B
It
also
my
scoping
changed
from
an
afternoon
to
probably
a
few
weeks
and
yeah,
so
it's
all
easy
right
and
so
yeah.
The
first
thing
I
learned
is
that
GPIO
is
not
everything
and
yeah.
It's
mostly
interrupts
and
events
and
things
like
the
buttons
give
you
what
I
was
actually
looking
for
is
something
like
SPI
or
i2c,
both
of
which
the
Raspberry
Pi
supports,
but
yeah.
B
These
are
two
bus
systems
essentially,
and
i2c
is
more
common,
so,
especially
since
SPI
needs
a
pin
for
every
device
you
plug
in
so
yeah,
so
I
looked
closer
at
i2c
I
to
see
something
called
inter
integrated
circuit
from
1982,
and
it
has
phenomenal
bandwidth
of
400
kilobits.
A
second
there's
actually
faster
variants,
but
yeah
I
assume
that
this
is
more
more
of
in
the
vicinity
of
that
small
thing
here
and
it
uses
seven
bit
addresses
goes
up
to
ten
bits,
and
this
lets
you
connect
about
a
thousand
devices
which
I
thought
was
enough:
yeah.
B
They
are
also
able
to
connect
multiple
raspberry
PI's
on
the
same
bus
and
the
devices
come
pre
address.
So
if
you
want
to
connect
two
of
those
sensors
you're
out
of
luck,
unless
you
get
a
second
bus
going,
which
in
this
case
needs
a
second
raspberry
pi,
so
yeah
that's
an
easy
start.
This
is
what
what
I
had
to
do
and
wanted
to
do
so.
This
is
essentially
this
device
here,
so
the
Raspberry
Pi,
which
is
Raspberry,
Pi
zero.
It
has
one
wire
for
voltage.
B
Okay
hold,
it
may
be
in
this
direction
bit
more
since
you
have
a
picture
one
device
base.
One
wire
basically
suppose
gives
the
sensor
power
and
there's
two
other
wires,
one
of
which
is
the
data
wire,
so
SDA
for
data
and
SEL
for
the
clock,
so
it
kind
of
it
knows
when
something's
actually
sent-
and
not
just
you
know-
random
noise,
for
example,
and,
of
course,
there's
a
groundings
to
complete
the
circuit.
B
So
this
is
you
know
this
is
fairly
easy
to
find
out
what
the
pin
layout
is
and
connect
the
things
that
are
named
the
same.
So
this
is
this
is
the
sort
of
thing
complexity.
I
was
dealing
with
there
and
yeah
the
base
library
to
talk
to
these
ITC
devices
is
called
ITC
death
and
it's
on
crates
I/o,
just
yeah
easy
to
find.
B
So
the
result
was
that
I
created
a
crate
called
pmpo
85,
which
is
technically
a
different
device
somewhere
here
yeah,
it's
yeah
I
think
it's
that
one.
So
it's
a
bit
larger
than
this
one.
So
this
is
a
bmp180.
You
can
see
what
what
the
version
difference
makes
and
but
they
use
the
same
driver.
So
this
driver
works
for
both
of
those
devices
and
it
gives
you
the
temperature
and
air
pressure
of
whatever
it
measures.
B
B
So
in
case
of
this
PMP,
this
need
means
you
need
to
read
calibration
data
from
the
sensor
say:
if
it's
somewhere,
then
you
write
to
a
command
register
until
it's
like
I
want
to
have
temperature
next,
then
you
wait
and
then
you
read
from
the
data
register
and
get
what
you
yeah,
what
you
want
it,
and
then
you
translate
you
factory
in
the
calibration
data
and
then
you're
basically
done
so.
Let's
take
a
look.
How
easy
that
is,
so
it's
not
readable
at
all.
B
We
will
see
that
later,
but
enums
are
very
nice
to
use
in
this
space
in
general.
As
you
can
see,
there
is
also
more
of
that
of
these
items,
especially
for
registers.
This
is
very
handy.
You
can
use
some
hex
literals
there
in
order
to
you
know,
mapped
addressing
space
quite
quite
nicely
in
C++,
for
example,
that
was
just
a
gigantic
amount
of
constant
variables
that
wasn't
defined
the
header
file,
which
yeah
is
you
know
it's
hard
to
find
sometimes
the
stuff
you're.
Looking
for
these
are
the
calibration
registers.
B
I
was
talking
to
talking
about
earlier,
and
this
is
the
the
actual
thing
that
does
something
to
control
register,
and
this
is
where
something
is
yeah.
When
you
read
data
from
the
data
register,
then
there's
also
two
commands
that
you
put
in
yeah
like
read:
temperature
or
read
pressure,
of
course,
since
we're
in
that
space,
we
also
need
to
convert
between
big-endian
and
little-endian,
which
is
always
quite
fun,
to
find
out
what
you
actually
have
to
use
and.
B
You'll
figure
it
out,
you
have
one
test
yeah.
This
is
this
is
where
the
actual
reading
happens.
So
you
read
the
raw
temperature
by,
as
I
said,
sending
a
to
control
as
sending
to
the
control
register,
so
the
device
comes
in.
So
you
have
an
SMS
right,
bytes
data,
so
you
write
exactly
one
byte
to
this
register
and
you
add
this
command.
So
you
know
it's
like
reads
this
or
get
me
some
temperature.
Then
you
wait
in
this
case
five
milliseconds,
which
is
exactly
according
to
the
specification,
but
it's
a
blocking
thing.
B
You
have
to
put
it
in
there
and
then
you
read
from
the
data
register
and
you
hopefully
get
something
back.
If
you
are
quicker
than
those
five
milliseconds,
you
will
get
some
garbage
data,
probably
or
an
overflow,
because
you
know
you're
doing
some
extensive
calculations
done
here
and
some
of
them
fail
quite
easily,
especially
it
shifting
things
yeah
and
there's
a
lot
of
those
things
that
are
really
peculiar
to
drivers.
B
I
guess,
because
there's
a
lot
more
coming
from
that
and
I've
I've
copied
most
of
that
I
try
to
look
through
what
it
actually
means,
but
it's
quite
hard
to
understand
what
actual
thing
does
since
also
it's
not
it's
not
helpful
that
they
use
the
register
names
to
describe
the
variables
and
yeah.
This
is
from
the
specification
and
it's
quite
interesting-
the
the
D
test,
I
kind
of,
tells
you
if
you're
right
or
wrong
and
yeah
the
same
goes
for
the
pressure.
B
The
pressure
has
some
something
in
here
that
it
factors
in
the
sampling,
which
is
quite
interesting,
so
you
have
basically
put
in
some
yeah
a
binary
pattern
and
you
add
the
sampling,
so
it
kind
of
knows
where
how
long
it
should
read,
or
rather
what
did
you?
What
did
how
accurate
it
should
be,
and
you
have
to
figure
out
the
nearside,
how
long
you
should
wait
in
order
to
get
the
right
yeah
the
right
reading
out
of
this
and
then
the
register
here
is,
for
example,
three
bytes,
the
other
one
was
two
bytes.
B
So
this
time
you
have
three
bytes
and
yeah
I
wasn't
really
sure
how
to
put
this
in
use
the
u-32
and
then
I
used
the
integer,
a
32-bit
integer,
because
I
wasn't
sure
if
there's
negative
pressure
that
it
can
read
something
this.
These
are
the
sort
of
things
that
you
deal
with
a
lot.
So
every
temperature
is
quite
easy
here.
This
basically
directly
gives
you
back
Celsius.
B
The
read
pressure
is
a
bit
more
complicated,
so
you
read
the
temperature
in
order
to
obtain
a
coefficient
that
you
only
get
when
you're
reading
to
temperature,
so
the
temperature
influences
the
pressure
reading
quite
a
lot.
Then
you
have
coefficients
you
read
from
your.
You
know
from
your
calibration
earlier
and
then
you
do
a
bit
more
of
random,
more
or
less
random
calculations
of
stuff.
B
B
So
this
is.
This
is
destruct
itself,
there's!
No!
No!
No
big
secret
here
does
this
is
reading
the
the
coefficients
that
a
new
method
really
goes
into
and
reads
like
a
bunch
of
10
10
or
something
coefficients
from
the
device
and
returns
it
here
and
then
you
save
it
and
then
this
is
for
the
lifetime.
So
I
guess
if
you
probably
change
altitude
a
lot.
So
if
you,
you
know
calibrated
at
the
bottom
of
a
mountain
and
then
go
up,
maybe
this
changes.
I
didn't
try
that.
B
So,
if
anyone
does
that,
please
let
me
know
submit
a
pull
request
and
github
or
something
because
that
would
be
interesting.
What
I
used
was
from
I
from
the
i2c
dev
library,
since
this
guy
already
created
a
barometer
and
thermometer
trait,
I
implemented
those
sort
of.
I
thought
it
was
a
nice
thing
to
integrate
with
so
this
is
was
yeah
a
fairly
simple,
fairly,
simple
thing
to
do
to
do
here
and,
as
I
said,
the
coefficients,
so
just
just
a
massive
amount
of
reading
done
here
and
then
save
it.
B
It's
not
nothing
special
and
here
is
the
test.
No,
actually
it's
more
tests
than
that,
but
it's
yeah.
First
of
all,
I
have
to
had
to
implement
a
mock
device
and
for
the
mock
device
to
kind
of
save
data
and
return
it
properly.
In
order
to
test
you
know
what
I
was
calculating
since
I
wasn't
really
sure
how
this
works
and
yeah
there's
a
lot
of
stuff
going
into
the
calibration,
so
I
faked
the
calibration
and
the
calibration
itself
and
the
writing.
Of
course
you
saved
it
into
a
bearable,
but
the
writing
itself.
B
So
the
the
test
that
was
from
the
specification
was
basically
giving
you
a
bunch
of
coefficient
coefficient
calibration
values
and
then
an
input
value
and
then
what
the
output
should
be,
and
then
you
kind
of
iterate
on
that,
as
as
long
as
needed
until
it
worked,
which
is
probably
not
the
way
to
do
this
properly,
but
this
was.
This
is
currently
the
only
thing
that
I
have
in
order
to
improve
that
driver.
B
B
So
I'm
here
connected
by
H
onto
this
thing,
so
it
only
has
a
network
with
me
right
and
in
order
to
connect
and
i2c
device
to
a
Raspberry
Pi.
You
need
to
load
some
common
modules
that
probably
come
with
with
raspbian
they're,
probably
already
loaded,
and
then
you
have
some
tools
in
order
to
work
with
all
of
that
I
to
see
stuff
from
the
get-go,
so
you
can
do
I
to
see
detect
and
then
you
get
the
matrix
of
stuff.
B
So
we
can
I
already
built
it,
because
building
on
a
Raspberry
Pi
takes
a
while.
So
in
this
case
it
should
not
do
anything
and
we
have
to
run
the
binary
directory
because
we're
gonna
use
sudo
so
and
yeah.
This
is
it
so
it
reads
that
it
has
25
degrees
Celsius
in
here,
and
we
can
warm
it
up,
maybe
a
bit
so
yeah
and
of
course
it
crashes
yeah.
B
B
So
this
this
happens,
especially
it
is
multiplied
with
overflow.
As
we
can
see
it
is.
This
would
probably
wouldn't
happen
in
Python
as
much
or
maybe
not
at
all,
since
it
has
very,
let's
say,
flexible
data
structures
there
and
then
see
also
there's
sometimes,
students
like
yeah
use
this
number
pointer
and
then
you
do
some
magic
on
in
the
end
you
say
it's
like
yeah.
This
is
now
basically
a
16-bit
signed,
integer
and,
and
it
all
kind
of
works
it's
now.
B
Then
Indian
Ness,
of
course,
I
dealt
a
lot
with
that
because
it's
both
both
of
these
give
you
a
number.
The
question
is
only
what
number
and
can
you
you
know?
Sometimes
it
doesn't
really
say,
or
it's
not
clear
what
what
they
actually
give
you
back
and
maybe
sometimes
it
changes,
because
you
can
read
two
registers
with
each
byte
and
then
you
have
a
16
16
bit
number
and
you
know
you
can
use
it.
B
However,
you
want
it's,
maybe
not
right,
though
yeah
the
tests
or
tests
or,
however
many
you
can
make
out,
is
it's
very
interesting
and
this
was
valuable
feedback
right.
It's
not
I
tried
it.
I
have
used
this
sensor
and
this
driver
a
lot
of
a
lot
of
times.
I
did
never
crash
for
me.
It's
like
that.
So
I
can
use
this
valuable
feedback
to
kind
of
try
and
figure
out
what
went
wrong
there
and
yeah
it's.
B
You
know
that's
different,
since
this
is
physics
about
this
could
be
very
different
experience
for
someone
who
lives
in
or
something
where
they
have
like
a
thousand
meters
above
sea
level
by
default,
and
here
we
have
like
what
30
so
there's
differences
in
yeah
and
a
lot
of
things
and
it's
very
hard
to
get
it
right.
And
of
course
you
have.
You
know
some
minor
things
like
cross
compilation
issues
that,
for
example,
these
io
things
don't
build
very
well
on
a
Mac
because
there's
something
missing
that
I
didn't
know
what
it
was.
B
I
just
used
the
virtual
machine,
because
Linux
works
really
well
and
of
course,
dependencies.
You
walk
straight
in
the
dependency
hell,
if
you
don't
keep
it
updated
or
yeah.
If
you
add
too
many
dependencies
and
you
have
like
I
think
this
driver
has
not
like
for
just
by
one
by
adding
one
crate
but
yeah
other
other
project.
I
have
have
like
hundred
dependencies
just
from
nothing,
essentially
yeah
and,
of
course,
I,
learn
something
so
that
drivers
are
not
that
scary
to
implement
they're
sort
of
fun.
B
I
did
something
with
typescript
the
other
day
and
it
kind
of
yeah.
It
only
took
pictures
of
about
three
megabytes,
then
serialized,
a
picture
that
took
about
ten
megabytes.
The
whole
application
had
about
a
hundred
and
ten
megabytes
for
some
reason
that
I
didn't
know
and
yeah.
It
used
to
run
out
of
memory
because
the
garbage
click
that
didn't
go
into
going
as
quickly
as
a
thought
so
yeah.
It
was
not
the
greatest
experiences.
B
The
rest
unfortunate
and
yeah.
There's
a
lot
of
CPU
architectures
available
to
build
for,
and
it's
yeah
drivers
are
great
to
do
just
do
stuff
with
IOT.
Then
you
can
yeah
fancy
yourself
being
an
IOT
person
quite
quickly,
so
yeah
as
a
summary.
If
you
didn't
pay
attention
until
now,
I
have
just
grabbed
I
to
see
death.
If
you
have
an
i2c
sensor,
figure
out,
the
messaging
protocol
created,
wrap
it
into
a
nice
API
and
find
tests.
B
It's
I
think
the
mean
are
things
to
do
here,
something
that
is
nice
to
work
with
is
the
tehsil,
since
it
has
comes
prepackaged
with
rust
api
for
all
of
their
senses.
I
think,
and
it's
yeah
it's
a
similar
board
as
the
Raspberry
Pi
and
yeah
it's
documentation
and
all
kinds
of
stuff
and
the
other
two
things
are
links
to
the
crates
I've
been
using
and
developing.
So
thank
you.
It's
not
time
for
questions
and
you
can
follow
me
in
Twitter.
C
D
B
A
And
thank
you
everyone
for
attending.
It
was
really
nice
and
you
can
stay
around
if
you
want
I'm,
not
gonna
leave
immediately.
So
if
you
want
to
eat
some
of
the
leftover
bagels
or
just
have
another
drink
and
talk,
you
can
do
that,
but
you
are
also
free
to
leave.
Of
course
and
yeah
see
you
next
time
we
will
have
meetup
in
late.
October
I
haven't
settled
on
a
date
yet,
but
we
will
yeah,
let
you
know
soon.
Thank
you.