►
From YouTube: OpenCPI OSP Development Workshop - GRCon 2020
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Hi,
my
name
is
aaron
olivares
I'd
like
to
welcome
you
to
the
opencpi
system.
Support
project
workshop
today,
we'll
be
learning
how
to
enable
new
platforms
on
opencpi.
I'm
glad
you
guys
are
here.
A
And
this
is
gonna
be
recorded
as
well.
A
Anyhow,
so
there
are
some
differences
if
you're,
watching
the
recording,
those
being
that
the
live
participants
have
access
to
a
pluto
sdr
over
a
vpn
and
the
pluto
sdr
is
functioning
as
a
standalone
in
a
usb
host,
meaning
it's
attached
to
a
network
interface
card
and
you
have
access
through
it
through
our
network
infrastructure.
A
In
addition
to
that,
the
doc
container
points
to
an
nfs
mount
that
contains
the
xilinx
tools,
vivato
and
vitus
tools
that
we'll
be
using
today
for
the.
If
you're
watching
the
you
would
have
to
install
those
tools
locally
on
your
system
under
op
site
links
and
then,
when
you're
launching
the
docker
container
update
the
volume
argument
with
pointing
to
those
locally
as
well.
A
These
instructions
will
be
updated.
I
was
trying
to
show
within
the
workshop
communicating
with
the
local
one,
but
I
ran
into
issues
in
the
previous
one,
so
I'm
not
gonna
do
that
right
now,
but
keep
that's
if
you
get
that
we're
gonna
update
the
cheat
sheet
with
instructions
on
how
to
do
so,
watching
the
recording
and
if
you
have
questions
while
watching
the
recording,
go
ahead
and
email
us
at
our
discussion
list.
So
we
can
help
you
troubleshoot
to
get
through
this.
A
So
the
agenda
for
the
workshop
today
we're
going
to
2
3
5
6.
A
And
we
can,
we
can
confirm
that
we
were
talking
to
the
pluto's
over
the
vpn
network,
we're
going
to
have
an
overview
of
opencpi
and
then
we're
going
straight
into
what
it
takes
to
enable
a
new
system,
and
that
includes
depends
on
the
system.
If
there's
an
fpga
one
enable
or
a
general
purpose-
processor
processor
that
you
want
to
enable.
A
B
A
A
A
Along
so
opencpi
stands
for
open
component
portability
infrastructure
and
it's
a
component-based
framework
similar
to
blocks
into
new
radio.
But
one
of
the
main
differences
is
that
components
have
can
have
multiple
implementations.
What
we
call
workers
an
example
of
that
an
example
that
I'll
continue
using
throughout
the
the
overview
is
of
the
fur
filter
component.
A
We
have
the
rcc
which
stands
for
resource
constraincy
authoring
model
which
executes
on
general
purposes,
processors,
and
then
we
have
vhdl
or
hdl
or
platforms
that
execute
fpga
implementations
of
that
worker,
and
you
can
have
multiple
of
those
for
those
author
models
as
well
an
opencpi,
it's
capable
of
supporting
other
computer
data
engines,
and
we
have
preliminary
support
for
opencl
gpus,
and
we
we
have
plans
on
continuing
development
that
so
we
can
have
gpus,
cpus
and
fpgas
all
all
in
one
and
that's
what
one
of
the
main
features
of
open
cpi
is
that
it
encompasses
the
entire
system
and
not
just
one
particular
execution
and
that's
what
we
want
to
bring
to
the
gnu
radio
community
is
the
ability
to
to
run
applications
across
the
entire
system.
A
So
another
thing
is
that
we
scan
across
vendors.
So
we're
vendor
mutual,
and
also
that
includes
fpga
vendors
or
integrated
circuit
vendors
and
then
the
device
workers
that
we
generate
is
the
capability
of
working
on
multiple
platforms
and
that's
that's
the
whole.
The
point
of
opencvi
is:
is
the
hardware
agility
the
the
ability
to
move
this
application
from
one
platform
to
the
other
without
having
to
start
from
scratch?
A
B
A
Three
distinct
development
processes
and
today
we're
talking
about
platform
development.
There
there's
another
workshop
yesterday
in
the
day
before
yesterday,
in
which
you
can
find
videos
for
that
talk
about
the
application,
development
and
the
canoe
radio,
companion
integration.
We
have
time
at
the
end
of
this
workshop.
I
can
bring
it
up
and
to
show
you
just
a
little
preview
of
that
and
the
other
is
the
component.
A
So
the
component
development
creates
the
libraries
for
for
application
developers,
so
you
combine
the
components
and
the
platforms,
and
then
you
develop
an
application
and
those
run.
You
run
that
application
and
deploy
it
across
several
different
platforms.
A
So
really
we
all
you
need
to
start,
because
I
would
is
from
here
to
here
is
all
that
you
would
need
the
highlighted
portions,
the
other
environment
variables,
so
opencpi
is
a
command
line.
The
main
interface
to
open
cpi
is
through
the
command
line,
using
command
line
utilities,
art
of
open
cpi
and
to
modify
the
runtime
environment
characteristics
of
those
executables.
A
We
use
environment
variables,
the
first
command
line
utility
we're
going
to
use
is
ocpi
remote
and
that's
going
to
load
open
cpi
on
the
pluto
sdr,
so
the
pluto
scr
is
basically,
this
firmware
has
been
is
fresh
and
there's
no
modifications
to
the
firmware
that
analog
devices
provides.
You
can
use
the
firmware
firmware
as
long
as
you're
running
version
0.32,
and
what
ocpi
remo
does.
B
A
A
A
Server
addresses
equals
192..
Oh
I'm
not
doing
that.
One
anymore
mine,
I'm
going
to
use
the
last
octet
is
119..
Please
use
the
one
that
was
provided
to
you.
A
And
then
I'm
going
to
ocpi
remote,
since
I
just
got
out
of
the
previous
workshop,
I'm
going
to
use
reload
because
it's
going
to
there's
a
sandbox
that
contains
all
that
files
and
it's
going
to
delete
that
directory
and
then
load
it
with
a
brand
new
one.
A
Where
do
I
cr
I'll
lock?
So
what
these
arguments
mean?
So
the
hyphen
s
stands
for
the
software
platform.
So
that's
the
name
given
by
opencpi
to
the
software
platform
and
then
dash
w
is
for
the
hardware
and
p
is
because
is
that's
the
password
to
ssh
into
the
into
the
pluto
sdr.
A
So
it's
quicker
for
me,
there
was
one
environment
variable
I'd
like
to
add
that
wasn't
in
the
latest
image,
if
you
have
the
latest
latest
image,
is
the
export
ocpi
underscore
hdl
simulator,
and
this
letting
open
cpi
know
that
that
xm,
which
is
a
simulator
bundled
with
the
motto
to
do
fpga
simulations
is,
is
on
the
platform,
is,
is
available
and
it
doesn't
have
to
discover
it
because
if
it,
if
it
goes
to
discover
it,
when
we
run
ocpi
run,
it
can
take
a
couple
minutes.
A
Your
guys's
end
and
that's
a
good
environment
variable
during
this
workshop,
because
it'll
save
a
lot
of
time,
bypassing
that
discovery
so.
B
A
I
haven't
started
yet
ocpi
remote
start
dash
b.
That
argument
variable
is
to
denote
let
the
embedded
target
know
that
we're
interested
in
loading
a
open
cpi
default
default
bitstream,
because
right
now
it's
analog
bitstream
and
that
bitstream
is
used
during
the
discovery
of
containers.
It's
required
to
be
there
or
else
the
fpga
platform
will
be
recognized,
so
p
analog
with
password.
A
Spit
out,
basically
the
discovery
that
happened
on
the
embedded
device,
so
we're
using
this
in
a
remote
container
sense.
So
this
is
the
information,
so
the.
A
Offered
to
the
client
should
see
pluto
sdr,
so
so
by
the
end
of
this
workshop,
we're
going
to
replace
that
platform
with
a
platform
that
we
generate
during
this
workshop,
and
it's
going
to
say
my
underscore
sdr,
so
I'm
using
the
one.
That's
part
of
the
open
cpi
system,
support
project,
that's
located
on
gitlab
repo
and
then
the
driver
there's
a
kernel
driver
that
gets
gets
built
within
an
open
cpi
that
handles
a
lot
of
the
functions
within
the
the
cpu.
B
A
Memory
making
it
available
for
user
space
and
it's
basically
our
swiss
army
knife
and
open
cpi
and
that
kernel
driver
runs
from
the
embedded
target
as
well
as
any
of
the
anybody
any
execute
any
platform,
that's
doing
execution,
and
that
can
be
the
development
host
as
well
and
kind
of
the
last
things
that
it
prints
out
is
ocpi
serve.
A
So
that's
a
a
run,
executable
that
runs
on
the
target
that
is
opening
up
a
port
and
listening
for
commands
from
open,
cpi
and
and
that
open
cpi
that
it
can
accept
data
streams
and
applications
to
to
run.
And
that's.
A
A
So
if
you
guys
are
following
along,
let
me
know
if
you
got
to
this
step
and
we
can
proceed
just
to
give
a
couple
minute
pots.
A
A
A
If
you
were
looking
for
components,
there's
a
component
directory
and
there's
a
component
specification
we'll
go
somewhere
through
some
more
of
these
terminologies
right
after
this
slide
and
then
applications
there
are
several
projects
that
are
are
part
of
the
source
and
the
core
project
contains
everything
that
you
that
bare
minimum
for
opencpi
to
function,
and
then
assets
is
the
project
where
we
store
a
lot
of
our
components.
Dealing
with
the
software-defined
radios
that,
like
dsp
components,
coms
components,
util
components,
they
have
primitives
there
as
well.
A
The
platform
project
houses,
our
device
workers
that
handle
the
transceiver
data
and
configuration
device
workers
for
those
as
well
and
under
osps
is
it's
where
we
have
the
system
support
projects
located.
B
A
Driven
so
there's
going
to
be
xml
document
for
pretty
much
every
element,
and
it's
it's
described
by
opencvi
component
specification
and
the
component
specification
is:
is
a
contract?
There's
no
implementation
behind
it?
You
specify
its
inputs
and
the
outputs
and
any
of
the
configure
parameters
or
properties
on
that
for
the
component.
A
So
the
input
port,
the
output,
ports,
what
we
call
the
data
plane
and
the
control
is
the
control
is
the
control
plane.
The
example
would
be
the
fur
filter,
some
of
the
control
properties.
You
can
modify
the
coefficients,
the
number
of
taps
and
the
coefficients
of
those
tabs
using
the
the
control
plane.
A
There's
sometimes
a
parameter
is
a
build
time
property.
So
that
would
be
a
build
time.
Example
of
the
fur
filter
would
be
the
width,
the
bit
width
of
the
coefficients,
whether
they're
16
12
bit
or
the
code
that
the
bit
width
of
the
coefficients
themselves
or
or
the
the
data
widths
of
the
ports
as
well.
A
So
the
implementation
is
called
the
worker
and
you
can
have
multiple
ones
and
there's
different
types
of
authoring
models:
rtc
hdl,
there's
ocl
for
the
different
types
of
authoring
models
within
the
worker,
there's
the
source
files
that
includes
a
make
file
a
dash,
build
xml
that
that
you
can
change
the
two
different
brand.
The
the
parameters
of
that
com
that
component
using
the
parameters
specified
in
the
component
specification
that
file
and
then
the
source
file,
and
that
that
would
be
a
c
plus
file
or
vhdl
file.
A
And
the
the
outputs,
when
you
do
when
you
use
the
ocei
dev
command
to
build
it
on
the
rcc
side
that
well
in
either
of
the
in
all
the
authoring
models.
You'll
you'll
generate
an
article
and
that
artifact
is
a
canary
file
that
contains
in
the
rcsc.
Since.
B
A
So
once
we
have
our
components
and
workers
and
the
communication,
the
messaging
between
those
components
is
defined
under
a
protocol
specification
xml
this
example
because
we're
in
the
sd
software
defined
radial
realm
is
the
real
and
imaginary
data
types,
and
this
is
a
time
stamped.
So
there's
we
use
operation
what
are
called
op
nodes
and
the
operation
time.
It's
a
64-bit
time
that
there
has
a
type
step.
A
So
we
have
our
workers
protocols,
we
start
stringing
them
together,
create
an
application,
and
the
application
is
an
xml
document
called
the
application
specification
xml-
and
this
is
a
very
this-
is
an
example
of
a
simple
application
where
we
instance
those
components
for
components,
and
then
we
connect
them.
A
So
when
you
instance
them
you
just,
you
can
specify
the
component
as
just
the
component
name
and
it
will
look
in
the
library
of
artifacts
and
find
the
workers
associated
with
that
component
and,
while
automatically,
if
not
told
to
do
so,
will
automatically
execute
from
that
library.
There
is
a
functionality
that
allows
you
to
be
more
specific
if
you
want-
and
you
can
move
that,
if
you
had
a
the
fur
filter,
for
example,
has
both
authority
models
of
hdl
and
rtc.
A
You
can
move
that
functionality
freely
within
the
application
when,
when
you
execute
the
application,
so
you
can.
B
A
The
fur
running
on
the
cpu
and
you'll
know
that
you
might
notice
that
the
firs
execution
is
being
high
on
the
processor.
You
need
to
free
it
up,
so
you
can
move
it
on
to
the
fpga
without
having
to
write
any
any
more
source
code
to
do
that.
To.
A
Would
create
a
we'll
go
into
that
and
assembly
make
sure
there's
an
assembly
with
that
in
there.
So
a
platform
is
a
physical
motherboard
housing,
one
or
more
interconnected
processors
and
associated
ir
devices,
and
we
will
be
using
the
pluto
sdr
as
an
example
in
that
the
pluto
sdr
it
uses
the
fpga
from
7000
series
zinc
and
the
zinc
has
embedded
inside
the
same
chip,
hardpour
arm
processor
and
the
fpga
fabric
and
the
way
the
interconnect
between
the
fabric
and
the
arm
is
through
in
open
cpi
is
through
the
axi
exit
ports.
A
This
is
where
the
worker
is
going
to
be
executed
and
then,
before
the
four
gpps,
you
can
have
multiple
containers
within
the
same
platform,
and
that
could
be
it's
like
a
container
for
the
arm
arm
processor.
So
in
the
zinc
7010,
it's
a
tool
for
arm,
so
you
can
have
two
containers
and
open
cpi.
Will
facilitate
the
data
transfer
between
those
containers,
so
those
two
cores
using
shared
memory
and
then.
A
Side
as
its
own
and
it's
the
job
of
the
platform
worker
the
platform
developer,
to
enable
that
the
execution
of
those
workers
on
there
and
there's
several
layers
within
the
container
on
the
fpga
site
that
are
needed
to
accomplish
this.
The
first
one
is
hdl
assembly.
A
An
hdl
assembly
is,
is
a
group,
a
set
of
workers
that
are
connected
similar
to
an
application,
but,
except
so
the
whole
point
of
having
this
hdl
assembly
description.
Xml
is
so
that
application
developers
don't
have
to
worry
about
the
nuts
and
bolts
of
the
of
the
rest
of
the
container
that
make
make
the
fpga
work.
They
just
focus
on
the
application,
so
the
assembly
houses
just
all
those
workers
and
how
those
workers
workers
are
connected
and
connected.
A
So
the
jobs
of
a
platform
hdl
platform
developer
is
grading
device
workers
and
we
have
a
set
of
device
workers
that
handle
the
communication
between
the
transceiver
and
the
fpga.
A
And
those
device
workers
are
created
on
on
in
the
container
and
there's
the
hdl
worker
xml,
it's
a
special
type
of
worker,
so
it
uses
the
same
worker
xml,
but
there's
also
a
cards
and
slots
paradigm
that
enables
an
fpga
developer
to
in
the
instances
that
your
platform
has
a
slot.
The.
B
B
A
We'll
have
we'll
need
device
workers
on
that
card
and
we
have
xml
that
that
handles
that
configuration
so
that
you
can
have
that
that
platform
have
containers
with
and
without
those
cards
on
there
and
and
switch
out
functionality
easily.
Using
those
xml
documents.
A
So
what
we'll
be
building
today
is
the
platform
worker
and
the
platform
worker
is
the
worker
that
that
instantiates,
the
the
the
processing
system
essentiates
the
interconnect
between
the
containers,
whether
it
be
in
our
example,
would
be
the
axi,
but
we
also
support
pci,
express.
We
have
support
for
ethernet
as
well,
and
the
platform
worker
once
handles
the
clocks
and
the
resets,
all
all
the
the
fpga
processes
to
get
it
to
get
that
platform
running
and
that
containers
data,
both
data
plane
and
control
plane.
Communicating
to
other
containers.
A
A
Control
plane
it
go
it
flows
through
the
platform
worker
and
the
control.
Plane
again
is
the
configuration
of
runtime
parameters
of
that
of
the
worker,
and
the
worker
also
has
a
life
cycle.
So
there's
a
start
executing
and
a
stop
running
type
of
life
cycle
that
are
also
clearable,
and
that
includes
the
workers
of
the
assembly,
everything
all
basically
all
the
workers
inside
the
container
and
then.
A
Plane
and
the
data
plane
we
use
the
data
container
data
engine
we
use
is
called
the
sdp,
meaning
scalable
data
plane,
and
the
scalable
part
of
the
name
is
is
to
note
that
the
data
plane
can
be
of
it
supports
multiple
bit
widths
from
32
bits,
all
the
way
to
128
bits
and,
and
that
also
flows
through
the
platform
worker
and
we'll
see
that
soon.
A
Okay,
so
platform
development
is
really
based
on
the
platform
you're
trying
to
enable
if
it's
just
like
a
if
it's
just
a
processor
processor
or
you
want
to
enable
the
risc
5
architecture,
you
focus
on
the
software
platform
developer,
we'll
get
into
that
and
the
fpga
platform
there's
the
enable
of
enabling
of
the
fpga
itself
and
then
there's
the
enabling
of
the
device
types
or
the
device
for
the
specific
integrated
circuits
it'd,
be
like
a
clock,
generator
or
eeprom
memory
that
communicates
over
spy
rise.
A
Christ
i2c
things
like
that
and
those
device
types.
Unfortunately,
we
don't
have
time
to
go
more
into
development
of
that
today,
but
the
the
idea
is
to
to
for
it
to
be
like
linux,
linux,
drivers
that
we
we
implemented
once
in
the
fpga,
and
then
we
can
just
reuse
it
across
all
supported
platforms
and.
B
A
Open
cpi
supported
platform
list,
we
support
the
rcc
platforms,
so
we
use
the
tool
chain
and
the
linux
kernels
provided
by
the
xilinx
vendor
and
and
those
tools
are
updated
periodically
by
quarter
and
by
by
year.
A
So
that's
what
the
19
stands
for:
19
2019
and
the
two
is
the
second
second
or
the
second
deployment
of
that
that
that
set
tools,
you'll
notice,
the
difference
for
the
pluto
is
we
use
the
software,
the
kernel
version
provided
by
analog
devices
so
that
we
can,
because
it
doesn't
use
an
sd
card
and
we
can
maintain
all
the
nice
features
of
the
usb
usb
device,
whether
it's
the
host
or
the
pluto,
is
acting
as
as
a
device
which
will
enumerate
the
serial
port,
the
ethernet
and
the
mass
storage
device.
A
That
allows
you
to
update
the
firmware
so
hdl
platforms,
the
zed
and
the
zed
with
the
fm
coms
transceiver,
the
9361
e310,
the
zinc
open
scale,
pluto
sdr,
matchstick,
ml605
alsd4,
we're
in
active
development
for
various
other
platforms.
I'll
share
with
those
towards
the
end
of
this
presentation
and
then
other
platforms
that
are
considered.
Fpga
platforms
are
the
simulators
and
we
we
support.
Isim,
which
is
bundled
with
isc
vivato,
which
is
bundled
with
oh
sorry,
xm,
which
is
bundle
novato
and
modelsim,
which
is
a
third-party
ph
hdl
verilog
simulator.
A
So
enabling
a
new
system:
what
are
the
steps
to
do
so
so
the
first
step
would
be
a
system
inventory
which
elements
are
relevant
on
the
platform
that
you
want
to
enable
with
opencpi
second
would
be
assessment.
What
what
is
the
current
level
of
support
that
the
framework
provides
and
is
there
additional
pieces
that
are
missing
that
I
need
to
to
develop
and
then
additional
system
information
of
the
platform,
those
being
the
data
sheets,
schematics
constraints,
files
for
fpgas?
A
And
then,
if
some
of
those
things
are
missing
to
complete
the
the
project,
then
you
would
have
to
experiment
and
fill
up
those
knowledge
gaps.
A
Using
the
pluto
as
an
example,
so
the
number
of
processors
processing
elements,
there's
the
dual
core
arm
and
the
fpga
fabric.
The
interconnect
would
be
the
axi,
the
axibus
that
communicates
between
the
fabric
and
the
fpga.
I
mean
the
fpga
any
arm
and
then
the
one
device
that
we
want
to
enable
is
the
the
transceiver
which
uses
the
cmos
data.
B
A
Assessment
of
the
current
level
support
the
zinc
processing
system
was
already
supported
with
an
open
cpi
at
the
time
of
enabling
a
photo
sdr
with
a
slight
difference.
The
zinc
7010
is
a
smaller
chip,
and
the
ddr
memory
only
supports
16
bits
versus
32
bits,
so
there
were
there
had
to
be
a
modification
to
open
cpi
it's
core
or
framework,
to
make
to
enable
this
to
happen,
and.
B
A
You
guys
in
prop
come
across
the
same
similar
situations.
We
encourage
you
to
create
merge,
requests
within
git,
and
so
we
can
continue
to
increase
our
capability
across
different
types
of
architectures
and
then
the
interconnects
we
use
two
ip
cores
that
are
part
of
the
core
projects
is
the
exceed
to
stp
and
the
xc
to
control
plane,
and
this
currently
support
the
we
currently
at
the
time
supported
the
80
93
61
and
the
80
93
63
matches
all
the
registers
and
the
data
interfaces
at
exactly
so
that
was
reusable.
A
Gathering
information
analog
devices
does
a
really
good
job
of
providing
all
their
data
sheets.
Reference
designs,
schematics,
clocking
information,
their
time
yeah
their
reference
designs
include
all
that
information
as
well
as
how
to
debug
it.
If
you,
if
you
need
jpeg
access
or
uart
serial
access.
A
And
then
any
knowledge
gaps
again
for
the
pluto
it
was
will
document,
but
sometimes
not
information
is
available.
So
you
might
have
to
reverse
engineer
some
things
to
get
things
working.
A
It's
just
important
to
note
that
we,
you
have
access
to
the
tools.
Your
development
environment
contains
everything
that
you
need,
so
the
platform
worker
will
require
the
bottom
2019.2
and
then
the
execution.
A
So
this
is
a
block
diagram
of
the
orders
that
are
implemented
inside
the
fpga,
for
our
zinc,
zinc,
processor
and
you
can
use
so
you
can
use
these
same
steps
to
go
over
to
enable
any
any
zinc,
fpga
based
processor-
and
I
don't
know
about
you,
but
I
am
a
an
fpga
hoarder
and
I
always
I
always
you
know
I
get.
I
always
purchase
new
fpgas.
A
I
have
a
laundry
list
of
things
of
platforms
that
I
want
to
to
enable
like
the
ultra
96
or
the
snickerdoodle
and
other
fpgas
that
have
the
zinc
on
it.
Following
the
steps
you
can
quickly
enable
those
platforms
as
well
so
part
of
the
platform
worker
which
we're
going
to
build,
has
the
wrapper.
A
We
open
cpi
has
a
wrapper
around
the
xylinks,
primitive
and
then
those
ip
cores
that
facilitate
the
control
plane
and
the
data
plane.
There's
four
high
performance
ports.
Oh
there,
that's
what
this
cx
stands
for
so
and
you
have
the
option
to
only
use
one
or
use
all
four
or
use
anything
in
between
there's
a
another.
A
Optional
xml
document
called
the
platform
configuration
and
this
is
optional
and
and
but
it
allows
you
to
enable
or
disable
specific
device
workers
if
you
had
a
device
worker
that
was
very
resource
intensive
and
you
wanted
a
particular
bitstream
that
didn't
have
that
one
to
free
up
resources
for
the
assembly.
You
have
that
capability
as
well.
A
So
opencpi
has
the
ability
to
synchronize
with
gps
time
and
has
a
timestamping
a
time
server
that
facilitates
timestamping
of
samples
from
the
adc
or
the
dac
or
from
the
adc
really,
and
then
there's
the
time.
Client
that
feeds
the
device
workers
that
are
that
run
on
the
in
the
clock.
Domains
of
the
of
the
transceiver
itself,
then.
A
One
thing
I
want
to
note
is
the
there's,
a
read-only
memory
that
contains
uid
and
metadata
to
identify
what
the
stream
is
currently
loaded
and
that's
variable
from
the
arm
side.
So
you
can
see
what
exactly
is
on
loaded
on
the
ga
fabric.
A
A
A
A
A
We're
going
to
change
directory
into
vector
that
project
I
created
to
make
file
and
the
projects
exports,
so
the
projects
exports,
so
there
will
be
multiple
projects
in
an
open
cpi,
environment
and
the
exports
denotes
that
there's
certain
files,
whether
it
be
components
or
hdl
platforms
that
need
to
be
exported
so
that
other
platform,
other
projects
have
access
to
those
and
vice
versa,
to
have
to
to
have
access
from
build
source
files
from
other
other
projects
as
well.
A
A
A
A
A
A
Mk
modified,
we
can
drill
into
our
platform
directory
so
under
hdl.
This
is
what
ocpideb
created
our
platform
and
it
has
a
makefile
dot,
mk
file
and
the
xml
an
xml
file.
That
xml
is
the
worker
description
xml,
so
an
hdl
platform
is
based.
It
is
based
off
of
a
very
specific
component
specification
and
that's
denoted
in
the
xml
automatically
when
we
generated
that
project.
A
A
B
A
So
the
next
step
we're
going
to
modify
like
pluto.xml
the
worker
and
the
first
thing
we're
going
to
modify,
is
we're
going
to
make
it
bringing
two
and
version.
Two
within
the
framework
has
additional
abilities
and
the
way
we
reference
libraries
in
bhdl
that
we
want
to
enable
by
specifying.
B
A
A
The
xml
is
going
to
use
ocpi
gen
to
generate
the
vhdl
files
that
are
going
to
be
used
to
generate
the
the
workers
netlist.
That
will
eventually
be
used
to
generate
the
bit
stream,
and
the
scalable
data
plane
is
what
we
use
for
the
data
plane
to
communicate
with
the
workers,
the
container
data
engine
and
the
other
containers,
and
we
want
to
make
the
this
platform
work
for
the
master
and
the
count
to
have
four
of
them,
and
that
corresponds
to
the
available
number
of
axi
ports.
A
The
next
thing
is
some
just
debug
properties,
whether
it
actually
errored
out
visible
and
true
or
false.
That
would
be
queryable
and
then
the
scp
drop
count.
The
number
of
dropped,
stp
messages
and
then.
A
Plane
we're
letting
it
we're
letting
the
open
cpi
know
when
it
goes
through
its
generation
that
this
is
going
to
be
the
master
and
then
the
use
gp1
is
a
is
a
boolean,
and
if
it's
true,
if
this
is
just
a
way,
allow
us
to
test
both
general
purpose-
ports
on
the
xe,
the
xc
bus,
to
move
the
control
plane
from
zero
to
one
for
a
bit
zero.
A
A
But
we
can
control
c
right
after
this.
If
we
let
it
go
and
take
about
10
minutes,
it
will
finish
but
there's
nothing
implemented
in
the
vhdl,
because
let
me
open
up
an
ls
here,
you'll
notice,
that
it
generated
a
couple
more
directories
and
it
generated
a
skeleton
vhdl
file.
A
A
I'm
gonna
just
copy
and
paste
that
into
my
docker
window,
the
first
one.
First,
one
we're
gonna
review
and
modify
is
the
xbox
so
just
like
in
the
platform
level,
there's
an
exports
file,
there's
one
in
the
in
the
sorry
in
the
project
level,
there's
an
exports
file,
there's
one
in
the
platform
level.
A
B
A
Dot
exports,
so
what
this
is
is
we're
letting
this.
So
what
we're
doing
in
the
platform
also
is
these
things
are
going
to
go
to
the
project
level,
but
there's
three
different
types
of
exports:
there's
deployment
files,
those
are
denoted
by
this,
the
first
character
and
that's
a
plus
sign
and
the
equals
is
a
runtime
runtime
files
so
required
by
the
runtime
executables
these
files.
So
we're
exporting
that
so
it's
available
inside
of
this
project
and
then
there's
deployment
files,
the
ones
we're
going
to
modify
here
is
the
development
files.
A
A
And
when
building
an
fpga
platform,
we
try
to
use
the
trace
file
provided
by
the
particular
manufacturer
of
that
platform
or
yeah.
If
it's
like
a
development
board
and
such
and.
B
A
To
keep
the
same
namings
that
they
use
for,
pin
assignments
and
signals.
A
A
Just
double
checking
the
next:
while
we're
going
to
remove,
modify
and
review
is
the
system
xml?
A
So
when
running
open
cpi,
it
looks
it
looks
at
this
an
xml,
it's
called
systemxml
and
it
gives
it
information
of
how
to
load
open
cpi
what
modules
to
load
that
facilitate
transfer
data
between
between
containers,
this
being
a
zinc
platform,
there's
two
containers:
again:
you
can
have
multiple
of
one
type
container
type
of
rcc,
but
we
only
instance
one
one
rtc
container
in
here,
so
one
one
rcc
and
then
one
hdl
and
then
the
device.
A
So
the
transfer
modules
here
so
pio
is
for
shared
memory.
We
have
containers
within
with
that's
the
shared
memory,
we'll
use
utilize
that
socket
module.
Well,
it's
for
remote
containers,
communicating
so
from
the
host
to
the
embedded
embedded
target.
Like
we've,
we've
shown
with
ocpi
run
that
uses
sockets
and
then
dma
is
used
for
transferring
the
data
between
the
fpga
and
well.
That's
where
the
axis
is
implemented
is
through
the
direct
memory.
Access
from
from
the
arm
side.
A
And
we're
going
to
add
libraries,
and
these
of
zinc
is
for
the
zinc
process.
Processing
system
wrapper
located
in
four
xe
is
for
our
interconnect
and
sdp
is
for
the
communication
between
workers
and
the
interconnect
make
that
modification
save
it
so
at
this
at
this
point,
we're
ready
to
build
our
platform
worker
so
because
we
did
a
build
earlier.
Some
of
the
generation
files
are
still
are
stale.
Now,
so
I'm
going
to
do
an
lcdi,
dev
clean
and
then
oh
cpi,
dev
build.
A
A
Building
here
is
so
that
if
there
are
any
mistakes
that
we've
done
in
the
previous
steps,
we're
automatically
going
to
see
those
changes,
we're
gonna
it's
gonna.
It's
gonna
pick
back
and
error
out.
A
Normally
at
this
point
you
would
be
able
to.
If
we
had
all
the
time
would
be
able
to
do
ocpi
admin,
install
platform
after
registering
the
platform,
but
we're
gonna,
let
this
platform
worker
build
for
a
little
bit,
and
while
it's
doing
that,
I'm
gonna
review
the
steps
of
enabling
a
general
purpose
processor
it
takes
it
took
me
about.
A
So
target
is
a
new
term
that
I
didn't
mention
before,
but
target
is,
is
basically
the
architecture
of
the
fpga
or
fpga
architecture,
or
not
just
not
just
fpgas,
but
also
like
cpu
architecture
as
well
could
be
a
target.
A
Okay,
so
the
next
step
I'm
going
to
do
is
I'm
going
to
I'm
going
to
open
up
a
new
terminal
and
I'm
going
to
use
that
terminal
to
discuss
the
the
general
purpose
process
now.
Hopefully,
if
you
guys,
if
we
have
people
following
along,
let
me
know
in
the
chat
how
things
are
going,
we've
been
able
to
follow
along
and
and
start
the
build
as
well
to
be
helpful.
Thank.
A
A
So
software
development
software
pop
from
dylan
there's
two
there's
the
development
hosts
and
the
target
target
host
or
target
platform.
The
steps
for
that.
It's
very
important
that
all
steps
should
be
recorded
for
reproducibility
first
step
is
to
install
the
options
and
packages
needed
to
build
the
open,
open,
cpi's
source
source
code
and
I'll
show
you
a
file
where
you
can
use
as
a
reference
depending
on,
and
we
utilize
the
package
manager
available
of
the
operating
system
to
facilitate
the
installation
of
opencpi
and
also
to
one
of
the
packages.
A
It's
very
important
because
we
have
to
build
our
loadable
kernel.
Module
kernel
driver
just
to
is
the
linux
kernel
headers
and
that's
one
of
the
benefits
of
dove
and
host
is
that
the
headers
are
available
in
a
package
that
we
could
easily
reference.
A
The
next
step
is
to
make
sure
that
the
tools
that
we
need
for
the
platforms
we
want
to
support
are
supported
natively
by
that
operating
system.
A
Those
tools,
if
you
wanted
to
target
those
islands
fpga,
would
be
bravato
and
vitus
so
that
operating
system
wouldn't
have
to
support
those.
The
next
would
be
to
to
receive
retrieve
the
source
code
to
build
against
it.
So
the
next
follow
the
following:
steps
are
the
same
for
for
the
target
devices
as
well,
and
that
would
be
building
the
kernel
driver
and
then
building
building
the
environment
and
the
ex
the
runtime
executables
that
we've
been
using
to
work
on
that
that
particular
platform.
A
B
A
Finish
really
quickly,
so
my
platform
workers
is
it
has
completed
and
I'm
going
to
go
ahead
and
issue
the
next
command
of
the
cheat
sheet,
which
is
the
ocpi
admin
install
platform,
is
registered
the
project
so,
like
I
said
we
so
so
far.
We've
we've
created
a
project.
We've
created
a
platform
and
we've
we've
created
the
platform
worker.
B
A
That
platform
and
to
query
the
registered
projects-
cpi
dev,
go
registry,
but
these
are
the
ones
that
open
cpi
is
currently
aware
of.
So
we
need
to
make
open
cpi
aware
of
the
tr
con
2020
project
to
do
that.
There's
an
ocpi
dev
register
project
command
that
we
can
register
this
project.
A
A
B
A
A
A
So
what
is
going
to
happen?
Is
it's
going
to
look
at
all
the
projects
that
are
registered
and
it's
going
to
go
all
to
go
through
the
components
and
make
sure
that
they're
any
hd,
because
this
is
an
hdl
platform?
That's
going
to
look
for
hdl
components,
sorry,
workers
that
are
implemented
to
make
sure
that
they're
already
built
and
since
they've
already
been
built
for
the
target
sync
because
they've
been
built
for
the
standard,
the
the
one.
A
That's
in
the
repository
bluetooth,
sdr
it's
going
to
go
through
these
fairly
quickly,
though
one
of
the
last
steps
it
does
is.
It
builds
a
brand
new
bitstream
and
it
builds
the
test
bias
assembly
which
includes
one
component
and
it
takes
data
in
and
then
the
bias
it
just
adds
a
value
to
that
particular
64-bit
data,
and
then
it
shoots
it
back
out.
So
it
does.
It's
doing
hardware
acceleration
and
that's
that's
basically
our
default,
that
stream
that
we
use
and
it's
our
hello
world
that
we
use
with
an
open
cpu.
B
A
A
A
So
you'll
notice,
there's
centos
7
sent
to
os
8
we're
just
waiting
on
the
tools
right
now
to
catch
up
to
centos
8,
so
that
that
would
be
a
fully
operational
platform,
soon.
Mac
os
again
with
the
tools,
the
sidelines
or
intel's
tools.
Don't
work
natively
in
that
operand
system,
but
you
can
run
rcc
containers
and
you
can
build
rcc
workers
in
the
operating
system
and
then
the
operating
system
that
we're
using
now
is
ubuntu
and
the
ubuntu
1804
is
what
we're
running
and
we
also
support
1604
those
two.
A
There's
just
this
hyphen
check
dot
script,
sh
shell
script,
we'll
look
into
and
this
operating
system
dependent,
so
it's
different
for
every
awkward
system,
but
for
ubuntu
there's
a
file
under
etsy
called
lsb
release
and
we
use
that
to
to
to
tell
the
difference
between
1604
and
1804.
So
the
distribution
id
in
that
file
is
18
or
16,
and
then
the
release
is
the
o4
portion
and
if
it
matches
to
1804,
then
it's
going
to
build
open
cpi
for
that
platform
for
1804..
A
A
And
they're
organized
by
functions
so
for
runtime
minimal.
If
you
wanted
to
just
just
run
just
execute
things
or
execute
artifacts.
You
only
need
this,
but
if
you
wanted
to
build
the
components,
the
workers
you
you
use
these
other
packages
as
well
then
towards
the
bottom
is
where
we
all
the
apt
installation.
A
The
next
file
that
I
want
to
highlight
is
the
mk
files
again
with
the
development
host.
The
nice
thing
is
that
we
have
the
ability
to
get
the
kernel
headers
from
the
package
manager,
and
this
is
where
we
point
to
opencpi
to
find
those
headers.
A
Using
this
this
this
make
function.
We
know
where
they
are
at
look
you
you
would
know
where
you're
at
located
and
and
you
can
find
the
headers-
and
this
is
how
you
point
open
cpi
to
when
it
runs
the
build
for
the
kernel
driver.
That
knows
where
to
find
them.
A
So
gender
progress
practice
platforms
are
similar
with
the
exte,
with
the
change
that
cross
cross
compiling.
Now
to
do
so,
we
don't
have
the
compiler.
The
compiler
is
part
of
a
tool
chain.
We
have
to
acquire
that
tool
chain
and
for
the
example
platforms
that
we
have,
we
use
the
xilinx
gold
chain.
That's
provided
in
their
installation,
2019
twos.
Their
tools
are
qualified
us.
A
Now
it
used
to
be
called
sdk
once
you
have
that
we
can
cross-compile
our
runtime
libraries
and
the
executables,
the
command
line
utilities
and
the
kernel
driver
using
that
tools,
those
tools,
but
we
have
to
go
and
acquire
kernel
headers
and
it's
not
as
simple
as
a
package
install
for
those.
A
So
yeah,
where
is
it
coming
from
and
it
again
open
cpi
is
very
flexible
in
the
sense
that
you
don't
have
to
use
eileen's
tools
tool
chain,
you
don't
need
to
use
intel,
intel's,
eds
tool
chain.
You
could
use
any
tool
chain
that
that
you
need
to
use
for
that
particular
architecture
platform
that
you're
trying
to
enable.
A
So
I'm
going
to
show
you
what
the
pluto
sdr
software
platform
looks
like
and
kind
of
the
same
same
steps
that
you
have
to
to
do
when
you
don't
have
access
to
kernel
headers
and
essentially,
we
use
the
tools
to
to
compile
the
kernel
in
its
entirety
and
once
the
the
tools
have
been
compiled,
you
will
there's
a
scripts
that
we
have
that
we've
been
using.
A
B
A
Objects
and
then
osps
the
cpi,
bluetooth
sdr
in
there
it's
the
same.
It's
the
same
directory
structure
as
the
core
and
as
the
one
we've
created
so
platforms,
there's
only
one
and
again
we're
using
the
kernel,
that's
provided
by
analog
devices
so
that
we
can
keep
that
maintain
that
functionality
of
the
usb
port
and
it's
the
flexibility
of
acting
as
a
device
or
as
a
host.
So
under
adi
photo
sdr.
B
A
A
A
Analog
devices
it's
there,
they
use
git
sub
modules
so
that
some
modules
has
a
very
specific
commit
tag
commit
that
from
the
analog
devices
kernel,
and
we
use
that
to
rebuild
against
that
because
that's
the
exact
same
kernel,
that's
running
in
the
stock
lauren's
dr
firmware
and
once
we've
we've
built
using
the
tools.
There's
another
file
that
that
points
to
the
tools
which
I'll
show
you
so
here's
the
script,
the
source
it
here's
to
create
it,
and
so
the
runtime
executables
have
a
sdk
that
they're.
B
A
Once
you
get
those
two
things
running
so
it's
gonna
extract,
it
extract
it
and
then
the
next
file
that
I
want
to
that
is
the
exports.
A
The
same
same
as
the
the
other
exports
files
that
we've
seen
so
far
thus
far
plus
is
for
development
time,
and
we
want
to
extract
the
kernel
headers,
tar
that
that
script
generated
that
contains
those
kernel,
headers
and.
B
A
A
The
next
file
is
the
mk
file
part
of
this
platform,
and
this
is
where
you
point
it
to
the
the
correct
tool
chain
that
you
want
to
build
against
and
we're
forcing
into
to
run
against
the
2019
tools.
So
when
developing
for
open
cpi,
you
need
a
really
large
hard
drive
space
because
of
the
well
us
as
opencv
the
opencpi
team
testes
it
from
many
different
versions
of
vivado
and
each
of
those
is
about
50,
60,
gigabytes
of
of
data
just
for
their
vivato
and
their
software
development
tools.
A
But
there's
some
directives
that
are
part
of
the
this
include
that
helps.
You
find
the
where
they're
located
on
the
system.
A
Typically,
when
you
install
using
the
defaults
from
the
installer
they're
under
starting
from
2019
too,
I
believe
is
the
tools
slash
xilinx
directory
previously
was
opt
xylinx
and
in
your
docker
container,
that's
where
they're
at
right
now
site
links,
but
this
will
find
the
correct,
correct
directory
and
then
inside
that
directory.
This
is
where
you
find
the
the
compilers.
A
There's
this
is
the
kernel
headers
and
the
directory
where
to
find
them
the
arm
the
crop.
This
is
the
cross
compiler
directive
that
uses
so
we're
gonna
use
gcc.
B
A
So
we
also
have
a
set
of
scripts
that
help
you
generate
the
xilinx
versions,
and
so
you
can
generate
any
version
in
between
by
default.
We
have
2.17.1
to
2013
for
in
our
core
projects,
but
if
you
needed
one
in
between,
because
you've
already
there's
already
been
a
lot
of
development
and
and
you're
stuck
at
a
particular
version
of
the
dialing
tools,
and
then
we
have
scripts
that
can
create
the
rcc
platform
with
basically
just
one
line,
just
specifying
what
version
you
want.
B
A
To
do
like
cloning,
the
xilinx
xilinx
kernel
tree
and
then
also
installing
the
pre-built
binaries
for
the
boot.band
that
contains
the
first
hp
loader
and
all
those
things
that
execute
the
zinc
on
startup.
A
So
this
is
you
I
am
using
the
nfs
mount
too,
but
I
am
I'm
located
in
the
building
that
is
being
served
out.
So
this
might
be
a
significantly
faster
for
me
than
it
is
for
you.
So
let
me
know
you're
following
along
and
it's
still
building
for
you.
I
think
I've
been
asked
this
a
couple
times.
So
maybe
a
lot
of
people.
A
lot
of
you
are
just
observers
and
if
so,
then
I
can
proceed.
A
So
anyway,
we've
got
our
platform
built
and
now,
since
you
guys
it's
hard
to
tell
if
you
guys
are
still
waiting
or
not
or
you've
been
following
along.
A
A
So
one
of
the
first
things
that
we
do
when
developing
a
platform
is,
is
going
through
the
components
and
the
component
unit
tests
executing
that
for
every
worker
there,
for
every
component
specification
file,
there's
there's
associated
unit
tests
and
also
for
every
component
file,
there's
also
documentation
as
well
for
every
component
and
then
successfully
tested
against
that
in
hardware.
A
A
The
next
thing
would
be
to
test
to
test
the
assemblies
and
specifically
assemblies
that
pertain
to
device
devices
and
device
workers
that
are
implemented
on
that
platform.
The
first
one
that
I
do
is
test
to
test
hardware.
Acceleration
is
the
test,
bias
application
and
that's
the
default
one
that
gets
built
with
the
ocpi
admin.
A
A
If
you
have
an
80
analog
devices,
893
61
or
in
that
same
family,
we
have
tests
that
test,
the
basically
send
data
to
the
transceiver
and
it
digitally
loops
back
to
the
adc
channel
and
to
validate
that
the
all
the
bits
are
coming
back
as
expected.
A
So
there
are
three
different
modes
that
that
platforms
are
capable
of
running
standalone
mode,
network
mode
and
mcpi
remote,
no
cpr
remote.
It's
what
we're
using
now.
A
What
you
would
use
to
do
do
all
the
hardware
in
the
loop
testing
of
the
components,
the
component
unit
test,
the
network
mode
utilizes
nfs,
on
the
development
host
to
share
all
the
executables
I
think
cross
compiled
for
the
target
and
or
artifact
artifacts,
and
make
them
available
so
you're,
not
using
any
of
the
space
on
the
on
the
embedded
target
and
you
have
access
to
a
hole.
It's
good
for
debugging
and
then
stand
alone.
Is
that
all
those
files
are
located
on
the
platform
itself
and
require
no
network
connection
at
all?
A
So
we
did
it
in
the
very
beginning,
but
we
did
it
for
and
I
was
going
to
show
yeah
we're.
Gonna
do
other
things
while
we're
waiting,
but
it
seems
like
waiting
for
others
to
complete
as
well,
but
I
still
haven't
gotten
feedback
if
others
are
are
waiting
for
that,
so
I'm
gonna
press
so
we're
going
to
reload
the
openc,
the
open
cpi
on
on
the
device
itself.
So
I'm
going
to
do
ocpi
remote
to
use
our
our
new
platform
that
we
created
s.
A
A
We
know
that
it's
serving
there.
Hopefully,
I
ran
into
troubles
in
the
previous
workshop
because
I
was
trying
to
do
two
different
things.
So
the.
A
Going
to
run
it
is
the
test
bias,
application,
so
the
world
for
the
platform,
opencpi
projects.
B
A
And
again,
if
I
this
is
the
directory
structure,
it's
exactly
the
same.
It
has
a
couple
of
a
different
thing:
artifacts
is
where
go
into
artifacts,
so
these
are
our
links
to
all
the
artifacts
that
are
available
that
are
in
the
assets,
project
and
you'll
notice
that
so
this
particular
rcc
worker
was
built
for
ubuntu
1804.
A
Pluto
about
my
here
so
inside
this
artifacts
directory
there's
a
link
to
the
assembly.
That's
going
to
run
in
the
the
assembly
that
we
need
to
run
the
bias
application.
That's
vice
application,
so
under
applications.
A
There
is
the
xml
for
that
test
that
the
application
we
want
to
run,
it's
called
testify.xml,
so
the
opencpi
application
specification
oas
in
the
application.
There's
three
components,
so
this
component
here
is
the
file,
read
we're
connecting
it
to
the
bias
component
and
these
are
the
properties.
So
this
is
the
input
file.
A
It's
not
just
static
granularity.
This
is
the
bias
value,
so
one
two
three
four
and
then
we're
gonna.
That's
connected
to
file
right.
A
So
another
open
cpi
command
line
utility
is
ocpi
run
and
I
like
to
use
dash
v
for
verbose
and
then
dash
d
for
dump
of
the
properties.
Then
you
can
specify
a
lot
more
things
and
there's
a
man
page
for
that
for
all
the
different
options
that
you
can
use.
But
right
now,
I'm
just
going
to
do
testify
as
delexing.
A
So
I
scroll
up
to
the
printout
here
and
one
of
the
first
things
it
does.
Is
it
detects
what
containers
are
available?
So
this
is
exactly
what
ocpi
dash
c
runs,
so
our
pluto
is
there,
but
then
we
actually
here
under
here
sorry
about
that.
A
So
this
is
the
contain
available
containers
and
this
is
where
it
actually
deployed-
and
this
is
each
there's
an
instance
of
each
of
the
of
the
components
associated
with
their
workers
as
well
and
we'll
notice
here
that
it
this
ran
locally
on
the
ubuntu
platform,
because
it's
using
the
boomtube
artifacts.
A
A
To
do
so,
there
is
a
dash
capital
p
to
specify
specifically
what
platform
you
want
to
run,
and
then
you
have
the
the
way
to
do
this
is
to
specify
to
name
the
component.
You
want
the
component
specif.
The
component
you
want
that
to
run
on
is
the
bias
component,
so
the
middle
component
of
the
application,
and
then
we're
going
to
do
my
underscore
order.
Ostr.
A
We
should
get
and
it
completed
so
within
our
with
our
platform,
we
were
able
to
execute
a
an
application
using
well.
Let's
go
validate
that
by
scrolling
up
to
to
this
ocd.
I
run.
A
B
A
A
A
Assigned
so
that's
that
application,
so
normally
it
would
take
a
while,
for
others,
and
to
fill
that
time,
I
was
going
to
go
over
executing
unit
tests
and
executing
just
a
little
brief
overview
of
what
the
the
integration
with
generated,
companion
and
open
cpl.
A
What
that
looks
like
so
for
a
unit
test,
because
one
of
the
things
one
of
the
things
to
complete
a
platform
is
to
run
against
the
unit
tests.
So
what?
What
is
a
unit
test
so
under
access?
A
That's
honest
components,
let
me
use
this
specific
one,
and
this
one
was
just
chosen
specifically
because
it
had
the
smallest
number
of
test
cases.
Otherwise
it
would
take
a
while
to
get
through
all
of
them,
so
under
cons.
Comps,
there's
you'll
notice
here
that
there
are
different
authoring
models
that
this
component
is
built
for,
there's
an
hdl
worker
and
there
is
a
rcc
implementation
of
it
and
then
you'll
also
notice,
there's
a
test
and
then
there's
a
specs
file.
So
we
go
into.
A
This
is
a
specification
for
for
the
worker
that
we're
going
to
run
united
skin,
so
it
has
an
upper
a
property,
and
so
this
denotes
the
number
so
the
fsk
mapper
it's
a
2fsk
or
fsk
and
symbols,
and
then
there's
a
input,
port
and
output.
A
A
And
where
the
document
gets
generated,
as
well
as
there's
a
function
to
generate
the
input,
data
and
there's
a
python
script
that
does
verifying
of
the
data
and
if
you
wanted
to
view
the
data
in
this
case,
I
think
it
just
does
a
hex
step
to
view
the
data,
but
that
has
its
own.
A
unit
test
has
its
own
xml
to
describe
it
and.
A
It
I'll
use
hdl
file
io.
So
if
you're
using
a
simulator
it'll
use
this
a
specific
type
of
implementation
to
handle
the
file
read
and
file
right
now
it
will.
It
will
not
use
the
rcc
implementation
for
the
host
platform
and
use
the
simulator
version
and
then
input
port
output
port,
so
the
input
port.
This
is
where
it
would
generate
which
it
will
execute
the
python
script
to
generate,
and
then
the
output
was
is
where
it
would
verify
it.
A
And
as
far
as
our
documentation,
you
can
find
that
at
opencpi.gitlab.io.
A
And
this
is
for
the
mfk
mapper
inside
there's
a
datasheet
for
each
component
and
there's
the
worker
implementation
details.
A
A
A
So
it's
going
to
go
through
the
generation
steps
and
then
the
first
platform
it
shows
was
xsim.
So
it's
going
to
execute
that
test.
Those
test
cases
there's
two
and
those
are
defined.
Those
have
its
own
xml
like
I
showed
earlier,
but
then
you
could
also
define
you.
B
A
Create
any
number
of
combinations
of
properties
or
parameters
that
you
want
to
test
I
wanted
to
show
here
is
that
your
it's
going
to
test
against
multiple
platforms
at
one
time,
and
this
is
what
our
our
continuous
integration
continuation
development
does
in
its
testing
and
how
using
the
ocpi
remote
ocpi
serve
executables.
We
can.
We
can
test
against
hardware
and
loop
testing,
so
it
finished
with
xn,
and
now
it's
doing
the
rcc
platforms
and
then
normally
it
would
do
the
hdl
platform
too.
A
But
since
it
hasn't
been
built
for
the
specific
platform
that
we
just
recently
generated,
it's
only
been
built
for
the
pluto
sdr
platforming,
not
that
my
underscore
pluto
didn't
run
on
that,
but
it
will.
It
would
run
on
that
if
it
was
built
for
it,
because
I'm
just
executing
the
test
and
I'm
not
I'm
not
building
the
test
and
and
the
assemblies,
because
the
test,
the
unit
test
framework
with
an
open
cpi
handles
the
generation
of
assemblies
automatically.
A
And
the
last
thing
I
wanted
to
show
was
just
a
brief
demonstration
of
the
gnu
radio
companion
integration.
B
B
A
This
is
a
new
radio,
companion,
3.7
and
we're
in
the
process
of
updating
and
reading
into
3.8
and
above
right
now,
there's
some
limitations
on
the
mixing
of
blocks
between
the
radio
companion,
the
open
cpi,
runtime
environment
right
now.
Each
flow
graph
is
available
with
just
one
runtime
environment
and
we
have
a
way
of
of
exporting
data
using
sockets
to
the
canoe
radio.
Companion
again,
you
can
watch
the
video
about
that
in
jim's
chin's
workshop,
but
in
here
on
the.
A
They
follow
the
same
structure
of
assets
or
that
they
do
in
their
directories
and
what
we're
going
to
build
real
quick
is
just
the
test,
bias,
application
and
then
we're
going
to
try
to
put
it
on
different
platforms.
A
B
A
So
for
the
writer
block,
we
need
a
way
to
let
the
new
radio
companion
know
that
it's
been
completed
and
there's
a
done
attribute
right
here
where
it
says
ocp
I
done
so
let
it
know
that
it's
successfully
completed.
B
A
Or
the
jrc
flux
we're
saving
the
grc
flow
graph.
It
hasn't
built
anything
yet.
But
when
you
include
there's
a
button
here,
it
says
generate
the
photograph
will
generate
the
open
cpi,
xml
required
to
run
this,
and
then,
after
we've
generated
that
we
can
run
the
execute
button
and
it
came
out
really
fast
up
here
and
it
has
the
same
printout
that
we
saw
with
ocpi
run.
That's
where
it's
getting
it
from
and
we.
B
A
I'm
going
to
read,
generate
the
xml
again
and
then.
A
A
I'm
gonna,
give
this
a
try,
but
I'm
no
guarantees
to
work,
because
the
pluto
container
that's
executing
right
now
is
the
one
that
we
created
and
we
haven't
regenerated
the
box.
To
include
that.
I
think
if
I
put.
B
A
Error
for
some
reason,
oh,
my
pluto
is
not
registered.
Oh
the
domain
key
yeah
because
I
haven't
regenerated
anyway.
Otherwise
it
had
done
if
I
was
still
waiting
for
the
platform
worker
to
build
it
build
a
lot
and
the
ocpi
platform
to
install.
I
would
have
been
able
to
show
that
yep
and
gave
us
the
correct
error
on
why
we
can't
do
that.
A
Cool,
didn't
know
that
so
anyway,
we
showed
this
simple
application.
It
could
be
complicated
when
we
have
an
fsk
application
built
with
grc.
That
is,
is
our
go-to
example:
application
when
developing
transceivers
is
a
simple
fsk
application
to
send
an
image
and
receive
an
image
that's
available
in
our
source
code
as
well.
A
A
Updating
rl2
framing
to
support
ethernet
frames
as
an
interconnect,
the
n310
e320
and
there's
several
transceivers.
Well,
there's
an
the
platform
itself
is
the
80
or
b961
and
then
80
or
9009,
and
that
that
in
itself,
it's
going
to
support
our
new
offerings
by
analog
devices
as
well
as
updating
the
matchstick
right.
Now
we
we
support
the
z1,
but
they're
they've
made
a
lot
of
platforms
since
the
last
time.
A
We've
had
any
support,
epic
for
epic
platforms
for
intel,
support,
cyclone
5,
stratix
10
and
then
also
refresh
our
gpu
support
to
opencpl3
opengcl3.0
and
then
interconnects
like
one
that,
from
the
previous
workshop,
was
interested
in
seeing
as
a
usb
3
for
the
b210
and
10
gigabit
ethernet,
and
then
refreshing.
The
pci
express
support
as
well.
A
So,
to
find
more
information
you
can
visit
opencpi.org,
and
that
contains
general
information.
Opencpi.Gitlab.Io,
like
I
mentioned
before,
is
the
documentation,
there's
also
tutorials
and
briefings.
If
you
want
to
learn
more
about
open
cpi,
our
git
lab,
whereas
where
we
store
all
our
source
code,
our
repository
issues
or
have
we
have
our
ci
system,
and
then
our
email
distribute
discussion
list
as
well,
so
this
this
particular
workshop
will
be.
A
You
can
replay
it
at
your
convenience
in
the
future
and
also
the
introduction
to
open
cpi
with
the
grc
integration
kit
is
available
as
well.
I
appreciate
you
guys
joining
me
today
on
exploring
a
platform
development
within
opencpi.