Lecture 1.1 - Network Libraries

Loading...

Do curso por University of California, Irvine

Interfacing with the Raspberry Pi

845 classificações

Explore Related Videos

At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you

University of California, Irvine

Interfacing with the Raspberry Pi

845 classificações

Curso 5 de 6 em Specialization Introdução à Programação aplicada à Internet das Coisas (IOT)

The Raspberry Pi uses a variety of input/output devices based on protocols such as HDMI, USB, and Ethernet to communicate with the outside world. In this class you will learn how to use these protocols with other external devices (sensors, motors, GPS, orientation, LCD screens etc.) to get your IoT device to interact with the real world. Most physical devices use analog signals; however computer hardware is digital so in this class you will learn how these signals are converted back-and-forth and how this must be considered as you program your device. The basic design of a sensor-actuator system will also be covered. You will also learn how to build more sophisticated hardware systems using Raspberry Pi expansion boards to create fun and exciting IoT devices. Please note that this course does not include discussion forums.

Na lição

Module 3

This module focuses on how to have your Raspberry Pi interact with online services through the use of public APIs and SDKs. Many interesting and useful services are available in the cloud and this module describes how to write code that accesses those services. We define what an Application Programming Interface (API) is and what a Software Development Kit (SDK) is. We present some API examples and we show the use of the Twitter API in detail using the Twython package.

Lecture 1.1 - Network Libraries12:24

Lecture 1.2 - Web Services7:24

Lecture 1.3 - Public APIs7:29

Conheça os instrutores

Ian Harris
Professor
Department of Computer Science

[MUSIC]

In this lecture,

we'll talk about

networking libraries.

Now we already talked about socket library in previous modules, but

we're going to go into other libraries, just a little bit.

And then we'll get to specific, sort of vendor-specific libraries,

that allow you to communicate with different services online.

So networking libraries.

We've already learned about the Socket Library,

a Socket Library is a very low-level library.

By that I mean, it's very useful, but there's more work for

the programmer to do, meaning the programmer is left to handle a lot,

a relatively large amount of details when it comes to this,

using the Socket Library to send a message.

So specifically, the programmer has to compose the message content, so

that means that the programmer has to be aware of what the network protocol looks,

defines as the message to look like.

So the program has to know well for ATTP,

you gotta have this line with the method at the top.

Then this on the second line.

You gotta have a series of headers,

you gotta know what the valid header values are.

You have to know a lot, a decent amount about what

the message is supposed to look like in order to use the Socket Library,

because the Socket Library, you have to specify that as a program.

Now, sometimes Socket Library is good if

you're just making some sort of ad hoc communication,

say I just want my raspberry pie to connect to my other raspberry pie, right?

And then, when I want them to talk to each other, I can use whatever protocol I want.

I don't have to use HTTP or

any specific complicated protocol, I can just make up something.

I can say look, I'm going to send ten bytes every time,

which are the results from my ADD converter, something like that, or

actually, raspberry pie doesn't have that, but results from my computation.

I can, if I know that, then the socket is good because you don't need any particular

kind of protocol that you need to worry about.

You just stick ten bytes on the wire, and on the receiving end,

you receive ten bytes, and it's very simple, right.

There's no protocol you have to worry about because you can make up the protocol

and make sure it's simple.

But with more complicated protocols, it becomes a little bit more work to use

Socket Library because you have to compose the message,

so you have to know the details of the protocol.

So here's an example, and actually we saw this example several lectures ago.

Sorry about the indentation.

It's just hard to fit on the screen right,

but the indentation is important with python.

What's happened here,

is that some of these lines are broken up over several lines.

For instance, the first three lines you see on that screen, that's one line okay,

that's the creation of the socket.

We did this example before, all this is doing is connecting to Google.com and

sending it a http get message.

So basically requesting the website, requesting the data on the website,

the html on the website.

So, you could see, we're calling socket to create the socket, then socket.get host by

name, with Google.com, so we have to get the host, the IP addresses for Google.com.

So that's doing a DNS lookup and then after that you do a connect and

then notice it says message equals, and we have that message in quotes,

get blah blah blah and then we send.

Now, the thing to notice about this is that that message,

you had to compose that message.

Now, this is a very simple message, but you had to know

protocol specific details to know what that message should look like.

The fact that the word get has to be the first thing you see, get or put or

something like that.

There are several headers that have to be first,

and you have to know that about HTML, HTTP rather, in order to make that message.

The next thing, that slash.

That's telling you what directory to look at, what file to find, right?

So the slash is just saying look, whatever file the index at the top level,

that's what I want you to get, right?

You have to know that.

HTTP/1.1, that's giving you the HTTP version that's being used.

You have to put that there and use a program.

You have to know that.

Also the slash r slash n slash r slash n.

That's the character turn line feeds,

a couple of character line feeds that you need, right?

You need two of them to let it know that that's the end of the message.

So those details, I mean I know about those.

We didn't specifically talk about those but, you know,

it's possible for you to look those things up.

You can Google http, find all the details.

But it can be a pain, right, because that's the most simple message you're ever

going to see, HTTP message, they get longer.

There are headers and

more complicated things that you want to add into these type of messages.

So using the bare Socket Library can be tedious for

a programmer because they have to worry about all those details.

It is nice sometimes to use protocol-specific libraries and there

are several of these available in Python and for the Raspberry PI and so forth.

And so these libraries, they are,

you have several, a lot of these just for one protocol.

Now the programmer doesn't have to know the protocol details in this case.

So they can just rely on these library functions that are available that

handle the details.

So it handles, as a for instance, the character turn line keys.

It'll put those in.

And they'll put them in the right place in the message and things like this, right?

So you just call these functions that where the arguments of the functions are,

the key details, the key information that you want to put in this message and

then the library function just composes it into the appropriate type

of string of data, series of data and then sends that for you.

And then on the other end, it receives it.

It does the same thing on receipt.

So they'll be library functions that maybe receive a message of a particular type,

and rather than showing you the whole raw message, they pulled out the important

things, you know, the payload and so forth that you're interested in and

strip away the rest so that you don't have to see that in the program.

So using these application specific or rather protocol specific libraries

can be very helpful sometimes and make it a lot easier.

So one of these libraries called, well there's the http library, right?

So you can import http client,

then if you want to send that same get message, you say con equals,

you call this function, they provide you an http lib called http connection, right?

So you call that function, and

you just give it the name of the domain that you want to go to.

So, this actually does a DNS lookup, but it also establishes a connection.

It rolls it up in to one function, and then conn.request, GET and

then /, that is actually what sends the request message.

So, notice that you're just giving the key details.

You're saying, look, GET, this what I want to do,

this is the type of header I want.

And then /, this is the directory of the file that I want.

You just give those key details and

it composes the bytes that it needs to send in the request.

And this actually sends the request for you, so this makes it easier.

Now this isn't, the difference between this and what we saw in the last slide,

isn't that big because the thing on the last slide was pretty simple as it was.

But this can be very helpful for more complicated types of messages.

So even here, you don't have to worry about exactly how the data is going to be

arranged in the packet, in the message in the headers.

You just give it the key data to get in the slash and it composes the rest.

So protocol specific libraries are very helpful in that way.

And there are a lot of them for a lot of different protocols,

we won't go through all those.

But you should know this for future, like for the capstones say, when you want your

Raspberry Pi to interact with something on the network, you don't necessarily have to

work from scratch with socket library, and learn a whole protocol, right?

Say you know you want your HTTP, you want your,

say you know you want your Raspberry Pi to not HTTP, let's say another protocol.

Let's say you want to talk to a mail server,

you want to send some mail, for instance, okay, send email.

So email the typical protocol is called SMTP, so

if you want to send mail you have to compose that mail and

then make a message in the format of SMTP, defined by that protocol.

Now you don't know that protocol, now you can look up that protocol.

You can Google SMTP and

find an information about what that protocol looks like.

But an easier way is just to import SMTP lib and

I then use the function that are provided in there to send the email.

It makes it much easier, right.

So just remember that for the future.

You don't want to build everything from scratch if you can help it.

If there's any protocol, there's no way we can go through all the different protocols

there are, but the different networking protocols at the application level.

But look for application level protocols specific It libraries for

any particular protocol that you're going to interact with your Raspberry Pi.

Along those lines, let's talk about how you interact with an online service.

So what we mean by this is, say there's Raspberry Pi, it's a nice little machine.

But it's small, relatively small okay.

It only has so much computing power, it only has so much resources, so

much information, right.

So in order to get interesting things going on you're going to need, depending

what you want to do, you might need your Raspberry Pi to connect to the cloud,

the web in general, or the cloud, and

offload some of it's job to the cloud, or get information from the cloud, right?

So what happens is, the way this works is there are these online services.

This service is already out there on the web that do something for you, okay?

That do some tasks for you and maybe it's a computational task that your raspberry

pie can't do fast, or something like that, or

maybe it's accessing data that your raspberry pie doesn't have locally.

So these services, they allow you, your machines to connect to them.

So you can make a request, you send a message from your say,

Raspberry Pi, to their servers with some kind of request in there,

please give me this data, please perform this operation, something like that.

And then the server sends back a message to your device with the results.

So there are a lot of online services like this, a whole lot.

They're pretty interesting to use.

So, for instance, Google Maps, right?

Say you want to make a webpage and you want to have a Google map in there.

Say I want to have a webpage with my office in there,

direct people to my office, something.

And I want to have Google Maps, you know,

a map in there with my address highlighted, my location highlighted and

directions to my house and whatever, my office.

So something like that, I would make a webpage and

I want to have, I might want to have code that interacts with Google Maps,

that allows people to do certain search and basically what you do on Google Maps.

You can do it through my page.

[COUGH] So there's an interface for that, that's an online service.

And you can send it a message, a request message, send Google servers a request

message, please give me this map, and give me these directions, whatever.

It'll send them back, and you can put them on your webpage.

Twitter, so, say you want to send a tweet, right?

You can write a program that sends a tweet,

that you don't have to do it manually.

You can create a message, send a message to Twitter servers,

Twitter servers take it and send the tweet.

Or the other way.

Maybe you want your code to examine tweets, right?

So you can send a request message, let me see tweets like this and

it'll send back the tweets, you know.

Let me see tweets that match this characteristic and

though Twitter service will send them back to your machine.

YouTube, maybe you want to make a web page something like that,

an app that has an interface, well lets you upload videos, right?

And basically, you can copy a lot of what YouTube already provides.

You can put that locally on your device, on your app or

your web page or something like that, using their interface.

And Facebook too, same thing, right?

You want to look at somebody's profile or

something like that through Facebook, you can write code that does that, okay?

And it's always Facebook servers, or YouTube servers, Twitter servers,

Google Maps servers, that are doing the job, but your device is

interacting with their servers through messages that are going back and forth.

So there are lots of online services, and if you're interested,

you can Google these.

These type of web based, usually they're called APIs.

We'll talk about this.

You can Google them to get a long list of lots of different public APIs that

you can use.

So, oh, and some of these services you may have to pay for, right.

They're not all free.

So, a lot of them, they have a free part, so maybe you get some ability for free,

but other things you have to pay for, right.

So that depends on what service you're using, right, but

some of them will cost money.

Thank you.

[MUSIC]

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