Save Heterogenous Radio with airSlate SignNow

Save heterogenous radio

hello everyone my name is wiley standage buyer i'm a phd student at arizona state university today we're going to be talking about uh writing the new radio blogs or signal processing applications in gnu radio and the we're going to be walking through what is going to radio the building blocks of it connecting these blocks packaging and deploying them and then argue why the new radio is a good fit for many applications the new radio most of you guys know is a c plus framework for writing signal processing applications with a python wrapping and how it does this is it it splits up your code into logical separable testable chunks with a buffer on the input and a buffer on the output the virtual there are a bunch of virtues to this and hopefully we'll make this clear in the talk it provides some other other tools as well allowing you to package and deploy your code the and it also a lot because your code separated into these individual blocks that it it it provides the scheduling between them part of this breaking your code up into logical blocks is it also provides a collection of existing libraries to do math and other applications or other sort of stuff as well as abstraction of the hardware this is a real real nice thing if you've ever had to deal with directly interfacing even with the uhd library there's a lot of work involved in just getting samples off the radio at times canoe radio allows an easy way you can switch out and switch to either a different radio or abstract that away i guess so if you want to stream files from a sample or stream samples from a file or from a radio or a tcp port it provides all that sort of tools so basically there are a bunch of stuff built in or built with the new radio that you may find interesting or useful um some of these are listed on the screen but that's by no means a list of everything and i encourage you to look around and find your own i'm sure there's at least something everyone should find interesting um if not hopefully after at the end of this you'll be able to write something interesting and share it back with the community i think everyone would uh appreciate that this almost everyone i'm sure has seen the graphical user interface for gnu radio or gnu radio companion um it's the first thing that everyone sees it's provides a graphical representation of what's going on with guinea radios that i have some usrp source or some radio source some processing stages that are connected up together and some destination for the data and we can get into what the specifics are of each of those for each specific application um and that so for this one or this talk we're going to be building this as our application we have a binary source this produces a stream of ones and zeros uh a modulator this is going to take those ones and zeros and turn them into psk symbols or phase shift keyed signals or symbols we're going to send them over um channel in this case it's an additive white gaussian noise channel so we have uh we take in a complex number and then we generate a gaussian random value and add it to it and then we return that and then we run that through a demodulator and then we compare we have a block that compares the original source of bitstream to the uh received bitstream and because this is a system that has been corrupted by noise and we've made no effort to correct for it no error correction code or anything like that there will be some bit error rate and this final block tallies up what the total number of bits is passed through and the total number of errors and will tell you the total the total error rate of the system in going back to slides hopefully everyone can see that now so we've got a good high level view of what we're going to be building for many of the things in here the new radio provides out of the box however this is an exercise in writing uh new radio blocks and not necessarily just using the ones that are there but many of them there and if you'd be advised if possible to try and first make use of already written blocks they will be they're already tested so that saves you the developer a bunch of time figuring out what subtlety is causing your system not to function as you'd expect so alrighty let's let's build a block first we've got to talk about what is a block so we've already seen the flow graph up here where one of these things is a block and performs a logical operation we'll get into what that is now so a block basically contains some setup and initialization some control user-defined methods which we'll get into maybe a little bit later but are a little bit less important than our specific to each block and then a work function on the input to the work function it takes in buffers to the input and the output of the block that's where the you consume data from or time series samples from and you write back time series samples too so your code lives right in the middle there in setup and initialization control user defined methods and work and work is really where the majority of the the stuff is done it so can't talk about or can't have this conversation without talking about different kinds of blocks uh there's synchronous blocks which basically for every sample in they take time series sample in they take in they yield one time sample or return one time sample source blocks they take no inputs and they have outputs so they're the source of the data a little bit uh ambiguously named if you just pronounce it sync s-i-n-k sync blocks uh are just like source blocks in the reverse they take in data but they they spit out no data in other words in other words this might be like a file or some other destiny or a radio where it might take in samples but it may not you may not expect or want anything back from it in terms of time series data interpolation if you guys have some dsp experience where you take in some collection of samples and then you return more samples than you took in decimation is exactly the opposite you take in some samples and you return less than you took in there's a separate type of block for each tag stream blocks give you the ability to have metadata affixed to your string time series stream uh catch up with the chat here the um the example of this would be if i had a frame detector or burst detector peak detector i you could have it label the startup burst with a tag and then that may be a way to signal to downstream blocks for here's where you want to start doing your operation so this way you could separate your detection from some downstream processing like equalization or channel estimation or or a time of arrival estimation general blocks as the the name would suggest you can take in some data spit out some data but you've got to uh you've got to be very explicit for every sample it takes in how much how many samples it spits out then there's perhaps the uh the most different block in all of these and it's a hierarchical block um it's basically a way to compose a bigger block out of sub-blocks so instead of having a work a direct work function you've got many work functions that are composed of blocks that are connected together inside and that are wrapped into a single block and this is this would be useful if you had a for example and not so much for our flow graph that we're building but if if we had a more complicated transmit and receive chain it may be advantageous to put the whole transmit chain and the whole receive chain in one block for each in their own respective block so this you could include things like uh error correction padding uh adding a pre and post amble other possible synchronization or error check in the transmit side and then the receive side equivalent operations and the transmit chain so you could see how you could get many blocks together that you may want to logically cluster together or clump together but would be really useful to just treat as a single block um there is one block that's not listed on this slide and it's a top block but it's sort of a derived case of the hierarchical block and we'll discuss that more at the end so we've already talked a little bit about the kind of the vague structure of a block but when you set up a block in python this is handled by the constructor method or the underscore underscore init underscore underscore method this oh what is an example of a general block um i believe a polyphase resampler is a general block if you had something that took in a flexible rate time series would be another example that doesn't answer your question try to get to it find an example later um the with the con structure we this set you have to set up what kind of block it is uh this is done by calling the parent constructor of the respective type as shown in this slide so if it's if you're wanting to construct a sync block you would have to inform or call the parent constructor for the sync block and then describe your inputs and outputs and then like in the case of the low pass filter shown on screen you might want to also generate your filter taps inside your setup so whatever your favorite method for generating filter taps is for your fir filter you might execute that code there on the given input parameters so in this case you'd have a cutoff frequency of 10 kilohertz a high pass or a high cutoff frequency of 15 kilohertz transition with one kilohertz and respective window and filter parameters here's some pseudo code for an empty new radio block in this case we're calling it my block notice that it's a inherent it inherits from the new radio runtime sync block class um the in the constructor we take in some arguments we don't act currently we don't implement anything in here because this is just a empty shell of a block but we do have to call the parent constructor in this case it's gnu radio runtime or gr dot sync block dot underscore underscore and yet underscore underscore on the self object and that's if you're not python familiar this will look a little strange to you if you are then this would be pretty normal um but it it's just inheritance like in any other language and we have to inform it what type of in what type and how many inputs we have for the input in this case we're taking in type complex and we're returning type complex and then that wraps up for this case our constructor and then the work function for the work method is basically where the majority of your signal processing is actually done and how you how you get the input buffers they're passed in as a list of what appear to be numpy arrays that that you can read and write from that are yeah i guess i'll leave it there that might be better not to over complicate it the so we grab the first item in the first input buffer because we only have one input in this case we only have one output so we grab the first output buffer and then in this case we're just doing a simple copy block so all this does is copy the samples from the input to the output but up until this point we haven't done anything to inform the scheduler or the runtime framework how many samples we've consumed or how many samples we've returned and this is done by the return statement at the end of the work function and we return the number of samples that are written out written to the output buffer in this case it's the same as the input number of samples because it's a sync block so for every one one sample in you write one sample out so talked a little bit about this but break it down in a little more detail so our constructor this is where you might initialize filter taps it's probably good to do all that after you've called the parent constructor but i suppose lived dangerously you could do it before and you basically describe the [Music] the block at this point it's an important distinction here that that this really does only run once for every instance of the block and it runs during when you or when you create the instance of the block so if you expect it to be called multiple times during the execution of your program on a single piece of data like you're updating filter taps or something that's probable it could be done but that's probably not the best way to do that you might be better to add a method that is update filter taps or something like that in that case the work function is as it suggests where the work happens basically this will get called many times during the execution of the program just how many is subjective the specifics if you're running on a continuously arriving stream of data from now until you know the end of the year at one gig sample per second and depending it may get called a lot of times so and then but it can only see the samples in a limited range in other words it doesn't preserve once you've said or informed the scheduler that i'm i'm done with this sample you probably will never get that sample again but let me say that a different different way the scheduler keeps track of the buffer for you and allows you to consume samples and then as you inform it uh that i'm done with the sample it will take that away from you so you're only looking over a fifo input or fifo kind of input we've got a question in the chat i believe each buffered chunk is called a block on data okay i don't see the question in that maybe i'm interrupting for no purpose so so all right so we've gone over the sort of high-level view of what what blocks are how they're structured let's see what this looks like in practice and i can switch to this so keep in mind this picture we've got a binary source some sort of modulator a channel a demodulator and then something to account for or do the counting for all the errors so we come so open the file so included in all the files under under blocks under stages of development so you might imagine if you've been through a base intro to communications class or you've ever had to done some information theory courses or something like that you've probably written i i venture guessed that somebody's written this and you've seen it or maybe you're fortunate enough to write it yourself a statistics class maybe another example of or you write something like this but all this does in this case we're just going to generate some random bits shown in this in line 22. we're going to take those random bits we're going to map them to symbols we're going to take those symbol we're going to generate noise that corresponds to a picture there should be text on the screen okay awesome and then we want to add noise scaled appropriately to the signal-to-noise ratio and then we want to take an attempt to get or get our best guess of what actual bits were sent and then we want to total up the number of errors and in this case we sweep it over snr i i really do think probably yes there is a first pass posted in the github link everyone's probably written something like this um maybe it's worth commenting on a few of the drawbacks this is just a script we really only have a hard-coded number of samples in this case if we wanted to handle 100 trillion samples no yeah i won't say there's no computer out there that wouldn't do that but that certainly wouldn't be the best way to do that um this because you'd have to have a number array of 100 trillion samples in this architecture as well as you can't really i can't really just go test uh yeah line 24 and line 30 as to whether or not they modulated or demodulated correctly there's no idea of separation of the code so we we might go to we were we might get a little bit better version of this and we might break it out into functions so we've got in this case some a function that generates random bits a function that modulates those bits applies a noisy an awgn channel to it and then a function that demodulates them and then something that computes the error rate and then and then all that gets the same for loop before is rolled down into this this is a little better because you know maybe we can call these functions many times to get around the fact that we don't have an infinite amount of memory or exorbitant amount of memory in a system but that's uh and it is an improvement but i'd like to note here um if we look at both the modulator and demodulator we have some code that even though it's not shown in the function we have code that's used in it that's only run once as in generating the constellation uh of the sorry wrong line of the communication system or the eye diagram of the system this is only run once for the whole thing and you could construct it inside each function at every call but you can guess that running the same thing over and over again on the same input should yield the same results and would be pointless i would think it would be pointless i guess opinions may vary um so this is a little better because we can we can now test the modulate function and we can test the modulate function and might be a little tricky but we can still test the the channel function but keep in mind or i want you to to note that this is kind of already looking a little bit like a work function and we've already got something that looks a little bit like a constructor up here even though it's not explicit like that exclusively a constructor it's not in its own namespace and it would be a lo still a little bit tricky to test this especially if it was part of a big project so and let's skip ahead to the fourth pass just to see we were a little bit nicer we might add comments yeah sorry i mean the scroll test um just because you know it's helpful um in case you guys didn't didn't catch this i'm sort of trying to give an idea of the the flow that students take when developing a communications simulation so if we were to write this in getting radio blocks what would this look like well our bit source we'd take in we'd have a constructor we'd have to how you denote that it's a source block we have no inputs and then our output is just intate or bytes chat i i'm aware the spelling was wrong i apologize spelling's not something i'm very good at um but thank you um the uh so and then our work function in this case we don't have to do anything with the input there's because remember we have no inputs on our bit source we have so nothing to do there and we just have one output so we're going to take grab the first buffer of the output we're going to see how big that buffer is so this is just going to appear as a num a numpy array output object for this output if and then what we're going to do we're going to generate a bunch of random ones and zeros and write them to the output and then we're going to tell the scheduler how many random ones and zeros we wrote to the output so that hopefully that gives an idea of of uh what a source block would look like and you could certainly put more complicated stuff in the the constructor or the work function or add additional stuff and the next block is a little better example of that so we've got our modulator which most of this will be lifted from previous stuff with the exception of to put it into an actual guinea radio block so we have our constructor this is actually a decimation block and the reason that is for if we were to do qpsk as described in here or quadrature phase shift keying which is four symbols per sample you can get two bits packed into that so we're converting two bits into one complex sample so we're gonna take in a stream of bits we're gonna spit out one complex sample it's gonna decimate and the number of bits per symbol so in this case this is going to be 2. we'll create it later and then we're going to store the constellation and the bits per symbol but you could just as easily generate if you wanted to say i'm only considering qpsk just generate the um the the constellation points in the constructor that would be another perfectly valid approach for this i just tried to make it a little more general such that i could throw in arbitrary points and then not have to concern myself about modifying a bunch of stuff later the work function on the other hand it does take an input and it does have outputs so we grab the the first input buffer or the zeroth input buffer from the input items we grab the zeroth buffer from the output items um this is some numpy where we basically reshape our input and this just makes it easier because we're taking in two bits per symbol we might want every indices in of time series in the numpy array that is our input to actually contain two samples but and then we're going to take and map those in the next line we map those constellation points to [Music] uh from their respective bits and then write them to the output array and then we inform the scheduler like we have done before how many bit or how many symbols we've written um next we might have a channel this is going to be even simpler and arguably i should have started with this block um all this does is it stores a local variable to the block called snr that'll get used later in the work function and then we inform the scheduler that it takes in complex 64 as the input and complex 64 is the output and then and then informant also the name of this block is uh awgn channel and that that will be useful or may be useful later depending on how far we get um the in the work function just like in the previous examples that show down uh we have we generate gaussian random or complex gaussian random samples that are identically distributed and independent or iid if you guys haven't heard that term before um and then we add them to the input and write them to the output and that forms the basis of a additive white gaussian noise channel yes you can embed um high torch into your code what that would do is in the background it would actually copy your code to the gpu run it and then copy it back um there are some ways to get away around that but this unfortunately uh there's not really a good method right now or a good strategy right now for keeping your data on the gpu in one place but yes you can do it just know that you're going to be living with the mem copy both ways unless you're using uh like the embedded nvidia gpus or something like that where there actually is there will be a mem copy penalty but it will be very small because it's the same physical memory i talked briefly about you could have bound methods and this is about the simplest ones you could think of would be a getter and setter for the snr so we i mentioned earlier you may want to update your filter taps during runtime execution well this would be a good way of doing that you may have a function that's create taps if this were a filter and then it would take in the appropriate parameters excuse me the demodulator is just just the reverse of the modulator block because we're interpolate or we're going from complex samples to two two bytes or two bits per symbol it actually is up sampling or interpolating by two in this case and everything in here should look relatively familiar and then the output is pretty much finding the just like in the the first and second pass examples finding the point in the constellation that's closest to uh the constellation point and then informing it how many samples i've actually done that on um so and then we have i guess maybe i should ask a quick question uh does everyone kind of see the mapping between if i was just to write a function in a regular signal processing application and how that might map to a block just throw in the chat if yes or no just to give me an idea of where you guys are because i don't want to have the equivalent of a bunch of people uh staring off blankly into space and not getting anything out of this that would be unfortunate for uh everyone got a few yeses that's that's good all right so i i guess i feel confident moving on and not dwelling on this point much more but the the error counter just like with with uh in the first and second and fourth pass it does very similar things and most of that code is actually lifted from here in this case the difference is it takes in two inputs and no outputs and then all it does for the work function is it takes in the total number of the binary two binary streams compares them computes the length of it and then totals up the number of errors between the two streams and then has running totals for that and then for computing the uh the bit error rate it just takes those running totals and takes the divisor of them so we'll we'll go back to the slides now because the next slide is so we've talked about sort of building or we've talked about building blocks but we haven't talked at all about connecting blocks and so if we go to our example here of our flow graph we look at look at this you may some of you may have noticed or known that it'll output to a python file is actually what's going on under the hood here and then if we believe i put this in here it's going to be under sorry for not having this pulled up away we have this python file that it actually generates and all that all you know radio companion does is take your description and fill out a template um this this is a very helpful thing because we can see what it's actually doing so let's stops bouncing around uh the it's actually creating an instance of something called top block and then it's got a bunch of filler and the constructor that is mostly user interface stuff it actually creates uh bound variables for the sample rate that was the only variable we had and then it creates instances of every block we passed in in the flow graph then below that it does something interesting um it takes and it describes i'm going to connect port 0 of the demodulator to port 0 of the error counter and then i'm going to connect up the other respective reports and then oh this was the under i will show you um if you go here's your top folder under canoe radio and then gr writing block or new radio blocks and then apps this will be this is the python file that's generated from the the new radio companion flow graph file or the grc file so hopefully that makes it more clear so and then just for completeness we've got a few bound methods and then a main function and then we execute main less important just yet but also useful so so if you notice everything's sort of contained in this idea of a top block and this this is really what the scheduler looks at and says here is where you inform it the the ordering of the blocks what's connected to what and then who has ownership of the blocks from a memory management standpoint if there you may run into runtime problems if i create an instance of a block and then garbage collection comes by and cleans it up later but your program hasn't finished executing so it's just a heads up that may be a problem i only say that because it bit me the other day so it's fresh in my mind the but what it does is the top block being a container for everything it's very much like a hierarchical block except for it's got oh how do you prevent that from happening that is done by if you make them bound to self in the constructor such that garbage collection won't delete it if you just said you know my block or create an instance of my block and then but you never bound it to self the when the constructor finishes it sees that it's just a local variable and not a variable that's in the bound to that class instance hopefully that answers your question if not i guess i can go in more detail a little bit later if you remind me uh good so and really there's four kind of methods you really care about with the top block and start and run are very similar one of those is blocking one is not and then wait waits for everything to finish and then stop actually forces everything to finish um are pretty representative of what they are and here's a another kind of pseudo python code version of this make it a little more clear so we we have a a class that inherits from like a new radio runtime top block it creates in it it inherits from it it calls the parent constructor and then it creates the instances of the the blocks and you may be able to see this self dot block one self.block2 that is what i'm uh i believe so yes if you call start and wait it's equivalent to calling run is there a reason i don't call super uh no no there isn't a reason um this was just to be a little more explicit and get the point across as to what exactly it was i'm doing um the predator the version of this talk that i actually started with was for people with little to no python experience so some of the stuff in here will be a little off or a little incorrect for the sake of clarity or have typos in it which that's all on me so and then here we connect up the blocks and we with the thing on the first argument we notice it's a an in it's the instance of the block comma some parameter in a tuple and this is the port number so it starts from zero so if we had three output ports we could go zero one two and then the second one it's the input so in this case we're connecting port 0 of block 1 to or the output port 0 of block 1 to the input port 0 of block 2. and so whether it's input or output is just denoted by order in the connect method i we haven't really talked in much detail about data types yet so it's probably worth having that conversation now and basically gnu radio really doesn't have a huge variety of data types that it supports built in uh explicitly everyone's kind of seen the the blue tabs on the blocks that are complex or the orange that is float32 we also have of int 32 in 16 and into 8 or byte um and but we can also do vectors so if you guys are familiar with multiple receivers that are acting coherently you might actually want four sample aligned samples to appear as one time sample or you may be reordering things and it may be advantageous to reorder them in such that every time instance i take in n samples but that's really the only data structure that's currently supported so if you had a receiver that every time series sample it returned a complex sample a float sample and an 8 sample so you might have a iq value power value and some sort of radio status for example that isn't explicitly supported right now unfortunately but you can do it if you are consistent about how you hook things up all the new radio schedulers doing is playing some games with memory management to move data around it doesn't actually look at what that data is so if i recast it in the block i can get around that limitation or in python you might see that as creating a new d type for a numpy array won't be doing that in this talk but it is useful if you know when to use it and so for example if you wanted to pass a matrix if you had a correlation matrix you wanted to pass back back and forth between blocks would be a very useful thing you know you could you could do that as a vector or you could do that as the modified d type um buyer beware there are you've got to be consistent on both um ready moving on we've already talked a little bit about sort of the start method and the run methods as well as the stop map the different ways to actually stop them stop the execution of the flow graph but the difference between weight and stop stop just kills it right now it basically it says finish up whatever buffer of data you have and then you're done whereas weight it it hangs around until until they there's a condition where there's no more samples moving through the the flow graph so if you had a block that was passing samples along okay um can anyone else having trouble seeing or hearing me okay okay oh sorry for the person who's having trouble um i am still on slide 19 yes so you might have a block or a a flow graph that only executes on a finite number of samples and in that case what you do is you would uh your in your work function you'd run until you hit the number of samples and then you'd return a negative number this tells the scheduler hey i'm not only not returning any more samples um i'm actually saying i'm done you aren't getting any more samples through me uh why does weight follow um because i forgot to delete the line most likely um writing blocks in c plus plus is fairly similar um there's obviously some c plus plus isms of of it being a different language but it is largely the same in that you inherit from base class and then implement your own constructor and then implement your own work function the the difference in c plus comes from if i have there's a little bit of indirection in that how you actually create an instance of your class there's this make method there's static make method instead of uh directly calling the constructor this is i'm not actually sure why this was chosen to be this way um maybe somebody knows better than me but um is there a reason i'm not using gr mod tool uh actually a little bit later i was hoping to use gr mod tool and talk through that um i was more interested in talking through the uh the python of it um the uh the comment about execution speed generally that's true however i will say developer speed is much faster in python so if you don't if you just want to show that something works or you care more about your time i last i checked computers only makes sense an hour while humans hopefully make dollars an hour you do the cost trade-off or the cost benefit analysis on that one specific to each problem not that and there is no single right answer to that and then questions um if you guys want i'm happy to keep going on on gr mod tool and actually packaging and deploying stuff i think we have i believe this talk actually ends in 45 minutes i'll take that is pedro i believe that's correct um okay it goes till 1800 eastern got it okay so then that actually leaves me with uh almost an hour wow i guess i didn't look at the clock oh so how does giving radio know about um about your actual blocks that that's a good point so i guess i'll get into that with the gr mod tool right now so everyone likes it so if we go to um under gr writing new radio blocks we i took most of the blocks and transplanted them into the python uh folder and i guess i'll take the channel block just because it's nice and simple and hey it's the one block that's actually kind of hard to write a unit test for because it's supposed to be random so um you can see this is almost identical code i just cut and paste it in to uh to this and i know this is a little backwards from if you were actually adding this using mod tool i just want to make clear that this this is what it is the if you were to go under the grc folder there's going to be a corresponding writing a new radio blocks underscore channel.blocks.yaml this is actually how grc knows what what's in what your block is grc in fact doesn't recognize or doesn't know what to do with your code if you don't provide it one of these so basically it describes the idea of it a label which is more or less the name uh what category it belongs in so you look under vrc here is the category over on the side as you can see we've got our bit counter bit source channel demodulator and modulator what input parameters it takes in this case it's just snr and if you recall from the code it's actually really one over the noise power it assumes a signal energy of one or a signal power of one little asterisks there but as long as you you know that that it isn't always to perfectly normalize that your signal if you reuse this block or hopefully write a better block uh that does exist oh uh where this is in the grc folder under the out of tree module gr hyphen writing gnu radio blocks no problem i probably didn't make that clear enough and just to say it again this is actually how this yaml file is what generates the graphical description so you can actually put crazy stuff in there and it will represent it in your block so you can do things like say my block has three inputs however your code doesn't take three inputs and you will likely get uh you likely won't get it to still work if you do get that to work you might consider filing a bug report that it's guaranteed to give some bizarre behavior so so if we all right so let's pull open a terminal this i haven't talked about gr mod tool and actually i think i might have a look real quick i might have a couple slides there we go i do um they're not cleaned up though unfortunately so let's so canoe radio for packaging it has this idea of an out of tree module and basically there's this idea of the core of the new radio tree or packages and then therefore anything that's outside of that is out of the tree trying to make a joke out of it but i think that's the best i can do with this one but more or less it provides you i don't think that joke's worth repeating um it provides you a sort of standard directory structure um your c plus code goes here your python code goes here it also provides most importantly but i guess maybe not most importantly but it provides a standard structure for building your code and installing it as well as testing it and build install and test being common it to me is an important thing i don't know if you've ever had to deal with other phd students everyone seems to roll their own and it becomes a headache to manage whereas if everyone's sort of using the same strategy for doing stuff it becomes a lot nicer so it's just cmake is the build environment even for if it's just pure python is provided yes uh gr uh writing the new radio blocks is an out of tree module i guess i should have stated that so we build it it's you're going to go to the root directory of it and then make a build folder get into that build folder run cma and then make this is if you've ever built gnu radio from source this will be look very familiar and hopefully be easier because it doesn't have hundreds and hundreds of dependencies that you may or may not know and yeah you probably should do an ld config in there um that would be a good idea and then it's one of one of my favorite things is just make test it's a very easy way to run all your unit tests at once and then get a binary yes or no did i screw something up is i don't yeah and then make install as well so the i guess we already talked a little bit about uh adding the graphical description it used to be xml you guys will if you're using uh 3.7 something you will see xml files we've gone away from xml and it's all yaml files now with good reason they're easier for a human to read and write so so let's go back to our to our out of tree module so talk a little bit about the structure of it um so we have a cmake file this i can open that up basically this is generated by gr mod tool and this contains everything to generate the make file i'm no expert on cmake i'm sure many people in the chat are much better than me and i i want to do math i don't really care about the finer points of building stuff so that that isn't helpful to you guys i'm sorry i may not be the best person for that because spend a lot of time screwing up cma files but so we already talked about a little bit we have this idea of putting python in one folder if you've looked through some of the code examples provided under that would be under blocks learn you'll notice we look at modulation we have our blocks as we already described but we also have this unit test down here and i don't claim this to be the be all end-all of unit tests for psk modulation but it's hopefully better than none and then if we just execute this file it executes the unit test so in under the python folder this is actually in a separate folder so we have a separate file rather not folder and i i stripped out to do just to make it simpler um very much the same just using uh gr unit tests and then there there is a c plus equivalent of this as well um oh i did not know that about c make that what is useful information thank you um will save me many characters of typing um so take a look at if we were to actually create a c plus uh block it would locate the actual code in the lib folder and then locate the in the headers for it so that we could use it outside of it as a shared library uh in the include folder and then it would copy the include folder into the respective location on the system when you ran make install or more than likely sudo make install if you're not running with root privileges also just maybe nice to mention it does provide oxygen if you have doxygen installed which on this vm i do not believe i do but it is it does generate that and it does it for uh every time you add a block so i guess let's add a block and so how would you do that in your mod tool so you guys you guys are probably going to get a little more familiar with the command line if you aren't already so i guess let's let's create a new module so um basically gr mod tool if we type help and get the oops and get the list of supported commands and if we're creating a new module what we're going to have to do is use the new mod command and then we're gonna have to give it the name of the mod so i guess how about um and of course i misspelled simple so we're just going to call it simple oot or simple out of tree then it actually creates this thing called this folder called simple or sorry gr hyphen simple oot and go into that and see what that created actually so we can see what changes every time i'm going to use version control so just just like the other one we've got an apps and a cmake folder a docs folder examples folder a grc folder include lib python and then swig i'm going to try and keep the talk to mostly python just because more beginner-friendly but we've already talked a little bit about what each one does i guess the only folder i haven't talked about is swig if you guys don't know what swig is it's a way of wrapping c and c plus plus such that it's callable from python and currently it's the the method that's used in getting radio to provide python bindings i believe that might be changing in the future but at this point in time it is swing so go to gr mod and then help we have this add and what this ad does it allows you to add a block so say we want to add a channel something we've already implemented but you then we can see the process so and it's going to have you go through and fill out a questionnaire uh in this case our channel takes in one sample for every sample it spits out so it'd be a sync block we want to write it in python and copyright holder then a valid list of arguments uh s and r probably noise power would be a little more correct there but we won't get into the argument there and we want q a code for unit test for python and then as you can see it claims to have added a channel.py a qa channel.py added it to the cmak file under python the python folder it's added a empty block in empty yaml file or a template yaml file of the block in the grc folder and then it's added that to the xml file or sorry it's a cma file how do you add you use commas so up here where it says snr if i did snr comma a comma b comma c um that sort of thing i don't believe it does space separation it is commas um i think it actually passes the spaces through but they may have changed that and just to verify we can see all the file get will tell us all the files that have been changed so let's go into python file or folder so we can i guess visual studio look a lot nicer than them simple ot then we've got our channel so this it gives you a header a sort of usual python top of a file it assumes you're importing numpy um this is because these input buffers are lists of numpy arrays and then it creates sort of an empty description of your block this is and then you have to fill it in so in this case numpy uh do we want to do the same thing over or we want to do uh i guess let's just do the the same because i'll make horrible mistake i don't quite recognize so i'm going to take in a complex 64 sample that's going to spit out a complex 64 sample so we've described the inputs and the outputs we're going to store our snr and then in our down here our work function if we remember this is where it gets called repeatedly here's where we add noise um i guess i could fill that in i don't know that it would be necessarily beneficial at this point um perhaps a little better to show that it actually does add what it adds to it so it adds the import for channel and then it in the cmake file it will also include that in the install currently this isn't a functioning block but we go to our grc folder we can see that it it's where it's added this yaml file for outer simple oot underscore channel dot block.yaml this and then the it's also added the reference to it in the cmake file this is we can show you what that is but it basically creates an empty template for um your your block and then you fill it in with in this case it might be snr for the id this will be the same as the make method or the how you construct an instance of the block up here this is the template that gets it uses for actually importing your block in the when you know radio companion goes to generate the python file that uses your block um and then down here you describe under inputs you describe the inputs and then respective outputs of your block and in this case it would be uh channel so it takes in it's got one input stream and one output stream for this particular channel you can imagine a multi-user channel where you know it might take in four inputs and have four outputs and then it takes some time delayed or time shifted linear combination of each of the inputs to form the output as a example of something that might have multiple inputs and multiple outputs and then the file format one i think is just a formality at this point somebody kind of more in depth could probably tell me otherwise but i don't think anything's currently done with that that's there for future proofing but um i guess i mean pretty close to everything i kind of have does anyone have any questions or want to bounce this in a different slightly different direction um i believe there should be a comma after there or it doesn't matter if there's a comma python lists you can put a comma at the end of it or not that's i think python i believe is flexible in that way matlab is not as for running your your block on an fpga that's a little trickier um so that currently getting radio framework is pretty cpu centric there's a lot of work going into making that not the case oh um and there is ways to sort of do that although it's kind of backwards you're going to implement your functionality in if you're wanting to get it to show up and get a radio companion and you're using rfnoc you'd implement it on an fpga and then in getting radio companion it will actually pass the the schedule or the hookup pattern to the what's going on on the fpga that's the closest i give you to implementing it on the fpga um as for i guess i'll pull up the question slide see how i'm answering questions the that's reference um i would say probably i know edius has some documentation on that if you look around on that um the the oh how do you make the box show up in a radio companion when you type run make install um on your outer tree package if everything's correct it will show up in gnu radio companion that it'll copy the yaml files into the respective locations the python files into their respective locations and then and then you may have to restart in your radio companion um it might refresh um i actually haven't thought about that one um i think it it'll just refresh automatically um and it will load in that list of blocks and they'll show up in there um there's a question in the chat about using it with uh jupiter um not that i'm directly aware of that that actually getting it to the new radio new radio to work with uh jupiter notebooks has been uh something i've been interested in for a long time but unfortunately um there isn't really currently a way to do it um the i i wish there was if you've got ideas i and a couple other people would love to hear them uh it would be great to have uh the ability to quickly and easily develop this stuff in a jupiter notebook and show off what's going on um the both okay so it does seem that you have to refresh it um there was i believe there was a question there about module um uh there's there's a question about con or using blocks that were created for i believe you mean uh new radio three seven not two seven unless you're referring to python 27 in 2.0 3.8 there is a tool out there to convert xml to or the xml blocks to yaml blocks and that might actually be in mod tool by now i actually haven't checked on that in a while oh somebody threw it in the chat awesome thank you the oh okay so it isn't module i thought it was in mod tool um uh i guess at this point i don't really have any good suggestions for modifying gr phosphor um i wish i did that'd be jr phosphorus something i kind of wanted to play around with more um or or more kind of gpu based processing currently um if you guys didn't know this skinny radio doesn't directly support scheduling on gpus so if you have code that runs on a gpu a new and that's executed in one of your blocks it will get copied over from the cpu side to the gpu run and then copied back and then as it before it gets passed to another block that copy back has to complete um okay awesome dad that's good to know that uh grm on tool will update your xml files to yaml files that's good to hear that there's a programmatic way of doing that because doing humans doing work machines should be doing is just wrong um i guess i'm a little surprised no one's bothered to ask about uh tag stream blocks or pdus or something really in depth of how you uh implement the finer points of implementing a good mac layer i may have just opened myself up to some pretty hard questions because everything i've said up till now has been about streaming blocks so they expect a continuous time series um yeah so i guess i'll address tag stream blocks first um previously mentioned that it's sort of like a fixing metadata to your stream um unfortunately i don't have any slides on this i didn't expect us to actually go this fast i thought i had an hour um the so if you want to to let's say you had a peak detector or a preamble detector you could say i have detected this or if you've got perhaps another example of this would be if i had if i was looking at a radar return just a single pulse if you not that you'd necessarily build a radar this way you could say i could label my targets or detected targets using tags that would be an example of tag streams and they use this thing called a pmt or polymorphic type which basically lets you okay good awesome somebody threw the link to the documentation in the chat and they they allow you to affix labels um to it i actually haven't don't have a whole lot of experience with using them in python i've really only used them in c plus plus so i may fall a little short on the python side for that the but they're a very useful thing because if you have a bursty receiver bursty communication system so you've got something more akin to most what most digital systems are you aren't always continually running your whole processing chain on every sample you can imagine a walkie-talkie there's a push-to-talk button and it's only tr you're the person trying to talk to you is only transmitting when that button is pushed whereas something like terrestrial broadcast like fm radio or digital television or a lot of satellite downlinks uh don't are just continually blasting out data the blocks to dynamically tune usrp center frequency i believe that exists if you enable the message port on the usrp in guinea radio companion or if you're using the python interface for it you enable it you can do that the if you were going to do it in python probably the simpler way if you didn't need something super dynamic and you had just a schedule would be just to have a for loop and call the method set frequency on the top block so let's say every 10 seconds you wanted to change to a different frequency you'd wait for 10 seconds or allow 10 seconds to pass and then call the set frequency method on your top block or instance of top block would be one way to do it so i guess hopefully that gives a a brief introduction even though i don't have any examples of tag streams um where they might be useful and kind of what they are um pdus on the other hand are a little bit different they're a more mac layer uh operation so there there's no idea of continuous operation on a pdu um and i can point you guys to some information on that there was a talk last year by jacob gilbert of sandia national labs on grp uh out of tree package for pdu utilities and basically you're creating messages and passing them back and forth um usopps don't have a message port to tune frequency i thought they did maybe i'm going uh crazy so they have a command port and then what you do is the pdu message you send there don't have a usrp hooked up to this vm so we hook this up a new flow graph just so you can see the python that it generates because i actually think that's the uh in the end the where you're going to be writing most of the stuff anyways you're going to want to let's save this out if we go generate this and it won't run because i don't have a usrp connected so be nice to run it and show you but it's a simple example you can generate for yourselves um and we go to python that's generated for that okay so top blocks and have more than just the listed methods they've got this message connect which is just like connect except for it connects messages i'm not sure about um emt messages for embedded blocks i'm not sure about that it's likely true off the top of my head i don't no and yeah i can push all of this at the end of the session that's a good idea um i'm happy to do it um so connecting up uh pdu or message message ports is just like connecting up regular data stream except for the scheduler doesn't have this idea that there's regular data that's going to be arriving from it and then you can probably pretty easily see why this would be useful if somebody's attempting to communicate with you you don't necessarily have somebody always transmitting you know there's a reason there's uh frame detection or preamble detection out there because not every radio system in the world is always on um else we might have problems it would make things like uh multiple uh multi-access channels could get somewhat difficult there was no idea of time division hopefully that makes the application of pdus a little more clear i'd known i had this much time or would have got through it this fast i would have actually included some code on this but there there is some good examples in the wiki uh i'm not sure what the difference or what make yamal does um i guess why just say plead my ignorance when i can find out we've got our mod tool oh okay i guess i see what it's got an idea of what it's attempting to do um so if you have blocks with no yaml i guess it'll attempt to generate i'm assuming just a template fill in the template of the yaml file because the uh the inputs and the outputs of the block can actually be set at runtime i'm guessing it doesn't um infer it from your code although maybe it does um interesting i i did not know about uh make yaml this is new to me guess any more questions