Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
  • Nov 26 08:20

    chipmuenk on develop

    Change icon of run button to "s… Fix auto selection of frame len… Add stop icon Signed-off-by: Ch… (compare)

  • Nov 25 16:50

    chipmuenk on develop

    allow writing "j" for imaginary… Merge branch 'develop' of https… fix some formatting issues Sign… and 1 more (compare)

  • Nov 25 08:43

    chipmuenk on master

    formatting updates Signed-off-b… Operate fixpoint filters with Q… clean up code Signed-off-by: Ch… and 31 more (compare)

  • Nov 25 08:43

    chipmuenk on develop

    Reduce width of progress bar Si… (compare)

  • Nov 24 11:33

    chipmuenk on develop

    change initial settings Signed-… (compare)

  • Nov 22 16:24

    chipmuenk on develop

    reduce logging noise, update co… (compare)

  • Nov 22 15:11

    chipmuenk on develop

    process signals from local fx w… emit {'fx_sim': 'specs_changed'… (compare)

  • Nov 19 13:35

    chipmuenk on develop

    fix wrong name in signal, preve… Fix HDL creation widget becomin… Update docstrings Signed-off-by… and 4 more (compare)

  • Nov 18 12:25

    chipmuenk on develop

    only print first dict_sig k,v; … Only emit a signal when widgets… reformatting Signed-off-by: Chr… and 5 more (compare)

  • Nov 18 04:32
    chipmuenk commented #205
  • Nov 18 01:49
    CybEng opened #205
  • Nov 17 17:58

    chipmuenk on develop

    improve logger formatting Signe… Only log first item of dict_sig… (compare)

  • Nov 17 07:39

    chipmuenk on develop

    update docstrings Signed-off-by… rename to_verilog to to_hdl Sig… try remembering results from la… and 2 more (compare)

  • Nov 17 06:46

    chipmuenk on develop

    restructure and rename fx_selec… comment out logging info Signed… (compare)

  • Nov 15 13:15

    chipmuenk on develop

    formatting updates Signed-off-b… Operate fixpoint filters with Q… clean up code Signed-off-by: Ch… and 2 more (compare)

  • Nov 14 15:27

    chipmuenk on develop

    correct "If ... Else" syntax fo… (compare)

  • Nov 14 15:27

    chipmuenk on develop

    Merge branch 'HEAD' of https://… remove superfluous imports, fix… (compare)

  • Nov 13 17:59

    chipmuenk on develop

    fix PEP8 errors Signed-off-by: … Correct order of arguments Sign… improve formatting and docstrin… and 14 more (compare)

  • Nov 10 17:23
    chipmuenk closed #203
  • Nov 10 17:08
    chipmuenk edited #193
Christopher Felton
@cfelton
possibly the first two items for the project and leave the third unstated for now
Sriyash Caculo
@sriyash25
yes, got it
Christopher Felton
@cfelton
leave the external expectations low
Sriyash Caculo
@sriyash25
also, slightly unrelated topic, needed confirmation on filter order for implementation? The previous attempt, if I may call it so, was 2nd order filter implementation only. How do I go about implementing different orders to interface with pyfda?
Christopher Felton
@cfelton
most practical implementations are cascaded 2nd order filters (second order sections)
Sriyash Caculo
@sriyash25
@chipmuenk I'm not familiar with trello, don't mind trying.
@cfelton right, I'll stick to 2nd order in that case
Christopher Felton
@cfelton
we should be able to make it general enough for any order (but there will probably be intermediate value overflows or very large word widths)
Christian Münker
@chipmuenk
I suggest starting with a simple direct form topology
to gain experience with filters with parametrized order in myhdl, never mind that practical iir filters are usually not implemented that way.
Sriyash Caculo
@sriyash25
@chipmuenk Should I try interfacing a simple moving average filter?
Sriyash Caculo
@sriyash25
The HDL generation seems to be working although I haven't actually checked if the results are accurate.
Christian Münker
@chipmuenk
Yes, you could start with simple FIR-filter if that's what you mean - some books refer to FIR filters as "moving average" or "MA". In pyfda, the term moving average filter is used more strictly for a filter where all coefficients are 1. This should be implemented accordingly with a simple accumulator in HDL.
For a start, you could restrict your filter to a fixed order of say 10, then we should discuss with @cfelton how to parametrize the order.
Christopher Felton
@cfelton
I think there is a general design topic that needs to be determined - should the digital circuit blocks be encapsulated in an object (the original example) or a block with a parameter object.
for the first examples might seem overkill, having a few arguments would suffice
in the long term the filter-blocks should receive design parameters from pyfda and have the ability to send simulation data, etc. back.
Christian Münker
@chipmuenk
I really haven't worked with myhdl blocks so I don't know their limits. The API seems nice though. Wouldn't it be worth a try to design a simple implemementation (DF FIR filter ;-) ...) using a myhdl block to gain a better understanding? The time wouldn't be lost as we have to specify + improve the interface between myhdl and pyfda anyway.
BTW: I'm currently finishing a new pyfda release with some changes to the HDL generation part. Hopefully you haven't started to dig into that part too much.
Christopher Felton
@cfelton
the block decorator doesn't provide much to the user, it is really an internal myhdl thing to simplify some things, it is nice because in explicitly labels functions/methods that are myhdl.blocks
I think the best method, is to implement the digital hardware descriptions like the example I posted, but then to create a class that will encapsulate the parameters, control, and status of the filter creation
the API to pyfda will be provided by these objects and they can be coded here https://github.com/cfelton/filter-blocks/tree/master/filter_blocks/fda
Christopher Felton
@cfelton
the link shows the block usage, not the FIR implementation
Christian Münker
@chipmuenk
Only had the time for a quick look: Looks clear & good, I would only suggest handling the float -> integer conversion of coefficients in pyfda so that the user can make a first estimation whether coefficient quantizations has an disastrous effect. It would also be nice if quantization parameters (e.g. accumulator wordlength and requantization method like floor, fix etc) could be controlled via the ui.
Currently, I'm developing in the branch 'hdl_interface', I've renamed the directory with the fixpoint implementations and some files and I'm in the process of redesigning where and how pyfda looks for user files at startup. Perhaps you can take a look before I merge some time next week.
Christopher Felton
@cfelton
@sriyash25 @chipmuenk we started a discussion, how to pass all the parameters to the filter-blocks
one idea is to have a class that can be used to set all the parameters
Christopher Felton
@cfelton

from ..fir import filter_fir_df

class FIRFilter(HardwareFilter):
    def __init__(self, b):
        self.filter_type = 'direct_form'
        self.n_cascades = 0

    def set_cascade(self, n_cascades):
        self.n_cascades = n_cascades

    @hdl.block
    def filter_block(self, glbl, sigin, sigout):
        # this elaboration code will select the different structure and implementations
        if self.filter_type == 'direct_form':
            if self.direct_form_type == 1:
                # all filters will need the same interface ports, this should be do able
                dfilter = filter_fir_df

            if self.n_cascades > 0:
                filter_insts = [None for _ in range(self.n_cascades)]
                for ii in range(self.n_cascades):
                    filter_insts[ii] = dfilter(
                        glbl, sigin[ii], sigout[ii]
                    )
            else:
                filter_inst = dfilter(...)
there are a lot of details missing
this api will take some experimentation to figure out
these objects would live in filter_blocks/fda/fir.py, filter_blocks/fda/iir.py etc.
Sriyash Caculo
@sriyash25
Okay, I think we can start with DF1 FIR and come to cascades later (as suggester by Christian). I will attempt to set parameters through this class and see how it goes.
Christian Münker
@chipmuenk
@cfelton I agree that organizing filters in a class or in several classes is a good approach to bundle all the functionality we need:
  • setting (and maybe getting) parameters like internal and external word formats or coefficients. I suggest a setter method with **kwargs
  • fixpoint simulation stuff
  • HDL synthesis stuff
  • maybe information on internal quanization noise on an algorithmic / behavioural level etc.
Christian Münker
@chipmuenk
I'm not sure though whether it is easier to write one class per filter implementation (given that fixpoint implementations can be very different in e.g. their parameters and simulation setup) or to create a large class.
Sriyash Caculo
@sriyash25
@chipmuenk I was under the impression that we would be creating only two classes for now, one for fir and one for iir filters. Although, even these two can be bundled into one
Christopher Felton
@cfelton
you want a hierarchy, and only create a new class based on the subclasses if one is needed
Christian Münker
@chipmuenk
I think we have reached a point where it would be best to whip up an example that we can use as a base for discussion. In pyfda, I can now easily write a dict with integer coefficients and word lengths and trigger HDL conversion.
My next step would be to think about a way for importing data from fixpoint simulation.
Christian Münker
@chipmuenk
To give some inspiration to our discussion tomorrow, here are a some screenshots from Mathworks fdatool with fixpoint toolbox:
fdatool_quant1
fdatool_quant2.png
fdatool_quant3.png
fdatool_quant3b.png
fdatool_quant3d.png
Christian Münker
@chipmuenk
And this the UI of the current pyfda development:
pyfdax_fixpoint.png
Christian Münker
@chipmuenk

I suggest the following discussion topics for tomorrow:

  • State / progress of the project

  • Import mechanism pyfda <-> myhdl

  • File / directory structure: How do we organize the myhdl and UI descriptions
  • Who you're gonna call: Communication between myhdl and pyfda
  • Interfaces for fixpoint simulations: input data, number of points, output format ...

  • Fixpoint filter implementations: next steps

  • Integration into the myhdl ecosystem
Sriyash Caculo
@sriyash25
A brief summery of the discussion
  • Import mechanism pyfda <-> myhdl
    We will have multiple classes for different filter implementations inheriting from whichever class appropriate. Base class FilterHardware.
    Pyfda will import class as follows: from filter_blocks.fda import FIRFilter
    parameters can be set and simulation run as follows:
    hdlfilter = FIRFilter()
    hdlfilter.set_coefficients(b)
    hdlfilter.run_sim()
    y = hdlfilter.get_response()
  • #55 (issue) demo of fixpoint simulation to be carried out for the fir_df1 filter. Output would be returned as a numpy array.
  • Rounding modes support (ceiling, floor etc.) has to be provided in filter-blocks repo
  • further discussion on limiting wordlengths based on FPGA family for optimal use of resources, providing warnings if wordlength is not ideal.
I may have missed some points