 Okay, I'm Fergus Noble, and I'm Colin Bagley, and we're from Swift Navigation. So this is going to be a talk in three parts. First of all, we're going to try and give you some motivation as to why GPS would be interesting, an interesting topic for hackers. Then the bulk of the talk is really going to be a technical discussion about how GPS works because we think this is really interesting and not many people, you know, know all the details, there's a lot of good stuff there. So we're going to focus on that, and then at the end we're going to present a couple of new tools that we've been working on which should provide a nice platform for hackers to experiment with this stuff. There's a link up there. Actually, that notes PDF is not yet available. We'll try and get it up there shortly after the talk. And if we'll be in the Q&A room, room three, it's just right out of the door and then right again after the talk, I don't know how to say it. Okay. There's a lot of people here. We're kind of worried about after the celebrations last night that there wouldn't be anyone here, but I guess we have the opposite problem. So why is GPS interesting for hackers? Why are we doing a DEF CON presentation about it? Well, there, I mean, GPS devices are ubiquitous. They're estimated to be like in the high hundreds of millions of them in various devices around the world. So they, they're very common and very widely used, but there are very few open source projects that implement a high performance embedded GPS receiver, not in fact, hours that we know of. And so we, yeah, we think that it is a project that we, there, so there are a lot of different use cases for GPS receiver that are not, it's hard to design a proprietary receiver that meets all these different use cases optimally. And so we feel that having an open platform allows people to optimize the receiver for their own particular application, which is very useful. There's a lot of different hacker projects that use it. There's been a lot of open source UAV stuff that has become very popular in recent years. There's a lot of open source inertial sensing stuff these platforms and we feel that an open source GPS platform would get quite well for these. And then there's a black hat, white hat dynamic where there is like all of our infrastructure depends highly on GPS and on the unencrypted signals, which there's massive, massive vulnerabilities there. Financial systems all depend on it, communication systems, transportation systems, you name it. And so there's a lot of interesting problems there with jamming and spoofing these infrastructure that are quite interesting. Okay, so I thought I'd kind of explain how we ended up here and you know how this project got started. Colin and I met at a company called Joby Energy. We used to make, work on making, it was kind of a crazy project. So we were working on building high altitude wind turbines, which is where you take a rigid winged kite, put some big propellers on it, tether it to the ground and fly it up like a kite into the jet stream and hope to generate power. And so the photo you've got here is one of our prototypes. It's just like a little, I think it was a couple meters span conventional UAV basically only with a tether holding it to the ground. And you would fly this thing up and it would autonomously fly circles into the wind. And this thing was pulling like 8Gs continuously, I don't know the airspeed, like 100 miles an hour, 20 feet off the ground. And we were looking for GPS systems which could offer that kind of performance. And we really just couldn't find anything that was suitable. And we also couldn't find any open source platforms which we could use to adapt to our needs either. So we decided to start our own project. And we worked on it with Joby Energy for a couple of years. And a couple of months ago I decided to spin off and start working on it full time. So I guess that's why we got here. We really found this need to have a flexible, customizable platform which you could use in these high dynamic environments, other more demanding applications than could be met by just the type of GPS you're having yourself. So here's another UAV platform that we think will benefit greatly from this project. And sort of plug for our friends at Transition Robotics. They're giving a talk tomorrow about Paparazzi, the open source autopilot. That's a three tomorrow? Or Sunday, sorry. Yeah, Sunday four. Yeah, so like centimeter level position hold for things like this, autonomous landing. Yeah, there's many different applications. And another huge area of application is research. Spoofing and jamming, you guys may have heard about Todd Humphrey in University of Texas at Austin, their recent demonstration of bringing a drone out of the sky with spoofing. There are many cases of very simple like jamming devices. Yeah, so like there's been cases of. There's been a couple of cases recently where truckers have been, the trucking companies have been installing GPS's in all of their vehicles so that their drivers don't drive too many hours so they take all the breaks they're supposed to take. And of course people have made these very simple, just like white noise source jammers which block the GPS signal so they can drive longer or whatever. And there's been a couple of cases recently where people, these trucks have pulled up outside airports and I think, I can't remember the airfield in question, but like shut down a major international airport for a day until someone found it. And this is just a really simple device. So there's a lot of work. It's like a very open area. How can we combat jamming or spoofing and detect it? Or also, you know, what techniques could we implement to, you know, to do more sophisticated jamming or spoofing more on the, you know, kind of attacking side of things. But yeah, do you want to take over for us? There's been a lot of research into what's called multi-path, which you tend to get in places like urban canyons. In a metropolitan area with like very large buildings, you don't know exactly where the signal is coming from. It could be coming from the satellite or bouncing off something. There are other what are called GNSS, Global Navigation Satellite Systems other than GPS. The Russians built one called GLONASS, which is also fully operational, but not quite as cool. Some kind of weird engineering decisions there. But Galileo, which is the new European system that is being brought up. Compass is a regional, I don't know what that's being, Compass is a system developed by China. And then there's a whole host of advanced positioning techniques that there's a lot of research into. You have carrier phase RTK, which can give you down to a few centimeters resolution. Survey grade post-processing, which can give you into the millimeter range. And there's a lot of research with fusing inertial sensors into positioning systems. Okay, so I guess we'll move on to the kind of the meat of the presentation. Hopefully that's given you a bit of a justification as to why, you know, this might be an interesting area to look at. So we're going to give you a run-through of how GPS works just in basic terms. So the first thing we're going to look at is how you might find the position of the receiver. Basically, this works through measuring distances from satellites. So if you imagine you have your GPS satellite somewhere in space here, if you imagine you had some magic ruler through space where you could just measure the distance, not the vector, just the distance from the satellite to your receiver, if you had just one satellite, then knowing that one distance puts your receiver anywhere on the surface of a sphere of a constant distance away from the satellite. If you imagine you had two satellites now and you had a distance for each of them, then where those two spheres intersect, you're left with just a circle. So now we know, given the distances from two satellites, that our receiver must be somewhere on a circle. And you see how this is going to go. If we add three, then we're going to be left with two, just two points where these spheres intersect. You could imagine if you took any two pairs of those spheres, they're going to make a circle, and then the two circles are going to intersect at only two points. And usually in practice, this would be enough to determine the position of the receiver, because one of those points is almost always miles off in space and can be completely discarded. So given some assumptions about where a sane position for the receiver to be is, that pretty much locks it down to just one position. So if we can measure these distances, then that's how we're going to go about finding our position. Also, you need to know the positions of the satellites in space in order to give some coordinates to that point. However, there's one slight complication. We don't have any way, any magic space ruler to measure these distances. All we can do is, or the best we can do is measure a time of flight of a signal sent from the satellite to the receiver. And this time, you know, with the speed of light gives you a distance. The trouble is the clock on the receiver is not synchronized to the clocks on the satellites. All the satellites have a synchronized clock, so they all transmit the signal at the same time. But you don't know exactly when they did it, because you may have some error in your clock. So that corresponds to an amount of time, an unknown amount of time added to, in common to all of these times of flights, which is unknown. And the way we get around that is actually by adding a fourth satellite. And that just locks down that extra degree of freedom, gives you the extra information you need to uniquely determine that unknown time period. So, you know, it's just four equations for unknowns, which is why, you know, if you've got a GPS receiver in your car or something, it will only start giving you a position solution when it's got four satellites. So, now we know it's all about distances to the satellites. So, how can we measure these distances? So, we can't measure the distances directly with a magic ruler. So, we measure flight times instead. So, you can see at the top here, we have a diagram, the distance between the satellite's antenna and the antenna on Earth. At the bottom, we have an impulse traveling from our satellite. It starts at time, equals zero, and it arrives at our antenna on Earth at time, equals distance divided by the speed of light. So, given that we know the speed at which these waves travel, all we need to know is the time to figure out the distance. So, how can we measure that time? We can measure the time by measuring the phase of certain codes that the satellites transmit. So, in this diagram, you see two satellites, and they each transmit a unique code. These codes are for the signals that we're discussing are 123 bits long. That's 123, not 124, or 1,000, 23, not 1,000, 24, excuse me. And they're transmitted at a rate of 1.023 megahertz, which gives them a period of 1 millisecond. So, what we do is we measure the relative flight time of these signals. So, you can see that each start of each signal is transmitted at the same time from each satellite. You can see bit end, they both just transmitted. But for satellite one, we've just received, or just about to receive bit zero. For satellite two, we're just about to receive bit 42, which illustrates that. We receive the start of each of those periods at different times. So, we measure the relative phase between those, which gives us the relative distance to each of the satellites. Note there's still a common offset that we don't know, which when we solve for the time, that fourth variable, then we're able to eliminate that. Okay, so let's talk a bit about the low level details of how these signals are actually transmitted, how they're modulated, and what's sent from the satellite. So, as Colin said, the, I guess the main thing which is transmitted is what we call the code. It's a 1,023 bit sequence, which we'll talk about in a lot more detail, you know, how that's actually derived. It's transmitted at a bit over a megahertz, so it's got a period of one millisecond per code. But this code is fixed. It's the same code just repeating over and over again for a given satellite that each satellite may have, or does have a different code, but for a given satellite that code is fixed. And now whilst it's going to allow us to derive some timing information, we can't use that to transmit any data because we can't change anything. So piggybacking on top of that code, we're going to add a low speed data channel, what's called a navigation message or navigation data. And that's a 50 bode data message, and that's modulated just by flipping all of the bits in the code. So every, I said the code's got a period of one millisecond, so 50 bodes, so it's 20 milliseconds. Every 20 repetitions of the code, we're just going to flip all of the bits in that code depending on whether we want to send a one or a zero in our navigation data message. So taking those two things together, you know, the code in the navigation message, that's going to give us a bit stream that we want to send. And then that's just modulated using a pretty common technique called binary phase shift keying. Also note the time scales here are really not to scale because the carrier is at just over one and a half gigahertz. But what we're going to do is we're just going to flip the sign of the carrier depending on whether we want to transmit a one or a zero because it's a binary phase shift keying system. We've only got two phases, zero or 180 degree phase shift. So that's just the same as flipping the sign on the carrier. So I guess that's, yeah, it's a very common modulation scheme. So the next thing that might be of some interest is how we get this radio signal into the digital domain so we can do some processing on it. I'll just go through this really quickly because I don't want to go into too much detail, but we have some antenna. The GPS signals are really, really weak. So first thing we're going to do is amplify them. They're pretty high gain, very low noise amplifier. There's like a bunch of other things in that piece of spectrum, a few other satellite navigation systems there and different, you know, other things that we're not interested in. So the next thing we're going to do is just filter all of that stuff out, just have a nice, narrow band pass filter which is going to select just our GPS signals. It's about two megahertz of bandwidth that we're interested in. This is a very common radio architecture. Almost every radio works in this same way. So now we've got our two megahertz bit of GPS spectrum that we're interested at still up around one and a half gigahertz. And that's obviously way too fast to be easily sampled by an analog to digital converter. So what we're going to do is just shift that two megahertz chunk of spectrum down from, say, you know, whatever it is, one and a half to one and a half gigahertz plus two megahertz down to just zero to two megahertz. This works basically if you remember your trig identities, if you multiply two sinusoids, you get a sum of frequencies and a difference frequency. So if we take this thing called a mixer, which is just a multiplier, basically an analog multiplier, and we generate our own local sinusoid of a frequency close but not exactly the same as our carrier, then what we're going to do is end up with a difference of those frequencies. So say we set this local oscillator to two megahertz different from our carrier, then the difference in those frequencies is going to be two megahertz and we're going to end up with, you know, that same signal shifted down zero to two megahertz. And we're also going to have another component which is the sum of frequencies, which is going to be way off at like three gigahertz or something. So the next stage is to just filter that out and we're left with our signal shifted down where we can just sample it directly with an ADC. So now let's talk about how we can measure this code phase that we talked about. So just introduce a couple of, I guess, mathematical bit of background. I'm sure most, you know, a lot of you will be familiar with this, but it doesn't hurt to go through it again. The basic way we're going to measure the code phase, just going back to the code phase is this idea of which bit you're on in your sequence in your code. You want to determine what position you're currently receiving at so that you can compare the signals from the different satellites. So the way we do this is all centered around correlations. So to just go back over what a correlation is, what we're going to do is imagine we have two different bit sequences. What we're going to do is take them bit by bit and just compare the two bits. So you could say multiply the two bits and if they're the same, then we're going to put a plus one. And if they're like in this lower diagram, if they're different, then we're going to put a minus one. And we're going to go through the whole sequence and just compare the bits bit by bit and then add up all these plus ones and minus ones that we've collected at the bottom to give us our correlation. That's just a numeric answer. And this is a kind of metric of how similar two signals are. If it's a higher number, then they're closer to each other in some sense. So for example, if you had two signals that were the same and you performed this operation and shifted one of the signals relative to the other, well imagine first of all that you didn't shift it at all, then of course all the bits are going to be the same. So every bit down here is going to be a plus one and the sum is just going to be the length of the bit sequence. This would be a perfect correlation. Now imagine we had some had the same signal but now we shifted it one bit to the right down here. A lot of the bits are now not going to line up and if we had some longer sequences with several high bits in a row for example, you might get some bits still correlating but on the whole it's going to be massively reduced magnitude of the correlation. So that's a correlation where you just take these two bit sequences, compare them and come up with this sum which tells you how similar they are. A simple extension to that is a cross correlation where we're going to take two signals and perform a correlation multiple times with different shifts like we've got these two here with a shift of zero and one. If you imagine you plotted on a graph all the different possible shifts you could have shifted by and what the correlation ended up as for those shifts then you can build up a plot of the cross correlation. So at zero obviously you're always going to have a peak but then for many signals you know you might find that it would tail off pretty quickly after you move away from zero. So now let's talk about the codes that the GPS satellites transmit. These were invented by a man named Gold so they're called gold codes. It's a special optimal set of codes which have some certain nice properties which we're going to use to which are going to directly allow us to implement this code phase measurement using correlations. You can generate a set of gold codes for any length two to the n minus one and there are going to be two to the n minus one different codes in that set of the same length and they have basically two nice properties and they can be shown to have to be the optimal bit sequences having these properties. So if you take a gold code and perform the cross correlation with itself what you find is that obviously at zero it's going to have a peak but the gold codes have this optimal property of having very low correlation elsewhere other than a shift of zero. So you can say that autocorrelation is as good as you can get an approximation to a delta function for a finite length code and we'll see how that's going to be useful in a second. The other property is I said for a there are many gold codes you know if you can have a certain length there are many gold codes in that set if you take two different ones and perform the cross correlation between two different gold codes in the same set you'll find that their cross correlation is zero everywhere or close to as close as you can get to zero everywhere for a finite length code and these two properties together are going to be very useful for implementing our code phase measurement. So how do we put this into practice? If we if we imagine we're performing this this correlation operation again and the two bit sequences we're going to use are what we get from our analog front end the received signal and what we're going to do is generate a local copy in software of the code that the satellite we know the satellite is transmitting each satellite is transmitting a different one of these gold codes in out of the same set so say we knew it we were looking for satellite number 10 then we would locally generate the the gold code corresponding to that satellite and what we're going to do is just try a number of different shifts or rather find the cross correlation between the incoming signal that we're receiving and this locally generated copy of the code just by shifting this locally generated code bit forwards and backwards as the as the receiver is running and hopefully you know we'll we you know we can generate this cross correlation plot and we should see a peak if we if we remember the gold codes had this delta function like auto correlation property when when our locally generated code is has a shift of zero relative to the received code we're going to get a massive peak in our correlation so if we're trying to find the the phase of the received code it's enough to just shift our locally generated code backwards and forwards until we find this correlation peak and then we know that our locally generated code must be in perfect phase alignment with the received code and you know of course because we generated our locally generated code we we know it's phase so that allows us to measure the code phase. The second property of these gold codes is going to allow us to receive from multiple satellites which is pretty useful so you need at least four satellites to get a solution. All of the GPS satellites transmit on the same frequency and you know they're transmitting data modulated in pretty much the same way so you think how are you going to distinguish between different satellites. If we think back to this property of the gold codes that two different gold codes have zero cross correlation then we're going to see that actually if we well if we performed this cross correlation between say satellite A code from satellite A and we locally generate satellite A's gold code then it's going to have this delta function like cross correlation allowing us to pick out this peak but if instead we were locally generating a code for satellite B then it's going to be zero everywhere so it's going to make no contribution to the to the correlation that we measure so basically this property of gold codes allows us to have the satellites independent from from one another even though we're we're we're receiving them on the same frequency. Okay so just to sum up why gold codes are cool they pretty much are the the key idea in GPS there's really three things they allow us to get this phase information which is allows us to measure the time of flight this is you know really the the main measurement we want to make they as I just said they allow us to transmit on the same frequency for all of the satellites and distinguish between them this is basically a form of CDMA same technique that's used in modern mobile phone networks and the third thing is which I haven't really mentioned is it allows us to pick up this really really weak signal the GPS signal is actually below the thermal noise floor of the receiver so just the the heat in all of the components in your receiver like knocking carriers around in the silicon is going to contribute more noise than the actual signal from the GPS satellites itself so we need we need some way to to be sensitive to such a small signal and really it comes back to the fact that when we're doing performing a correlation we're effectively integrating over a over a long period whilst so any noise is going to average to zero but any contribution from the code is going to be amplified and so in the case of GPS we've got the thousand and twenty three bit codes where we're integrating over thousand and twenty three bits or a whole millisecond so this gives us a huge gain in sensitivity there's another detail that we haven't discussed yet which is that the satellites are moving so quickly and the frequency that signals are transmitted on is so high that there is a non-insignificant Doppler shift on the signal when it reaches us of a couple kilohertz this comes in more important in a second when we talk about acquisition tracking but it's just important to know that we talked about down converting the signal from the carrier to a low frequency you actually even if even if that frequency is nominally zero you typically have to mix it again down and software to accommodate for Doppler shift okay so the navigation message gives us some information about the orbits of the satellites so we need the information about where the satellites are to know where to know where our position is in three space relative to them so as we said before the navigation message is transmitted at 50 BOD and there are 20 code periods in each navigation bit so at the at the end of this 20 code periods you may or may not have a flip in the the sign of the signal due to the navigation bits the whole message takes 12 and a half minutes to transmit which is why old school receivers will take 12 and a half minutes to give you your first position solution. So to sum up we have these kind of two paths come together to give us our position solution that come from the code correlations on the right hand side is the flow of signal processing to get the ranges to the satellites you start with code correlations from the correlations you can infer the code phase from the code phase you can further time of flight from time of flight you can further distance the satellite on the left hand side code correlations also give you the navigation message which allows you to extract data about satellite positions. Okay so in the the previous section we introduced basically so all the all the operations which we need to implement a GPS receiver now we're going to talk a bit more about how how these techniques are used in a specific way and almost all GPS receivers have effectively two modes of operation which use these same basic operations in two different ways depending on what you're trying to do. The first of these is called acquisition and this comes in when your receiver is just starting up from cold and you have no information about the satellites whatsoever. You don't have any estimate really of what their code phase or the Doppler shift. These are the two parameters that we're interested in that uniquely determine how we're receiving that satellite is the code phase and Doppler shift. So if you have no information you start in this mode called acquisition and we've got these two parameters and effectively all acquisition is it's just an exhaustive search over the whole two-dimensional space of code phase and Doppler shift. So here's a plot taken from some real data and all we've done here is just searched over all the possible values of code phase 0 to 1,023 bits worth of shift and Doppler shift I think we're here the range is plus or minus 5 kilohertz something like that and we're just searching you know for every point in the space we try out a cross correlation and plot the magnitude of that correlation and see if there's any signal present and as you can see you know you have this noise floor but then a pretty substantial peak where the satellite is present but as you can imagine this is quite a large space and each of these operations takes a you know not an insignificant amount of time because you're effectively doing a 1,023 bit integration so this is a very expensive process and we want to avoid doing it if we can if there's a faster way we can do it so if we can find a cheaper alternative then we can provide our user with more frequent updates in the position solution we can you know track more satellites at the same time or we can run at lower power so we want to avoid using you know this is why we can't use acquisition to perform every every measurement and it's also why you would try and make this this acquisition grid as course as possible I think that's all there is to acquisition so like first said acquisition is a very resource-intensive process and so we use a different method to quote-unquote track the signal once we've acquired it in that two-dimensional space to update that code phase and carrier frequency so this shows you roughly how the the code frequency is updated by the tracking loops so instead of doing one thousand twenty three correlations or you generally actually do more than that in acquisition and we only have to do three correlations we do one where we think that the signal is and that's the that's the prompt correlation we do one right before where we think it is the early correlation we do one right after and through those three we can kind of get a metric of how our locally generated code signal matches up with the received code signal so on the left you can see the case where it matches up pretty well the prompt correlation is right in the center of that peak a correlation peak and and the early and late have approximately the same value in the center you can see the early case where the early correlation is the greatest and prompting later less and we we use we we subtract the late correlation from the early correlation and to give us an idea of of what the error in our local code is and you can see when the when that when the early minus late correlation is greater than zero then we know that our locally generated code is a bit faster than the code that we've received and so we have to slow it down a little bit on the next integration period on the right you can see the the late case where the late correlation is the greatest and you have the opposite case early minus late correlation is less than zero and so this early minus late correlation is commonly called discriminator and that feeds a delay locked loop that helps us filter out our code frequency and get a lock on it the care the tracking of the carrier frequency or the Doppler shift is done in a very similar way and the discriminator is calculated slightly differently using the in phase and quadrature correlations but it's it's very similar here you can see a a plot of some real time tracking we did the blue signal is the quadrature signal and the red signal is the in phase signal if you remember from that analog slide the analog front end when we sample the signals we actually have two we have two signal digital signals that we sampled the in phase and quadrature versions those are ninety degree shifted mixed down signals and you can see the nav bit transitions in the red signal as it shifts from like positive forty thousand to negative forty thousand the code and carrier tracking loops are done in such a manner that they ignore these bit transitions in the beginning you can see the the red the red signal kind of ramping up and that corresponds to our tracking loops the the frequency of the code and carrier getting more accurate and that's the correlation and becoming greater okay so we wanted to focus in this presentation on the technical aspects of GPS because you know that's what we find interesting and we wanted to give you a flavor of you know that that side of it but just briefly we'll introduce a couple of new tools that you might be interested in using if you are wanted to to pursue some some experimentation in this area so I guess it's probably good to start with a little survey of what's what's already available very quickly we have something like a new blocks receiver really really amazing receiver for like a hundred bucks you can get two and a half meters of accuracy five hertz update in position solution it's small it's low power really nice integrated little unit more similar to what you have in your your car navigation system or your cell phone but it's it's completely black box there's not really any anything you can tune on it no parameters to be to tweak you pretty much just just get what you're given and it doesn't implement any of these Colin mentioned it there are these advanced positioning techniques which are pretty useful for example carrier phase RTK where you're taking two receivers and doing a differential measurement between the two of them and this is gives you like centimeter level precision and a receiver like this would not implement any any higher higher performance techniques like that going up the step you've got fantastic products from companies like Novotel I didn't actually get a quote on this receiver but it's like a full figure kind of number shaves a meter of off the position error compared to a new blocks type receiver and it's got firmware upgrade so you can add all of these fancy features but again it's pretty much just a black box there are a few basic parameters you can tweak but it's not very flexible going up a step again and in some ways you've got products like the memory from some guys that I think it's the University of New South Wales for like sixty six hundred dollars you can get a really nice platform and if you buy it you get the source code you get the board files you get all of the the details of the hardware so you can go and tweak it but it's not open source it's pretty much a closed platform and it's still fairly bulky and power hungry it's not something you can just duct tape on your quadcopter and go flying so we kind of wanted to fill this gap a bit so I guess the first tool is a library there are a couple of really good open source GPS toolkit libraries out there but we found none of them really met our needs so in LibSwift now if we try to implement all of the basic building blocks of a GPS receiver you know as Colin talked about like this these tracking loops the performing the navigation solution from the distances the pseudo ranges all of these are building blocks unlike the other libraries that are available it's designed to be really lightweight it's it's portable standard C no dependencies apart from I think the C standard library even that you could you could factor out pretty easily it's fast it's lean we run it on a on a microcontroller pretty low-power microcontroller so in contrast to the other existing libraries which you might run on your your machine locally with just an analog to digital converter plugged in this is something you can run an embedded system and it's designed to be flexible you can prototype new ideas with it quickly so yeah hopefully this this is something that should prove to be useful to other people and just briefly this is a hardware platform which we've come up it come up with it runs this library that we mentioned on they've got a microcontroller it's the the fairly new STM32F4 from ST it's it's a Cortex M4 core so it's pretty lightweight but it does have a few DSP instructions it's got hardware hardware single precision floating point which is pretty handy and it's pretty low power we've also got a Spartan 6 on their FPGA and that is basically it doesn't do anything that smart it's just filled to the brim with very basic correlators which the STM can go and program to perform correlations against different codes or you know all the parameters of the correlation and just get return the result back it's low power depending on the firmware you're running it's a little under half a watt it's small it's like a couple inches square so yeah these are our new tools and I think we've got a little little extra time so I guess we can take a couple of questions the cost so we're currently just gearing up to do like a beta a beta run and we're looking at around a thousand dollars yep no we haven't it should should build pretty easily on something like a Raspberry Pi that that should work fine yeah you just need to find a way to get your front-end data in which should be easy enough but should should build on any any system with a same-seat compiler sorry you have to shout TV tuner chips we haven't I know some people have had some success the GNU radio guys use those TV tuner chips quite successfully I'm not sure if they've received GPS I guess the problem you may have is sensitivity they're not as sensitive as a dedicated GPS front-end what we've got on the the pixie is a maximum front-end dedicated for GPS okay and we're out of time so we'll be in Q&A room three if anyone else has any questions thanks