CALIT2 Bird (Android)

Loading...

Do curso por University of California San Diego

Internet of Things: Sensing and Actuation From Devices

87 classificações

University of California San Diego

Internet of Things: Sensing and Actuation From Devices

87 classificações

Have you wondered how information from physical devices in the real world gets communicated to Smartphone processors? Do you want to make informed design decisions about sampling frequencies and bit-width requirements for various kinds of sensors? Do you want to gain expertise to affect the real world with actuators such as stepper motors, LEDs and generate notifications? In this course, you will learn to interface common sensors and actuators to the DragonBoard™ 410c hardware. You will then develop software to acquire sensory data, process the data and actuate stepper motors, LEDs, etc. for use in mobile-enabled products. Along the way, you’ll learn to apply both analog-to-digital and digital-to-analog conversion concepts. Learning Goals: After completing this course, you will be able to: 1. Estimate sampling frequency and bit-width required for different sensors. 2. Program GPIOs (general purpose input/output pins) to enable communication between the DragonBoard 410c and common sensors. 3. Write data acquisition code for sensors such as passive and active infrared (IR) sensors, microphones, cameras, GPS, accelerometers, ultrasonic sensors, etc. 4. Write applications that process sensor data and take specific actions, such as stepper motors, LED matrices for digital signage and gaming, etc.

Na lição

LED Block

It was amazing when we turned our first LED on. What if we told you one was just the beginning! In this Module we will manipulate 8x8 LED matrices to execute a variety of custom schemes. We will program and build games, and digital displays that can be used for fun or business. The 8x8 LED matrix is just the beginning. Our code and ultimately our concepts can be applied to larger more intricate projects as you grow your IoT toolbox.

Introduction to Lesson 41:27

Building the Circuit3:44

Message Display (Ubuntu)1:29

Dice Game (Ubuntu)1:38

CALIT2 Bird (Android)10:01

A look back at Lesson 40:41

Conheça os instrutores

Ganz Chockalingam
Principal Engineer
Qualcomm Institute of Calit2, UC, San Diego
Harinath Garudadri
Associate Research Scientist
Qualcomm Institute of Calit2, UC, San Diego

Welcome back everyone, I know we've already gone over quite a few games.

The dice game and the message board, I guess that's not really a game but

the message board.

And now,

it's time to explore the possibilities of making a fun game on Android.

So yeah, we did all that on Ubuntu using Python.

But now we're gonna kind of take that same setup.

We manipulate it a little bit, but basically the same setup we had for

the other two games and make a little fun app here.

So first, I wanna kinda go over this circuit here.

So we can kinda get maybe a shot in here of this,

and we're gonna trace these wires here so that you can see what's going on.

I know it looks like a little bit of mess, but they are color coordinated so

you can pause the video maybe take some time, check it out.

I'll do my best right here.

So we have our amplifier circuit as you can see right here.

The same amplifier that you built not too long ago in one of the previous modules.

Well, what we're gonna do is we're gonna power up the amplifier circuit right here

with these two ones.

We just have the black and the red.

So this is the power and the ground going,

giving power to the amplifier to our little opp amps here.

Then that ground traces across here along with the power,

giving power to our LED block.

So all the red and the black wires, all that is is power and ground.

Then we're gonna be using three GPIOs to power this LED block this time.

The three GPIOs or the three pins we're gonna use are pins 24, pins 26 and pin 34.

So respectively pin 24 is going to your d in on your LED block and

you're going to get to see this a little bit more when Ari goes over the code.

But pin 24 is going to the yellow one right here, yellow trace it into

the input of the amplifier and then the output of the amplifier goes into the DN.

Then pin 26 is gonna be your CS, so 26 traces into the second

input of your second amplifier there out into your CS of your LED block.

And finally, the white wires here go from pin 34 into

the input of amplifier and then output over to your clock.

So you can check this out.

I recommend pausing.

You probably can't see much of what's going on here, but

hopefully my explanations did you well and

then along with the code you should be able to figure this out pretty easily.

So let's kind of check out the code now.

We'll dive into what's going on here.

Hey Ari, what do you think?

>> So if you guys recall from course two I believe module eight,

we went over how to make your own Floppy Bird game.

We called it Calli Bird.

So we're gonna be reusing that same exact code.

So if you haven't already watched it before and

you kinda wanna learn more about our thinking or

our methodology behind making the game, go ahead and check that out.

Let's go ahead and take a look at the build.gradle file which is gonna be for

our module app.

And if you noticed, we have this extra line here for

compiling our GPIO library made in earlier module.

Now remember, we're gonna using the GPIO pins here,

so we need to have some sort of GPIO processor.

For us, we're gonna be using the GPIO processor that's available

under online repositories we made in.

So make sure we have this go ahead and use the most current version in this case

it's 1.0.7, and let's go ahead and take a look at the LED processor.

Now, Robert and Eric already went over the LED processor in an earlier lesson

in this instance, how does the GPL pins communicate with the LED block,

how do we transfer information to the board?

So if you compare the code, it's exactly the same thing just different syntax,

slightly different implementations.

Just a break down, inside of our constructor we pass in how many devices we

want and the GPIO pins we're gonna be using for our data in clock and CS.

You gotta initialize them as outputs.

And then we go ahead and do this initial instructions.

Now for the LED block,

there's different states it can be in as was previously mentioned.

We have to make sure that we put it into operational mode,

that the testing is off, that the display test is turned off.

We set scanLimit to 7, so we're able to use all of the rows of LED block.

And then we're just gonna go ahead and

make it the brightest we can which is 15 in this case.

In here, we have this last line which goes ahead and clears the display just so

it's a flat screen for us.

And other than that, that's basically it.

That's how you initialize it.

Now for us since Floppy Bird or Calli Bird is basically

a map with rows we're gonna be setting the rows one at a time based of our data.

So we go ahead and go to set row right here.

See, notice here that we specified the device which row you wanna do and

then the data code.

So based off of what row we have here,we're gonna go and

create instruction, and

then transfer the instruction to our LED processor or LED block rather.

And here it's the same as that loop that you'll find inside the Python version.

We're just gonna loop through the instruction, passing at one bit at a time

based in intern DIN and higher DIN and low based off of the instruction given.

So that's in the processor, how do we exactly hook it into the Calli Bird code.

So if you call for module eight,

we created something called the renderable interface and

this is where the real beauty of what we did here comes into play.

Because if you recall, we have a screen render using the same exact code and

we went ahead and rendered it to the screen using a GUI.

Now instead of having to write any more custom code to modify the CaliBird code,

CaliBird code stays the same.

We just kinda plug in our own application.

So in this case, we have our LEDRenderer class.

Which if you call it,

it's gonna be the exact same thing as the screen renderer, just slightly different.

Here we specify our GPI processor and in our LEDProcessor we pass in Pin24,

Pin34, Pin26 for DIN clock and CS respectively.

Inside our begin method we just have a score, just score text view set up.

Now under renderData, if you look here when we create our new data.

We're going to go ahead and create our instructions like this, create charts so

that it's easier for the LED block processor to parse to the code and for

every single row we're gonna go ahead and send this data in.

Just this one line and now, we're able to render in on the LED block through that.

We have a few other lines of code,

it's gonna be almost the same exact thing as it was for the screen render class.

The only difference of course is our rendering is going to be different.

So the input stays the same, if we look at the interface,

we're still gonna go ahead and click.

Do clicking.

If we look here oops or rather I think it's in screen renderer or LED renderer.

Somewhere we have a listener that every single time we click it jumps up and down.

So if we wanted to,

we could've actually created some sort of controller to control that as well.

Let that be a project for you guys.

But other than that I think we are ready to go.

>> So yeah, basically you'll follow all the things that

you've learned throughout course two, how to push an application onto your board.

We already have the application on our board.

So if you can't remember how to do that, it's a little play button up there.

You play, you select the device.

Push it on over, make sure you have the micro usb plugged in.

>> Or WiFi. [CROSSTALK]

>> Yeah, [CROSSTALK] of course.

So let's take a look at our dragon board here now.

So it's already booted up and ready.

We're in Android, so it's good.

I'm gonna unlock the screen here, there we go.

That's the hard part, now here comes the easy part.

So here we have the application that we pushed.

This is a little other one that we were kinda working on.

Oh, what'd I do?

One more time.

So I'm gonna click this and we're gonna see this LED block light up.

So as soon as I click this, and we're gonna get to play.

So you can kinda see.

There we go.

>> I see you're quite the gamer.

>> [LAUGH] I feel like this is actually easier than the Flappy Bird that I

played on the phone.

>> Wow.

>> I died.

So yeah, you can see now also.

When you die it registers your score or when you hit the I don't know,

if the bird dies, right?

>> [LAUGH] >> The bread dot dies.

But after you hit one of the obstacles your score pops up on the screen.

So I was able to pass through five obstacles.

That's pretty good.

I'm happy with that. >> Yeah, very good job.

I think that's a lot more than you would've done on the-

>> [LAUGH]

>> Actual game itself.

>> Cool, so as you can see this is a code that we put together fairly fast.

There are a lot of things that can be fixed, modified, made more robust.

So we would encourage you to get in there and pull the code and

make it your own, maybe add some- >> Controllers or

maybe a bigger display of LED blocks.

Anything you want.

>> All sorts of cool stuff.

Like he said, you can also change the devices.

You can add more devices, put them next to each other so

you can see more obstacles running up onto each other.

Lots of cool stuff and I'd say, that's a wrap right there.

All right, great. Have fun with your games and

we'll see you in the next lessons or modules.

Explore nosso catálogo

Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.

O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.

© 2019 Coursera Inc. Todos os direitos reservados.

Baixar na App Store

Baixar no Google Play