►
From YouTube: .NET Design Reviews: GPIO
Description
We took a look at an API proposal for general purpose IO (GPIO). Notes are here:
https://github.com/dotnet/apireviews/pull/66
C
Well,
it
did.
The
title
is
assistant.
Vice
GPIO
looks
like
rich
and
I
have
been
talking
about
this,
and
the
idea
is
to
have
the
one
PLL,
but
I
don't
think
the
system
does
device.
That
GPIO
is
the
right
name.
We
were
over
pivoting
right
on
the
GPIO
right
because
and
that's
what
I'm
going
to
talk
next,
we
plan
to
have
four
namespaces
systems
out
device
of
GPIO
which
will
contain
all
of
the
types
that
allow
you
to
access
the
GPIO
pins
directly.
C
This
means
opening
closing
them
reading
and
writing
to
them
and
subscribing
for
events.
Then
we
plan
to
have
a
different
name
space,
and
this
also
kind
of
like
echoes
what
we
have
in
current
API,
like
when
Artie
SDF,
so
the
PWM
namespace,
which
will
contain
only
the
pulse
width,
modulation,
operations
and
and
and
like
all
the
types
of.
Let
you
access
that,
then.
C
D
C
So
that's,
basically
yet
and
and
well
I
mean
I,
don't
know
how
how
deep
you
guys
want
to
go
over
i2c
n
SPI
protocols
in
particular,
but
basically
the
main
idea
is
they
use
like
digital
zeros
and
ones,
but
they
also
one
of
the
pins
hooked
up
to
the
device
is
a
clock,
so
they
basically
can
send
out
like
square
waves
that
in
the
messages,
so
that's
that's
mainly
how
they
work.
There's.
E
F
C
And
so
now
we're
gonna
go
over
kind
of
like
the.
This
is
what
Stephen
after
earlier,
which
is
like
what?
What
are
the
changes
between
the
iteration
one?
We
mainly
got
three
sorts
of
feedback.
If
you
can
scroll
down
a
little
bit,
you
know
please.
So
first
one
was
like
small
changes.
Witching
like
had
casing
on
members,
didn't
match
what
we
usually
do
on
the
dotnet
framework,
the
the
main
their
names
didn't
kind
of
mimic.
C
Then
we
got
all
the
types
of
feedback
that
was
a
little
bit
bigger
implementation,
wise,
which
is,
we
talked
a
bunch
about
the
ownership
of
objects,
the
lifetime
of
when
should
objects,
because
those
two
ohm's
who's
posting
them
and
stuff.
Like
that,
whether
or
not
we
should
use
singleton
implementation
for
a
few
classes,
and
so
we
did
take
on
the
singleton
pattern
for
a
few
of
our
classes,
which
we'll
talk
about
more
later.
But
basically
the
API
surface
didn't
change
that
much.
C
But
it
does
mean
that
we're
now
using
factoring
methods
and
stuff
like
that,
so
the
biggest
point
of
feedback
that
we
got
in
and
it
was
actually
some
feedback
that
we
got
after
the
review
wasn't
actually
doing
the
review.
But
this
is
the
thing
that
basically
changed.
All
the
API
surface
was
whether
or
not
like
the
decision
of
whether
or
not
we
should
have
the
pink
class
in
exposed
like
as
an
object
or
if
we
should
just
have
pings.
C
So
this
is
something
that
came
up
after,
like
'man
and
in
the
actual
with
you
that
we
post
and
github,
so
it
came
out
there
and
then
we
started
a
bunch
of
discussions
out
of
that.
So
this
is
what
we're
mainly
going
to
talk
about
during
this
review
since
I
think
at
least
the
functionality
we
already
covered
in
the
first
review.
So
in
here
we're
basically
just
going
to
show
you
both
models
of
how
does
it
look
without
app
in
class?
C
C
C
F
C
Correctly,
yes,
but
then,
if
I
mean
yes,
they
can
do
that,
but
they
will
still
call
all
of
the
methods
through
the
controller.
Yes,
that's
the
wrapper
piece.
They
can
do
that
yeah
and
then
I
mean
another
pro.
Is
that
it's
just
a
simpler
model
in
general?
The
cons
of
this
is
that
we
now
have
a
controller
class
that
basically
for
pretty
much
all
of
its
instance
methods.
It
takes
a
PIN
number.
C
So
if
you
follow
kind
of
like
the
the
patterns,
it
would
tell
you
that,
like
if
you
have
a
class
where
all
of
the
methods
taking
the
same
parameter,
it
probably
means
that
you
might
want
to
add
a
new
class.
So
in
this
case
we're
specifically
ignoring
that
pattern
and
saying
we
want
to
represent
them
as
integers
instead
and
then
another
con
is
how
eventing
looks
like
I
added
another
point
in
there,
but
that's
actually
not
true.
C
Look,
might
look
a
little
bit
more
familiar
to
dotnet
developers.
When
you
pin
model
contact,
yeah
pin
object.
Sorry,
then,
when
you're
not
using
it.
So
if
we
scroll
down,
we
have
some
kind
of
like
a
little
snippets
of
examples
of
how
others
it
looked
like
to
do
simple
operations
when
you're
using
the
new
world
a
model
with
none,
no
pin
object
and
the
one
that
does
have
the
pin
object.
So,
as
you
can
see
above
basically,
you
are
calling
you're.
C
Turning
on
and
off
the
pin
through
the
controller
you're
passing
in
integer,
whereas
in
the
second
one
we're
basically
just
getting
the
pin,
object
yourself
and
then
you're
calling
methods
into
that.
That
obviously
don't
need
that
editor
anymore.
Why
do
you
have
to
open
the
pin
before
I?
Think
you
just
do
that
directly
from
right?
Oh
no!.
C
C
K
K
C
Fine,
like
that's,
why
it's
wrapped
under
using
and
theory
like
once
the
control
gets
this
post.
It
will.
Basically,
you
set
the
state
of
all
of
the
pins
that
it
it
have.
It
keeps
a
state
of
which
pins
it
has
opened.
It
will
also
kind
of
prevent
you
to
open
up
in
twice
and
and
the
controller
by
the
way
is
the
one
that
it's
false.
It
follows
a
singleton
pattern,
so
it
basically
knows
which
bins
are
objects
are
opened
and
it
will.
It
will
prevent
you
from
doing
this,
I
mean.
D
What
situation,
what
I?
Sorry
in
one
situation
when
I
choose
to
use
the
ladder
like
you
know,
storing
the
GPIO
pin
and
then
using
that,
rather
than
just
calling
the
methods
on
the
controller,
their
advantages
disadvantage
to
the
approaches,
so
I
fall
off
a
cliff
with
one
and
have
to
use
the
other
etc.
You.
C
Know
like
it's
basically
I
mean
it's
just
the
way
you
write
the
code,
but
implementation
wise.
It
is
exactly
the
same
and
it
has
the
exact
same
effect
like
the.
If
you
have
the
GPIO
pin
class,
you
don't
really
need
to
dispose
it.
The
controller
will
take
care
of
that.
So
it's
not
like
you're
setting
yourself
up
for
problems.
D
C
D
C
E
C
I
I
M
F
F
Presumably
they
don't
write
this
using
statement
because
they
they
don't
necessarily
really
know
when
to
dispose
of
the
controller
right.
So
then
do
they
have
to
have
a
controller
method.
Sorry,
a
controller
parameter
and
kind
of
all
of
their
methods,
or
they
have
to
like
trying
to
have
this
init
thing
it
wigs.
A
In
and
closed
the
controller
just
coming,
I
would
say
it
depends
on
the
timer
and
I
mean
if
you
have
a
minor
library
that
I
don't
know
the
candles,
like
particular
lights
or
whatever
then
I
think
that's
what
you
would
do.
If
you
have
a
more
you
know,
end-to-end
solution,
like
I,
think
crystal
came
up
with
this
robot
example.
Either
you
have
like
a
pre-canned
robot
basically,
and
that
thing
takes
care
of
everything
and
then
you're
supposed
to
call
robot
dot
go
do
stuff
right
yeah.
A
A
F
I
F
K
C
Don't
have
those
methods
to
be
static
right
now
and
we
have
the
messages.
Any
sense
methods
is
because
we
haven't
gotten
into
the
gate
controller
method
yet,
but
there
is
state
in
that
controller.
Basically,
there's
two
things
of
state
in
the
controller,
one
is
the
driver.
That
is
basically
the
thing
that
knows.
H
I
I
Had
discussed
in
the
last
meeting
that
the
concept
of
the
thing
that
the
user
gets
might
carry
the
state,
but
internally
there
might
still
be
a
singleton
for
the
actual
device.
That
way,
you
can
separate
the
concept
of
their
state
that
the
user
needs
to
clean
up
versus
there's
a
device
that
you
can
only
ever
have
one
of
that.
C
H
I
Because
you
could
imagine
the
case
where
you
have
like
a
PI
and
you
want
to
manage
two
sensors
individually,
and
so
you
want
to
manage
those
pin
States
separately.
But
ultimately
you
still
have
one
controller
instance
at
the
root
that
has
to
be
shared
between
the
two
states
that
the
you
that
the
libraries
are
controlling,
listen
and.
J
Is
kind
of
Tanjung
whether
this
is
really
present
for
every
PI?
In
that
case
you
know
the
singleton
controller,
you
know
it
looks
like
unnecessary
abstractions
or
whether
this
should
be.
This
is
like
some
abstraction
designed
for.
Oh,
you
have
some
some
device.
That
has
you
know
multiple,
maybe
boards
with
pins
attached
to
it
and
each
of
the
boards,
as
like
its
own
controller,
yeah
yeah.
It
gets
to
the
concept.
I
Like
so
I
gave,
this
is
an
example,
a
stronger
you
have
DirectX
where
you've
got
the
in
the
DirectX.
Api
is
a
the
adapters
which
are
the
physical
devices,
and
they
then
they
dispose
the
DirectX
graphics
device,
which
is
the
virtual
layer
that
the
user
actually
sends.
The
drawing
API
is
through
at
the
higher
level,
and
so
you've
got
that
physical
versus
logical
distraction
for
I've
got
something
that
you
know.
There
is
only
a
single
time
because
it
physically
exists
in
the
real
world,
and
that
could
be
a
microcontroller.
I
It
could
be
a
sensor,
it
could
be.
You
know,
a
device
with
multiple
other
controllers
that
it
you
know
owns,
but
then
you've
got
that
logical
abstraction
of
well.
You
have
two
apps
that
both
need
to
be
able
to
drop
in
the
thing
simultaneously,
so
you
need
to
have
a
logical
state
for
each
of
those
apps.
That
goes
through
the
physical
thing
right.
F
Well,
I
mean
right:
now
we
don't
have
any
requirements
for
I
mean
we
don't
have
any
motivation.
I
mean
we
don't
have
any
concrete
requirements
to
drive
a
more
complicated
design
right.
So,
even
if
we
wanted
to
build
something
along
the
lines
of
what
you
generally
described,
I'm,
not
sure
we
would
know
what
to
build.
Okay,
you
don't
even
know
how
to
build
that
yeah.
A
The
question
is
just
is
like:
oh,
do
you
both
that's
right,
so
one
thing
you
don't
be
doing
is
you
could
say
you
have
a
GPI
control
of
static
class
today
and
then
everything
aesthetic
methods,
but
then,
if
you
ever
want
multiple
controllers
there,
you
basically
produce
a
new
type,
because
all
the
in
static
types
would
know
static
methods
would
no
conflict
with
the
ones
you
would
put
on
instance.
Another
way
of
doing
it
is
to
say
the
GPI
controller
type
is
not
static.
Everything
is
an
instance
memory.
A
Oh
yeah,
then
you
basically
don't
have
it
I
disposed,
wouldn't
b1
and
b2
here
want
to
have
multiple
control
lines.
This
is
what
you
would
just
do.
Is
you
would
just
you
know
actually
give
people
a
public,
constructor
or
static
factory
method?
Make
it
implement
a
disposable?
Make
it
somewhat
clear
that
this
that
aesthetic
shed
instance
can't
be
disposed
and
throw
an
exception?
If
somebody
tries
to
disclose
that
one,
but
the
plastic
in
the
flag
to
the
constructors
again,
I
am
the
magic
since
or
whatever
we
just
compared
into
this.
A
F
Would
still
break,
though,
because
this
goes
back
to
my
comment
on
what
is
what
are
you
passing
into
the
libraries?
Imagine,
the
most
libraries
don't
take
a
controller
they
just
they
just
reference
down
correct
yeah,
the
gross
dereference
current
and
then
that's
exactly
the
same
problem
at
almost
as
the
static
method.
One.
A
J
K
K
K
F
I
Okay,
right,
I
think
at
least
today
there's
a
fairly
good
model
for
how
the
physical
devices
are
set
up
and
that
you
have
a
microcontroller
and
for
the
Raspberry
Pi.
That
is
the
PI
itself.
That
microcontroller
has
a
set
of
pins
which
may
have
varying
communication
mechanisms,
but
at
the
root
you
still
have
the
pins.
They
take
inputs
and
outputs,
and
you
can,
from
that
pin
set,
have
a
sub
microcontroller,
which
then
can
have
its
own
paint,
etc,
and
that
just
goes
all
the
way
down.
I
But
you
know
at
the
root
you
have
the
microcontroller
that
communicates
with
other
sensors
or
controllers,
which
can
you
know,
do
that
themselves.
There's
people
who
have
taken
raspberry,
PI's
and
hooked
them
up
together
that
people
have
taken
raspberry,
PI's
in
the
breadboard
and
put
in
8088
on
it
and
created
their
own.
C
F
C
Kind
of
followed
what
filesystemwatcher
does
so-
and
this
is
a
discussion
that
I
had
with
so
basically
wait
for
event,
is
a
method
that
would
halt
execution
and
it
would
hit
it
has
a
timeout
and
basically,
it
would
watch
for
specific
event
types
in
in
opinion
and
then,
if
the
timeout,
it
returns
back,
a
wait
for
event
result
object,
which
basically
control.
It
contains
only
boolean
of
whether
or
not
the
operation
timed
out
and
if
you
did
get
an
event.
It
also
provides
the
event
type
of
what.
C
C
C
E
A
C
A
C
The
implementation
will
change
so,
basically,
the
way
we
would
do
it
is.
We
would
have
kind
of
like
two
threads
running
in
the
background
where
you
have
as
well.
It's
very
similar
to
filesystemwatcher,
where
you
have
a
queue,
a
buffer
queue
I
see
so
we
buffer
events,
it's
right,
you
buffer
them.
So
there's
one
thread:
that's
basically
just
monitoring
for
the
events
and
putting
them
on
the
queue
and
then
there's
the
other
thread.
That's
basically,
processing
those.
Do
we
drain
the
queue
like
nobody
calls
the
wait
forever
and
ever
we.
C
K
A
C
We
won't
be
monitoring
for
events
right.
We
won't
be
at
that
point.
We
won't
be
monitoring
for
events
until
you
subscribe
until
you
say,
I
want
to,
for
this
specific
pin.
I
want
to
well.
I
want
to
get
notified,
so
even
there's
two
eventing
models.
One
is
that
we
support.
One
is
the
wait
for
event
with
which
is
the
blocking
one,
and
then
you
have
you
could
register
for
a
callback.
So
if
you
do
any
of
those
two,
then
we
will
start
listening
for
events.
D
F
D
Well,
I
think
we're
talking
about
multiple
things
here.
I,
don't
think,
that's
true
that
you
have
to
go
to
the
avenging
pattern.
I
think
is
I
mean
by
the
inventing
pattern.
You
mean
the
callback
one,
the
you.
You
know
the
event
handler
one,
because
if,
if
I
had
two
different
buttons
and
I
wanted
a
way
for
both
of
them
to
be
signals,
I
can
do
make
two
calls
to
wait
further.
Then
async
one
for
each
and
then
say
wait
all.
D
D
C
So
we
could
expose
that
as
well.
Kind
of
like
a
way
to
control
of,
like
I,
want
to
start
listening
for
events.
I
wouldn't
like
to
just
have
the
controller
automatically
when
it's
need
up
to
start.
Listening
for
events,
I,
don't
think.
That's
a
good
idea
because,
like
you're
gonna
get
a
bunch
of
interrupts
so.
C
How
wait
for
event
how
this
similar
thing
where
it
works
in
filesystemwatcher,
is
you
do
have
to
both
things?
You
have
wait
for
event
and
you
have
an
enabler
that
basically
starts
listening.
So
what
wait
for
event
does?
Is
it
checks,
if
enable
racing
events
is
set
to
true?
If
it's
not,
then
it
sets
it
to
true.
C
It
waits
for
the
timeout
to
expire,
and
then
it
said
it
sets
it
back
to
the
original
state,
so
it
won't
affect,
like
all
the
code
that
ran
before
wait
for
mint,
then
after
the
state
will
be
the
same,
you
won't
be
if
you
weren't
in
like
caching
events
before
then
you
won't
be
catching
events
after,
but
if
you
already
have
that
turned
on,
then
the
call
to
wait
for
you
and
won't
turn
it
off.
Do
you
see
any.
I
But
maybe
it's
worth
that
allowing
the
user
to
actually
be
like
I
want
to
peek
at
the
top
message
in
the
queue
I
want
to
be
able
to
get
the
message
from
the
queue
I
want
to
wait
for
the
next
message
to
come
into
the
queue
see
what
it
is
and
determine
what
I
want
to
do
with
it
myself.
It's
a
very
low
level.
Api
then,
but
it's
similar
to
how
like
I
mean.
D
C
Yeah
we
could
have
both
like
thousands
and
what
your
explosives,
both
as
I
said,
and
so
what
we
can
do
is
we
can
not.
We
can
like
not
force
the
developer
to
have
to
call
enable
raising
events
whenever
they
they
want
to
just
wait
for
an
event.
So
we
can
internally,
like
flip,
that
on
while
we're
waiting
for
an
event,
and
then
we
can.
C
D
I,
don't
think
we
should
site
miles
as
too
much
I
think
this
API
on
PAL
system
watcher
is
terrible.
In
fact,
we
didn't
I,
explicitly
cut
it
for
dotnet
core,
and
then
we
brought
it
back
for
two.
Oh,
when
we
brought
back,
you
know
all
the
api's
for
compatibility,
but
I
wish
it
wasn't
there
because
it
it
is
so
prone
to
problems
of
problems.
Yeah.
A
I
think
I
mean
one
thing
you
could
be
doing
one.
You
could
say
you
have
this
anywhere
raising
event
where
you
call
it
originally
I
didn't.
If
you
say
you
call
a
white
poisoned,
you
speed,
set
whether
we
see
whether
it's
checked
and
if
it's
not,
we
throw
and
say
you
have
to
enable
this
and
then
basically
as
soon
as
you
enable
it
be
buffer,
and
we
stop
offering
you
disable
that
what.
C
A
That
it's
prone
to
errors,
because
basically
you
forget
to
set
it
alone
now
the
code
looks
fine,
but
nothing
ever
happens
right
versus
in
this
case.
If
you'd
forget
it,
if
they
soon,
as
you
call
wait
for
Remy
for
an
exception
and
say
embedded
operation,
you
have
to
turn
on
the
phone.
Otherwise
we
down
so
this
case
usability
yeah,
it's
you
don't
see,
but
if
you
ever
wonder
cause
at
least
once
you
will
immediately
told
what
to
do
instead.
A
But
at
that
point
you
have,
we
have
a
very
clear
lifetime
semantics
of
view
of
your
cue
and
it's
clear
that
if
you
don't
drain
it,
then
bad
things
will
happen,
but
I
think
I
would
have
you
of
like
Stephen
man,
I
mean
honestly
like
if
you
can
avoid
the
problem
altogether
and
just
said
the
only
way
you
get
any
man
is
by
subscribing
and
be
dispatched
to
you,
and
then
you
either
drop
it
on
the
floor.
You
don't,
then
it's
all
on
you
so
I
think.
D
If
that's
not
true,
I
think
just
we're
setting
ourselves
up
for
failure
with
this.
We
could
try
and
simulate
it
by
you
know,
rather
than
having
a
buffer
that
buffers
everything
you
have
a
buffer,
that
Bofors
buffers
one
thing
and
once
there's
something
there,
it
just
stops
listening
until
that
thing
is
consumed
and
then
it
waits
you
know
a
then
it
buffers
the
next
thing
so
that
at
least
wafer,
then
it
would
be
able
to
pull
pull
off
something.
D
R
A
C
D
J
J
F
D
J
You
need
to
wait
for
multiple
things
right,
so
I
think
these
are
the
kind
of
two
two
patterns
to
optimize
for
one
is
kind
of
they're,
not
naive,
you.
You
know
the
my
first
gpio
program
for
that.
You
know
like
the
wait
for
even
just
complication
thing
and
the
other
one
I
saw
you
know.
I
just
have
like
lip
service,
a
measure.
You
know
that
kind
of
drives
my
device.
A
D
F
I
Maybe
something
that
could
do
here
for
the
case
where
we
don't
want
to
always
pull,
but
we
do
want
to
pull
for
loops
is
we
could
have
a
controller
dot
like
start
listening
event
that
returns
a
object?
That
itself
has
the
weight
for
event
and
while
that
object
it
returns
is
live
and
not
disposed
it.
You
know
huge
up
the
bumpers
of
a
messages,
and
then
we
never
seen
have
like
that
on
a
GPIO
pin
can
reader
I,
think
yeah
and
so.
L
E
C
The
writing
and
the
reason
why
that
would
be
interesting,
Steven
and
and
why,
like
buffer
queue
now,
just
one
is
interesting.
Apart
from
from
not
missing,
events
is
that
then,
in
the
future,
which
is
not
in
the
current
API.
Is
there
there's
also
scenarios
where,
like,
for
example,
if
you
have
a
motor
that
rotates,
then
you
might
want
to
know
how
many
times
did
it
rotate
and
in
order
to
calculate
that
you
can
check
by
coming,
you
get
in
a
specific
thing,
so.
D
C
D
D
That
takes
everything
that's
raised
and
puts
it
into
a
channel
or
a
buffer
or
whatever
you
want
to
call
it,
and
that
buffer
is
extensive
exposed
to
the
users,
but
they
could
read
from
it
up
there,
whatever
they
wanted
to,
but
again
I,
don't
know
the
audience
for
this,
and
whether
we
want
to
expose
that
kind
of
buffering
information.
It
sounds
like
maybe
Windows
is
doing
that
and
in
its
api's.
B
C
B
C
C
I
C
The
youth
and
so
for
this
we
look
at
values
both
quite
the
Sisyphus
like
for
all
this.
We
use
Sisyphus
interface
in
Linux,
and
so
for
that
one
it
does
have
a
value
file
that
only
shows
value
of
0
or
1.
So,
even
if
it's
an
analog
pin,
it
will
show
you
a
0
or
1,
and
it
does
its
rounding
by
itself
so,
and
so
this
Paulding
basically
just
looks
at
that
file
universe
because
they
were
not
exposed
to
that
right.
C
If
we
were
to
go
and
expose
all
of
the
event
type
from
the
hardware,
then
we
would
be
exposed
to
that
and
I
think
that
then
you
would
have
to
support
eval.
We
don't
do
it
now,
because
that's
that's
something
that
West
raised
in
the
previous
review,
where
there's
so
many
pin
event
types
that
I
don't
really
care
about.
So
the
only
really
thing
that
I
care
about
this
when
the
value
the
digital
value
is
1
from
0
to
1
and
a
1
is
0.
I
C
C
Yeah,
so
that's
about
tbonz.
Can
you
scroll
down
a
little
bit?
You
know
for
the
callback
there
yeah.
This
is
I.
Think
one
of
the
points
that
initially
kind
of
like
pushed
us
over
to
use
the
older
model
to
pin
model
as
opposed
to
no
pin
object
model,
as
you
can
see
in
in
the
line
the
secondary
and
snippet.
C
We
one
could
do
both
right.
Good
I
mean
the
piece
of
feedback
like
the
way
was
implemented
on
V
one
on
iteration
one
you
did
have
to
manually
specify
enable
racing
events
great.
We
did
get
the
feedback
that
basically,
when
you
add
stuff
to
the
event
handler,
we
should
automatically
flip
the
naval
raising
events
to
to
yeah.
So
that
is
also
a
possibility,
but
at
least
the
way
it
was
implemented
initially
how
it
happens.
What
do
this
yeah.
F
And
that's
different
than
I
think
Emo's
feedback
different
before
about
needing
an
explicit
model
right.
That
feedback
doesn't
apply
to
this
right.
What
do
you
know?
Thieves
was
money.
Well,
he
was
saying
like
if
we
have
this
the
other
thing,
the
weight,
the
weight
thing
that
you
should
have
to
explicitly
opt-in
to
this
queue
being
fulfilled
and
explicitly
Ogden
to
a
not
being
filled
right,
the
event
registration.
That
seems
like
it's
different,
because,
most
of
time,
with
an
event
you
just
leave,
it
register
the
whole
time
as
opposed
to
clear
it.
F
H
I
The
same
value
in
I
think
that's
what
Stephen
was
saying
to
earlier,
which
is
in
what
I
mentioned.
We
need
to
like
coalesce
these
two
models,
because
in
both
cases,
you're
going
to
some
kind
of
buffer
system.
It's
just
in
the
former
case.
You
might
be
made
manually
managing
it
where's
in
this
case
the
controller
might
email
it
for
you,
yeah.
K
K
K
K
K
I
I
I'm
I'm
also
not
sure
that
you
would
necessarily
want
on
value
change
to
automatically
start
pushing
events.
Because
you
could
imagine
a
scenario
where
you
have
a
more
complicated
device.
And
you
want
to
set
up
several
callbacks
before
enabling
events
to
be
fired,
because
it
makes
managing
your
overall
state
easier.
C
F
J
J
Kind
of
you
know
interesting
detail,
except
like
the
moment,
if
they
available
on
the
thread
pool
like
this
will
kind
of
always
get
you
into
hey.
You
know
I
need
to
have
like
multi,
threading
clocks,
and
you
know
all
the
complexity
comes
with
it.
So
do
you
have
a
suggestion,
but
the
alternative
would
be
icing
with
icing.
You
kind
of
can
stay
on
the
single
thread
and
kind
of
thing.
C
Okay
and
then
well,
lastly,
I
wonder:
I
wanted
to
go
over
basically
like
kind
of
like
a
real
word
scenario,
because
this
is
something
that
Richard
and
I
started
talking
about
yesterday,
which
what
would
the
actual
and
you
are
like.
Why
is
what
we're
striving
for?
What
would
the
apps
would
look
like,
so
the
pen
you
can
use,
go
down
a
bit,
get.
C
C
This
Raspberry
Pi
in
my
daughter's
bedroom
and
then
I
want
to
send
the
data
of
the
temperature
meanings
to
an
Asscher
IOT
edge
and
then
I
want
to
get
notifications
in
my
phone
of
whether
or
not
the
temperatures
too
hot
or
too
cold,
so
that
I
can
talk
to
my
nest
or
whatever
it's
you
to
adjust
the
temperature.
So
when
this
scheme
will
end
up
having
three
components,
it's
going
to
be
the
console
application
that
I'm
going
to
write
and
that
one
is
the
one.
That's
only
going
to
talk
to
the
sensor.
C
It
gets
to
get
the
temperature
meetings
and
then
talk
to
a
jury.
There's
going
to
be
the
sensor
library,
which
is
what
we
kind
of
have
been
talking
about
right
now
and
that
will
expose
basically
the
mean
temperature
methods
and
all
that
and
then
there's
a
system
device.
Gpio
library,
which
is
the
one
that
we're
we're
proposing
into
it,
so
the
main
idea
is
that
if
we
provide
the
integer
only
model,
then
console
application
doesn't
really
need
to
know
at
all
anything
about
system
device.
Gpio.
C
You
can
basically
abstract
that
completely
and
the
console
application
can
only
talk
to
the
sensor.
Library
I
mean
well.
You
could
also
talk
to
systems
about
GPIO
if
you
want,
but
then
in
the
mainline
case,
in
the
main
light
case,
they're
just
talking
to
a
sensor
library
which
that
one
is
in
turn
talking
to
our
library
so-
and
here
this
this
kind
of
like
brought
up
some
questions.
F
Would
be
if
there
was
another
using
directly
underneath
that
one
that
had
a
light
sensor
as
well?
So
maybe
you
have
a
different
policy
for
changing
the
temperature
when
the
when
it's
daytime
versus
nighttime
like
well
you're,
not
gonna
need
like
covers
at
night,
so
too
terribly
cold,
and
then
the
reason
why
that's
interesting
is
you're.
Basically
assuming
the
temperature
sensor
and
the
light
sensor
are
both
using
GPIO
and
then
so.
How
do
they?
F
C
The
way
we
are
implementing
it
right
now
is
it
that
should
just
work
as
long
as
you
pass
in
different
sensors.
The
reason
is,
the
controller
is
gonna,
be
the
same
controller,
because
it's
a
singleton
so
inside
both
libraries,
they
would
be
getting
in
the
exact
same
control
area
wouldn't
know
which
pins
are
used
in,
which
is
once
are
not
by
each
library,
and
so
it
would
be
able.
F
This
is
using
a
disposable
pattern
here.
Obviously,
if
you
have
are
you
assuming
that
the
the
sensor
is
disposing
of
the
controller
as
part
of
its
implementation
as
part
of
its
disposing
or
not,
because
it
gets
complicated?
If
you
have
multiple
uses
of
multiple
different
sensors
that
are
completely.
H
F
F
F
L
I
Objects
that
are
already
well
I
think.
The
other
point,
though,
is
imagine
you
have
an
app
developer,
who
has
they've
got
a
Raspberry
Pi
they've,
gotten
three
or
four
sensors
and
they've
got
libraries
for
those
sensors
yeah.
They
want
to
connect
all
of
those
sensors
and
control
them
from
their
console
app.
They
need
to
be
able
to
understand
that
the
the
library
needs
to
understand
that
the
pins
that
they
get
passed
in
they
own,
but
they
don't
own
the
controller,
because
there
may
be
another
library
using
that
controller
simultaneously.
I
J
C
H
E
J
F
F
F
P
C
H
I
Surrender
I
think
for
the
chaining
scenario.
It's
the
same
thing
as
regular
GPIO
and
you've
got
microcontrollers
going
down
several
layers
where,
if
the
user
is
expecting,
multiple
devices
to
exist
that
are
trained
in
any
fashion,
they'll
have
to
write
some
kind
of
shim
that
that
is
the
thing
that
takes
ownership
of
the
pins
and
then
correlates
to
the
next
devices
would
write
it
and
maybe,
since
I
to
see
and
SPI
and
stuff
allow
this
inherently.
We
should
look
at
providing
some
built-in
mechanism
to
make
that
easier
for
people
we're.
C
F
I
F
Although,
if
there's
only
ever
one
device,
then
you
don't
get
exposed
to
any
of
that
complexity.
Yeah
it's
only
when,
when
there
are
slaves
that
you
need
to
deal
with
it,
yeah
and
I
have
them
I,
don't
know
what
that
looks
like
Justin,
Turner,
closing,
I'm
selling
it
and
yeah.
We
need
to
a
library
on
further
I.
H
I
Not
that
roller,
not
the
controller
right
right,
and
so
in
the
case
of
chain
GPIO
you'd
have
you
wouldn't
be
creating
a
tme
280
directly
you'd
create
a
microcontroller
which
you
you
then
would
create
the
BME
280
on
it.
So
you
have
2
pi,
which
is
3
controller.
You
create
some
controller
and
then
you
create
we
do
know.
It
sounds
like
a
lot
of
complexity.
Well,
if
you
changing
devices
where
I
yeah
I
think
we
just
need
to
elaborate
that
one
further.
I
It's
like
for
the
case
where
you're
not
training,
it's
literally
this
simple,
but
for
the
case
where
you
do
chain,
then
you
have
to
have
another
nest
in
there,
where
you
create
a
microcontroller
device,
passing
five
six,
seven
eight
and
then
the
beam,
a
280
you
pass
in
whatever
pins.
You
can
basically
saying.
H
F
F
F
If
you
do
control
C
and
don't
have
handler
because
the
the
LEDs
are
left
in
an
undefined
state,
some
of
them
are
lit
similar
or
not,
and
you
want
an
alt
on
lit
and
I
was
thinking
that
so
the
control
C
handler
is
mostly
only
obviously
used
for
like
the
interactive
scenario.
But
you
can
imagine
like
a
Dockers
environment
which
is,
which
is
what
most,
these
customers
going
to
be
running.
F
That
signals
are
used,
terminate
applications
which
is
very
similar,
obviously
to
control-c,
and
it
seems
like
very
it
seems
like
the
app
would
always
be
the
one
that
would
be
implementing
those
handlers
that
the
sensors
never
would
be,
because
that
would
be
super
bizarre
and
that
just
kind
of
pushes
further
to
the
lifetime
being
with
the
app
and
that
the
these
sensors
would
never
use
the
dispos'd
pattern
unless
there
was
some
other
state
that
they
needed
to
dispose
right.
I.
Think
if
the
controller
is
literally
the.
C
F
The
dispose
on
the
sensor
is
only
to
help
clean
up
the
controller
then
be
much
like
the
thing
you
want
to
avoid
and
say
you
have
like
16
sensors
that
you're
working
with
you
don't
want
to
have
like
you,
don't
want
spare.
You
know,
because
you
can't
even
write
a
for
each
loop
on
that.
You
don't
want
to
do
it
on
every
sensor
and
just
to
clean
up
the
controller.
Because
then,
why?
Don't
you
just
clean
up
the
controller
and
call
it
good.
C
F
M
F
Said
in
dotnet
framework,
there's
like
a
best-effort
thing,
that's
looking
two
seconds
long
and
he
said
in
core
CLR
there's
no
such
best
effort
period.
Basically,
no
yeah.
No
final
answers
are
rung
and
you
said,
there's
an
ongoing
conversation
between
him
and
yon
conversation.
Armand
sets
out
they're,
not
even
sure
the
critical
finalizar.
J
Running
the
finalizar
is
doing
shut
down.
The
problem
is
like
it's
racing
with
the
in
typical
app.
You
know
typical
of
as
much
of
icing
stuff
going
on
and
the
moment
you
start
adding
the
the
finalized
errs
on
the
background
thread.
In
parallel
with
the
foreground
activated,
it's
still
working
on
the
objects.
You
did.
You
get
deadlocks
and
crashes
yeah.
It's
basically
shut
down
as
a
hostile
environment,
yeah.
J
F
E
G
J
F
F
L
F
L
A
That,
probably
is
not
a
bad
thing.
I
think
more
interesting
would
be
like
what
the
action
items
are
for
the
next
steps,
like
is
there
I
can
seem
like
there's
still
a
bunch
of
feedback
or
may
about
the
interactions
would
be
which
probably
might
be
better
to
go
over
them.
First
address
them
and
then
do
an
actual
pass
over
the
API
ones
very
happy
with
the
interactions.
Otherwise,
you
just
need
picking
names
for
no
reason.
A
At
this
point,
yeah
like
once,
you
know
what
what
customers
are
supposed
to
do,
whether
things
are
static,
whether
they're
instances
where
there's
disposable,
then
I,
think
it
makes
sense
through
the
API.
Otherwise,
you
just
review
names
like
five
times
over
and
then
they
may
actually
change,
because
you
a
bit
of
hot,
that
I,
didn't
change
the
concept
yeah
like
I,
say
everything
about
things.
You
want
to
get
feedback
on
or
I.
B
C
So,
basically,
when
we
went
with
a
net
with
a
few
customers
last
week,
and
some
of
them
were
dealing
with,
they
were,
they
were
basically
making
my
flora
devices
that
communicate
I
owe
th
and
they
were
saying
that
once
they
were
setting
up
the
like
a
new
pie,
that's
gonna
be
basically
like
kind
of
like
a
lower
our
gateway.
They
always
hit
the
issue
and
they
forget
every
time
that
SPI
protocol
needs
to
be
enabled
by
raspberry
pie
through
config,
and
it
needs
a
meeting.
I
actually
didn't
didn't
check.
C
The
ideal
thing
they
said,
obviously
is
if
there,
if
we
exposed
to
a
method
that
can
just
enable
a
CI
for
you.
That
would
be
ideal.
I
think
that
it's
not
possible,
but
I
haven't
validated
that,
but
at
least
we
can
definitely
check
if
SPI
is
enabled
or
not.
So
they
just
wanted
us
to
expose
that
API.
So
it's
a
question
of
where
right.
The
question
would
be
where
yeah
yeah.
A
H
F
K
H
K
F
K
F
H
I
C
A
F
F
A
A
F
So
what
this
does
is
it
has
two
constructors
one.
Is
it
takes
controller
with
the
set
of
ends,
and
this
is
before
this
conversation
even
happened.
This
is
what
I
naturally
did,
and
the
reason
is
is
because
you
have
to
set
these
pins
in
different
modes,
so
the
mode
is
part
of
the
algorithm
okay.
So
this
is,
if
you
want
to
do
good
banging,
so
that's
the
one
constructor
right
so
they're
bringing
passing
an
SPI
device
so.
A
F
Was
about
four
GPIO
pins
that
you
need
to
pass
in
to
do
a
bit
banging
right
or
you
do
SPI,
so
these
are
mutually
exclusive
but
then
which
which,
which
one
you
do
I
see.
Then
this
is
the
interaction
model
read/write
and
with
which
it's
read
supports
either
of
these
constructor
types.
And
so,
if
you
yeah,
if
you.
J
F
This
right
and
then
it's
what's
the
word
it
like
proxies
that
to
the
specific
private
implementation
and
I
ported
it
from
this
code
right
there
was
Python
code
that
did
exactly
this
thing
from
Adafruit
I
see
and
then,
if
you
do
SPI,
then
it's
somewhat
simpler,
so
I
think
that's
what
this
guy's
asking.
Okay.
R
C
C
F
A
F
S
F
A
F
So
what
our
plan
is
is
to
build
a
first
class
sensor
library
for
the
protocols
that
Jose
already
mentioned.
Okay,
and
then
we
want
to
have
a
community
maintained
set
of
bindings
for
sensors
and
shaking
okay,
which
will
also
live
in
this
repository.
So
this
is
the
first
one
of
them.
We
actually
have
some
other
that
are
on
branches.
In
the
repository
that
we're
building
and
then
the
thing
we're
talking
about
is
whether
we
go
a
source,
distribution
or
binary
distribution.
F
F
O
F
All
gonna
be
in
this
repositories
sure
we
put
like
emo
dot
and
rich
dot,
or
should
we
tell
whether
or
should
we
say
if
you're
gonna
be
in
this
repository
and
be
like
in
this
semi-official
category
of
bindings,
then
you
have
to
adopt
this
particular
namespace
pattern
so
that
customers
get
they
don't
have
like
17
different
musings,
it's
it's.
These
are
basically
the
dotnet
foundation
set
of
community
supported,
sensors
and
and
and
chip
bindings.
Does
that
kind
of
make
sense
to
you?
It
does
I
mean
I.
C
D
A
Even
if
what
you're
on
said
is
true,
are
they
even
the
other
one
might
not?
Last
for
five
years,
the
other
one
who
may
have
to
change
in
two
years?
So
no
because
well,
the
whole
ecosystem
has
change
their
minds
on
how
they
expose
pinzón
blah
yeah,
in
which
case
you
know
what
is
more
official
way
that
make
more
sense
answer
the
question.
It
seems
like
it
at
this
one,
no
response,
no
others
GPIO
pins,
added
to
same
controllers.
How
can
I
pass
the
eight
pins
to
different
library?
A
C
K
F
F
F
F
K
J
K
L
I
Constructors,
right
but
I
think
we
were
saying
you
have
what
were
the
things
where
you
are
banging
you
have
a
software
implementation
for
both
i2c
and
SPI.
That
way,
you
don't
have
to
provide
three
constructors.
You
provide
the
the
devices
that
are
meant
to
communicate
through,
and
then
you
provide
the
software
implementation
without
having
to
provide
a
third
constructor
for
that
for
the
GPIO
case.
K
A
The
guy
in
the
chat,
says
always
see
where
the
confusion
comes
from
MCP
three:
zero.
Zero
eight
is
a
DC
which
I
guess
is
a
Remington.
What
is
the
converter
order?
I
know
a
caller
ID
yeah
an
MCP
two,
three
zero
zero,
eight,
which
is
what
he
is
talking
about
as
a
GPIO
expander.
Oh,
so,
like
he
says,
like
goal
of
chippers
to
add
new
pins
to
AB.
How
can
I
use
this
new
pins
in
different
library.
I
A
K
Still
like
in
the
controller
like
let's
say
you
will
not
query
hair
to
get
all
the
I,
don't
know
actually
like
controllers,
it's
something
like
that,
and
very
you
have
kind
of
like
one
directly
connected
to
the
port
and
one
indirectly
through
like
something
SPI
kind
of
interface.
Let's
put
some
other
things
for
something
you
still
have
to
kind
of
be
able
to
see
both
of
them
in
the
end.
I
Then,
when
you
write
your
controller
library,
probably
you
would
have
to
provide
a
mechanism
to
return
that
data,
because
there's
like,
if
you've
got
one
Raspberry
Pi,
that's
connected
to
another
Raspberry
Pi,
which
then
has
the
sensor.
You
have
to
have
some
way
of
saying:
hey
second
Raspberry
Pi.
What
devices
do
you
have
connected
to
you
and
it
has
to
be
able
to
return
it
because
there's
no
way
that
the
first
one
can
have
that
knowledge.
Otherwise.
A
C
C
K
E
Weird
thing
about
that
is
that
underneath
there's
gonna
be
a
pin
abstraction
anyway
for
each
controller,
/
driver
so
you'd
end
up
having
a
one.
That'll
suffice
right,
well,
yeah,
even
with
just
FS,
because
you
need
to
keep
track
of
you
know:
yeah,
there's
an
open
file
properties
round
I
mean
there's
gonna
yeah,
there's
going
to
be
a
dictionary.
If
this
doesn't.
I
C
C
The
configuration
of
like
which
pin
do
they
use
and
to
which
pin
is
it
connected
to
because
for
a
specific
Raspberry
Pi,
it
might
be
using
already
the
pins
that
that
the
default
app
is
trying
to
use.
So
for
that
we
kind
of
added
in
the
controller.
Can
you
scroll
real,
quick
in
all
it?
Well,
not
scroll
switch
to
the
other
tab
and
then
scroll
all
the
way
down.
C
Expose
that
function
called
get
pin
number
from
config
and
it
basically
will
return
you
an
int
that,
basically,
you
have
a
default
value,
which
is,
if
there's
nothing
provided.
Then
it's
gonna
use
that
as
the
default
of
where
your
pin
is
connected,
and
then
it
would
have
a
kind
of
like
a
configuration
name
parameter
which
for
now
we're
treating
it
as
an
environment
variable
because
docker
containers
only
kind
of
support
that
they
don't
need
to
support
having
config
files
very
well
unless
you
mouse
drives
on,
and
so
it's
not
super
trivial.
C
So
what
we
thought
that
API
would
look
like
is
that
you
would
have
kind
of
like
the
configuration
name,
you
would
say
like
I,
don't
know
mo
ASI
like
necessary,
master
helps
leaving,
and
so
you
have
that
as
a
name
and
then
you
have
like
the
default
value
in
case
you
just
want
to
use
to
default.
So
I
guess
we
wanted
something
back
in
to
see.
If
that's
something
that,
like.
I
L
J
Just
didn't
find
it
yet,
but
you
know
the
configuration
program
for
docker
is
like
independent
number
from
this
thing
right.
We
did
this
like
you.
Have
you
have
this
problem
like
for,
like
everybody
knows
right
it
psyche.
Do
you
think
to
configure
the
network
parts
that
your
doctor
from
Dana
talks
right,
yeah.
D
N
J
F
Exactly
what
asp.net
does
is
so
you're
right,
the
the
doc
arisen
is
basically
you
get
to
specify
which
ports
are
open
between
the
host
and
the
definitely
that's
the
key
thing.
The
way
it's
been
on
networks,
though,
is
you
can
spot
you
can
override,
which,
which
ports
it's
going
to
use
her
for
SSL
and
and
raw
raw
HTTP,
and
that's
an
kestrel
reads
all
that
configure
in
front
so
yeah
you're
a
disgrace
like.
So
it's
like
ugly
cake,
yeah.
F
In
there,
I
might
just
want
to
say
one
more
thing,
which
is
in
asp.net.
The
app
code
is
completely
abstracted
away
from
ports
right.
So
that's
that's
at
the
level
of
the
Tetra
web
server,
but
you
still
have
a
way
through
environment
variables
to
configure
kestrel
and
then
AP.
It
will
adopt
those
values.
This
case
is
a
little
bit
different
because
since.
F
Gpio
style
programming
is
much
lower
level
than
web
servers.
You'd,
like
you,
need
an
application
for
view
right
for
a
web
server.
Then
your
code
is
the
one
dealing
with
the
ports
in
this
case.
So
as
a
result,
if
we
want
to
provide
configuration
than
user
code
like
like
this,
then
user
code
needs
to
interact
with
it,
but
the
model
of
the
doctor
command
line
is
effectively
that
we're
proposing
here
is
effectively
identical
to
what
asp.net
has
is
just
the
user
code
model
is
different.
I
would.
D
I
Should
we
shouldn't
have
this
on
the
controller,
we
should
probably
have
a
separate
if
we're
going
to
provide
some
default
functionality.
Along
with
this,
we
should
have
a
separate
class
that
allows
you
to
abstract
away
and
read
that
information
from
whatever
you
want,
and
then
you
can
pass
that
in
so
it's
it's
both
easy
for
the
app
developer
to
get
that
information,
whether
it's
an
environment,
variable
of
Jason,
XML
whatever
and
then
pass
that
down
to
the
controller
when
they
created
that.
F
You
can
you
can
specify
like
a
params
list
of
strings
and
then
you
get
an
int
array
back
that
would
be,
and
then
you
can
easily.
Then
you
can
pass
that
that
set
of
pins
to
the
program
like
if
you
basically
have
the
set
of
strings
in
a
particular
order,
then
you
get
the
instant
a
set
of
in
a
particular
order
and
then
you
can
pass
it
to
that
to
that
program,
that
class
that
I
wrote
before
that
expects
them
in
a
certain
order,
though
good
I
think
the
best
experience.
I
Strap
it
separately
that
way
it
can
change
where
we
do
imagine
not
going
well.
So
you
can
imagine
a
case
where
you
have
a
like
configuration
reader
and
then
you
can
as
a
like
abstract
face,
and
then
you
can
say
section
out
into
a
Jason
config
reader,
an
XML
configure
an
environment
variable
configurator.
That
way
you
can
you
users
can
decide
what
configuration
they
want
best
because
you
know
five
years
ago
it
was
XML
right
now
it's
Jason,
some
people
still
use
I
and
I
Dockers
going
to
want
environment
variables.
J
I
S
K
Keep
the
singleness
of
focus
seems
like
that.
There
is
obviously
I
need
for,
like
knocking
your
name
into
like
that
for
number,
but
seems
to
me
like,
like
I,
did
a
lot
of
devices.
There
is
something
certain
like
names
which
are
gonna
be
used
and
they're
gonna
be
set
up
from
different
places,
so,
like
SPI,
is
gonna,
be
on
in
this
class
about
SPI.
So.
K
F
K
J
D
I
F
I
This
well
and
then
I
mentioned
in
the
last
meeting.
A
lot
of
the
set
up
for
censors
is
you're,
taking
a
data
sheet
you're
taking
draw
numbers
from
and
converting
it
to
code
and
having
a
general
format
for
automatically
creating
the
boilerplate
or
c-sharp
code
from
ideation
would
be
incredibly
useful
for
the
majority
Center
sure
that
has
nothing
to
do
with
this
particular
question
right,
that's
a
totally
so
it.
F
K
F
The
action
point
for
the
food
it
does,
but
just
comes
it's
nothing
good
yeah.
This
is
like
do
a
set
of
things
it
has
to
tolerate
offline.
So
everything
so
like
the
the
thing
that
I
would
see
guys
wanted
for
the
lower
case
is
basically
the
during
deployment
you
basically
in
the
like
in
the
case
when
you're
the
you're
not
procuring,
like
you
basically
say:
here's
this
IOT
hub
this
IOT
device,
I'm
an
IOT
hub
the
website
and
as
Eurovision
yeah.
That's
what
I
was
looking
for
a
provisioning.
F
You
basically
say
I
would
like
to
provision
this
half
in
the
IMT
marketplace,
which
is
a
docker
image
to
this
device.
It
gives
push
down
to
that
device.
There's
no
opportunity
to
change
the
image
itself,
because
that's
actually
antithetical
to
the
goals
of
docker
and
then
the
thing
you're
changing.
The
only
thing
you
can
change
for
configuration
is
the
docker
run
command
line
just
where
the
environment
variables
come
in.
E
Although
for
this
API
there's
there's
a
thought,
I
had
kind
of
out
there,
but
instead
of
just
a
PIN
number,
it
could
be
a
pin
string
and
that
way,
if
you
use
an
int,
it's
a
specific
hardware
or
GPIO
pin
logical
GPIO
pin.
But
if
you
use
a
string,
it's
symbolically
mapped
to
something
else.
But
then
what
would
that
be
would
be
what
you
were
saying
like
the
next
mal
config
well,.
F
The
whole
point
of
this,
though,
is
that
you
do
provide
a
default
yeah,
because
the
config
is
not
required
to
be
there
on
this.
It's
a
it's
an
additive
thing,
so
it
feels
like
you
need
both
and
also
the
symbolic
thing
that
you
would
want
to
link
to
is
definitely
not
the
default.
Pin
number
on
your
Nina
symbolic
band,
I'm.
I
K
I
It's
like,
if
you,
if
you're
doing
individual
pins,
then
you've
got
a
direct
communication
device.
So
you
can
have
two
different
apps
controlling
two
different
sensors,
but
if
you're
using
something
which
itself
has
some
devices,
then
you
have
to
have
some
kind
of
coordinator
there,
and
so
users
could
write
a
service
that
allows
you
to
say:
hey
controller
I
want
these
I
want
this
device
from
the
sensor
all
right,
but
I
think
that
might
be
out
of
scope
for
what
the
framework
should
provide
in
terms
of
yeah
yeah.
They
should
be
writing
their
own.