精华内容
下载资源
问答
  • python REfO模块使用入门 在国内基本找不到关于REfO的使用的博客,转载一篇外网的使用实例 链接: Regular Expressions for Objects. For work I recently needed to do something that is very similar to regexes, ...

    python REfO模块使用入门

    在国内基本找不到关于REfO的使用的博客,转载一篇外网的使用实例
    链接: Regular Expressions for Objects.
    For work I recently needed to do something that is very similar to regexes, but with a twist: it should operate on lists of objects, not only on strings. Luckily, Python came to the rescue with REfO, a library for doing just this.

    My usecase was selecting phrases from Part-of-Speech (POS) annotated text. The text was lemmatized and tagged using SpaCy and it resulted in lists of the following form:

    s = [['i', 'PRON'], ['look', 'VERB'], ['around', 'ADP'], ['me', 'PRON'], ['and', 'CCONJ'], ['see', 'VERB'], ['that', 'ADP'], ['everyone', 'NOUN'], ['be', 'VERB'], ['run', 'VERB'], ['around', 'ADV'], ['in', 'ADP'], ['a', 'DET'], ['hurry', 'NOUN']]
    

    From these sentences we want to extract human action phrases and noun phrases, which are defined as follows, using regex-like notation:

    human_action = ("he"|"she"|"i"|"they"|"we") ([VERB] [ADP])+ 
    noun_phrase = [DET]? ([ADJ] [NOUN])+
    

    Translated to English this means that human actions are defined as 1st and 3rd person, singular and plural pronouns followed by repeated groups of verbs and ad­po­si­tions (in, to, during). Noun phrases are composed of an optional determiner (a, an, the) followed by repeated groups of adjectives and nouns.

    Most standard regex libraries won’t help you with this, because they work only on strings. But this problem is still perfectly well described by regular grammars, so after a bit of Googling I found REfO and it’s super simple to use, albeit you have to read the source code, because it doesn’t really have doc­u­men­ta­tion.

    REfO is a bit more verbose than normal regular ex­pres­sions, but at least it tries to stay close to usual regex notions. Lazy repetition (*) is done using the refo.Star operator, while greedy one (+) is refo.Plus . The only new operator is refo.Predicate, which takes a function which takes a parameter and matches if that function returns true when called with the element at that position. Using this we will build the functions we need:

    def pos(pos):    
    	return refo.Predicate(lambda x: x[1] == pos) 
        
    def humanpron():    
    	return refo.Predicate(lambda x: x[1] == 'PRON' and x[0] in {'i', 'he', 'she', 'we', 'they'})
    

    For matching POS, we use a helper to create a function that will match the given tag. For matching human pronouns, we also check the words, not just the POS tag.

    np = refo.Question(pos('DET')) + refo.Plus(refo.Question(pos('ADJ')) + pos('NOUN'))
    humanAction = humanpron() + refo.Plus(pos('VERB') + pos('ADP'))
    

    Then we just compose our functions and con­cate­nate them and we got what we wanted. Using them is simple. You either call refo.search, which finds the first match or refo.finditer which returns an iterable over all matches.

    for match in refo.finditer(humanAction, s):   
    	start = match.start()    
        end = match.end()    
        print(s[start:end])
    
    [[u'i', u'PRON'], [u'look', u'VERB'], [u'around', u'ADP']]
    

    So, it’s always good to Google around for a solution, because my first instict to whip up a parser in Parsec would have lead to a much more com­pli­cat­ed solution. This is nice, elegant, short and efficient.

    展开全文
  • 本文主要参考SimmerChan大神文章:... 1 简介 基于浙江大学在openKG上提供的 基于REfO的KBQA实现及示例。代码部分浙大方面已经完成绝大部分,这里主要将其应用到自己的知识图谱上。...

    image

    本文主要参考SimmerChan大神文章:https://zhuanlan.zhihu.com/p/33224431
    Pelhans 大神的博客:http://pelhans.com/2018/09/03/kg_from_0_note3/

    1 简介

    基于浙江大学在openKG上提供的 基于REfO的KBQA实现及示例。代码部分浙大方面已经完成绝大部分,这里主要将其应用到自己的知识图谱上。在运行KBQA代码前,应按照前面的教程将电影类知识图谱导入到Jena的TDB数据库中,并运行fuseki服务器,这样我们才能进行访问查询。

    1.1代码结构

     jena_sparql_endpoint.py
            query_main.py
            question2sparql.py
            question_temp.py
            word_tagging.py
            external_dict/
                csv2txt.py
                movie_title.csv
                movie_title.txt
                person_name.csv
                person_name.txt
                __init__.py
    
    • "KB_query"文件夹包含的是完成整个问答demo流程所需要的脚本。
    • "external_dict"包含的是人名和电影名两个外部词典。csv文件是从mysql-workbench导出的,按照jieba外部词典的格式,我们将csv转为对应的txt。
    • “word_tagging”,定义Word类的结构(即我们在REfO中使用的对象);定义"Tagger"类来初始化词典,并实现自然语言到Word对象的方法。
    • “jena_sparql_endpoint”,用于完成与Fuseki的交互。
    • “question2sparql”,将自然语言转为对应的SPARQL查询。
    • “question_temp”,定义SPARQL模板和匹配规则。
    • “query_main”,main函数。

    在运行"query_main"之前,读者需要启动Fuseki服务,具体方法请参考上一篇文章。

    1.2 展示:

    2具体实现

    基于REfO的简单知识问答的原理很简单,就是通过REfo提供的匹配能力,在输入的自然语言问题中进行匹配查找。如果找到我们预先设定的词或词性组合,那么就认为该问题与这个词或词性组合匹配。而一个词或词性的组合又对应着一个SPARQL查询模板,这样我们就借助REfO完成了自然语言到查询模板的转换。得到查询模板后,我们就利用Jena fuseki 服务器提供的端口进行查询得到返回的结果。

    2.1 模块一 word_tagging部分

    该部分利用jieba分词对中文句子进行分词和词性标注。将词的文本和词性进行打包,视为词对象,对应 :class:Word(token, pos)。

    class Word(object):    
        def __init__(self, token, pos):
            self.token = token
            self.pos = pos 
                           
                           
    class Tagger:          
        def __init__(self, dict_paths):
            # TODO 加载外部词典
            for p in dict_paths:
                jieba.load_userdict(p)
                           
        def get_word_objects(self, sentence):
            """ Get :class:WOrd(token, pos) """            
            return [Word(word.encode('utf-8'), tag) for word, tag in pseg.cut(sentence)]
    

    2.2 模块二 rules 部分

    该部分为程序核心,负责将自然语言转换为SPARQL模板。

    下面为rules的程序入口,customize_rules 函数:

    def customize_rules():
        # some rules for matching
        # TODO: customize your own rules here
        person = (W(pos="nr") | W(pos="x") | W(pos="nrt"))
        movie = (W(pos="nz"))
        place = (W("出生地") | W("出生"))
        intro = (W("简介") | W(pos="介绍"))
                                    
        rules = [      
                                    
            Rule(condition=W(pos="r") + W("是") + person | \ 
                           person + W("是") + W(pos="r"),
                 action=who_is_question),
                                
            Rule(condition=person + Star(Any(), greedy=False) + place + Star(Any(), greedy=False),
                 action=where_is_from_question),
                                
            Rule(condition=movie + Star(Any(), greedy=False) + intro + Star(Any(), greedy=False) ,
                 action=movie_intro_question)
                                
        ]         
        return rules
    

    该函数中我们设置了一些简单的匹配规则,例如我们设置 ‘’’movie = (W(pos=”nz”))’’‘,即movie 的词性应该是nz。其中的W()是我们在继承REfO的Predicate方法的基础上扩展更新了match方法。您可以简单的把它理解为re中compile后的match,只不过多个W()间出现的顺序可以变化。这样通过多个定制的W()和Star(Any(), greedy=False)(相当于.*?)这种通配符的组合,我们就定义了一组匹配规则,当遇到符合该规则的句子时,就选取该规则后action对应的查询模板。

    例如当输入为“周星驰是谁”这样的问题时,会匹配到rules 中的 第一条规则。而后执行该规则后对应的action, who_is_question。而who_is_question对应的查询模板为:

    def who_is_question(x):
        select = u"?x0"               
             
        sparql = None
        for w in x:
            if w.pos == "nr" or w.pos == "x":
                e = u" ?a :actor_chName '{person}'. \n \ ?a :actor_bio ?x0".format(person=w.token.decode("utf-8"))
             
                sparql = SPARQL_TEM.format(preamble=SPARQL_PREAMBLE,
                                           select=select,
                                           expression=INDENT + e)
                break
        return sparql
    

    有了查询模板后,我们通过SPARQLWrapper 模块的SPARQLWrapper 执行该查询,并对返回的结果进行转换得到回答。对应的代码如下:

    from SPARQLWrapper import SPARQLWrapper, JSON    
    from utils.word_tagging import Tagger
    from utils.rules import customize_rules                   
                     
    if __name__ == "__main__":    
        print("init...........")    
        sparql_base = SPARQLWrapper("http://localhost:3030/kg_demo_movie/query")
        #加载外部词典,提升分词准确性和词性标注准确性
        tagger = Tagger(['data/actorName.txt', 'data/movieName.txt'])
        #初始化并获取规则列表
        rules = customize_rules()   
        print("done \n")    
                     
        while True:    
            print("Please input your question: ")    
            default_question = raw_input()    
            # 获取wordclass
            seg_list = tagger.get_word_objects(default_question)
                     
            for rule in rules:    
                # 将规则列表应用到问题上得到查询模板
                query = rule.apply(seg_list)    
                if query:    
                    # 设置查询相关
                    sparql_base.setQuery(query)    
                    sparql_base.setReturnFormat(JSON)         
                    # 得到返回结果并做转换
                    results = sparql_base.query().convert()   
                     
                    if not results["results"]["bindings"]:    
                        print("No answer found :(")    
                        continue    
                    for result in results["results"]["bindings"]:
                        print "Result: ", result["x0"]["value"]
    
    展开全文
  • 知识图谱构建7——基于REFO的简单知识问答 实例结构: 利用get_dict.sh脚本将数据库电影名和演员名抽取出来,生成字典文件,用于扩展jieba分词,脚本一些命令可以参考: shell教程: ...

    知识图谱构建7——基于REFO的简单知识问答(KBQA)

    实例结构:
    在这里插入图片描述

    #!/bin/bash
    #连接MySQL数据库
    Host=127.0.0.1(或者数据库服务器地址)
    User=root
    PW=数据库密码
    
    #本地连接
    mysql -u$User -p$PW <<EOF #开始SQL语句
    use kg_movie;#选择数据库(选择模式)
    #show tables;#执行SQL语句
    select actor_chName from actor into outfile 'C:/ProgramData/MySQL/MySQL Server 5.7/Uploads/actor_Name.txt';
    select movie_chName from movie into outfile 'C:/ProgramData/MySQL/MySQL Server 5.7/Uploads/movie_Name.txt';
    EOF #结束SQL语句
    
    # Append "nz" and "nr" tag for jieba
    # nr代表演员名
    # nz代表电影名称
    awk '{print $0 " nr"}' actor_Name.txt > actorName.txt
    awk '{print $0 " nz"}' movie_Name.txt > movieName.txt
    
    # 移动文件夹到G:\PyCharmWP\kgMovie\KBQA\patternREFO\data
    mv actorName.txt G:/PyCharmWP/kgMovie/KBQA/patternREFO/data/
    mv movieName.txt G:/PyCharmWP/kgMovie/KBQA/patternREFO/data/
    
    # Remove redundant file,actor_Name.txt and  movieName.txt
    rm *_Name.txt
    
    # 注:将get_dict.sh 放到C:/ProgramData/MySQL/MySQL Server 5.7/Uploads目录下运行
    

    将数据库中的字段数据导出时出现如下secure-file-priv选项问题:

    ERROR 1290 (HY000) at line 4: The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
    

    参考:mysql5.7导出数据提示–secure-file-priv选项问题的解决方法
    https://blog.csdn.net/fdipzone/article/details/78634992

    # encoding=utf-8
    
    import jieba
    import jieba.posseg as pseg
    
    
    class Word(object):
        def __init__(self, token, pos):
            self.token = token
            self.pos = pos
    
    
    class Tagger:
        def __init__(self, dict_paths):
            # TODO 加载外部词典
            for p in dict_paths:
                jieba.load_userdict(p)
    
        @staticmethod
        def get_word_objects(sentence):
            # type: (str) -> list
            """
            把自然语言转为Word对象
            :param sentence:
            :return:
            """
            return [Word(word.encode('utf-8'), tag) for word, tag in pseg.cut(sentence)]
    
    # TODO 用于测试
    
    
    if __name__ == '__main__':
        tagger = Tagger(['../data/actorName.txt', '../data/movieName.txt'])
        while True:
            print("请输入:")
            s = input()
            p = tagger.get_word_objects(s)
            # print(p)
            for i in tagger.get_word_objects(s):
                print(i.token.decode('utf8'), i.pos)
    # 测试结果:
    # 请输入:
    # 周星驰是谁
    # 周星驰 nr
    # 是 v
    # 谁 r
    
    • 将自然语言转换为SPARQL模板
      rules.py:
    #!/usr/bin/env python
    # coding=utf-8
    # 设置问题模板,为每个模板设置对应的SPARQL语句
    import re
    
    # SPARQL config
    from refo.refo import Predicate, finditer, Star, Any
    
    SPARQL_PREAMBLE = u"""  
    PREFIX : <http://www.kg_movie.com#>
    PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
    """
    
    SPARQL_TEM = u"{preamble}\n" + \
                 u"SELECT DISTINCT {select} WHERE {{\n" + \
                 u"{expression}\n" + \
                 u"}}\n"
    
    INDENT = "    "
    
    
    class W(Predicate):
        """object-oriented regex for words"""
    
        def __init__(self, token=".*", pos=".*"):
            self.token = re.compile(token + "$")
            self.pos = re.compile(pos + "$")
            super(W, self).__init__(self.match)
    
        def match(self, word):
            # m1要将字节转化为字符串
            m1 = self.token.match(word.token.decode('utf-8'))
            m2 = self.pos.match(word.pos)
            return m1 and m2
    
    
    class Rule(object):
        def __init__(self, condition=None, action=None):
            assert condition and action
            self.condition = condition
            self.action = action
    
        def apply(self, sentence):
            matches = []
            for m in finditer(self.condition, sentence):
                i, j = m.span()
                matches.extend(sentence[i:j])
            if __name__ == '__main__':
                pass
            return self.action(matches)
    
    
    # 某人是谁的问题
    def who_is_question(x):
        select = u"?x0"
    
        sparql = None
        for w in x:
            if w.pos == "nr" or w.pos == "x":
                e = u" ?a :actor_chName '{person}'. \n \
                ?a :actor_bio ?x0".format(person=w.token.decode("utf-8"))
    
                sparql = SPARQL_TEM.format(preamble=SPARQL_PREAMBLE,
                                           select=select,
                                           expression=INDENT + e)
                break
        return sparql
    
    
    # 某人来自哪里的问题
    def where_is_from_question(x):
        select = u"?x0"
    
        sparql = None
        for w in x:
            if w.pos == "nr" or w.pos == "x" or w.pos == "nrt":
                e = u" ?a :actor_chName '{person}'.\n \
                ?a :actor_birthPlace ?x0".format(person=w.token.decode("utf-8"))
    
                sparql = SPARQL_TEM.format(preamble=SPARQL_PREAMBLE,
                                           select=select,
                                           expression=INDENT + e)
                break
        return sparql
    
    
    # 某个电影简介的问题
    def movie_intro_question(x):
        select = u"?x0"
    
        sparql = None
        for w in x:
            if w.pos == "nz":
                e = u" ?a :movie_chName '{person}'. \n \
                ?a :movie_bio ?x0".format(person=w.token.decode("utf-8"))
    
                sparql = SPARQL_TEM.format(preamble=SPARQL_PREAMBLE,
                                           select=select,
                                           expression=INDENT + e)
                break
        return sparql
    
    
    def customize_rules():
        # some rules for matching
        # TODO: customize your own rules here
        person = (W(pos="nr") | W(pos="x") | W(pos="nrt") | W(pos="nz"))
        movie = (W(pos="nz"))
        place = (W("出生地") | W("出生"))
        intro = (W("简介") | W(pos="介绍"))
    
        rules = [
    
            Rule(condition=W(pos="r") + W("是") + person | \
                           person + W("是") + W(pos="r"),
                 action=who_is_question),
    
            Rule(condition=person + Star(Any(), greedy=False) + place + Star(Any(), greedy=False),
                 action=where_is_from_question),
    
            Rule(condition=movie + Star(Any(), greedy=False) + intro + Star(Any(), greedy=False),
                 action=movie_intro_question)
    
        ]
        return rules
    
    #!/usr/bin/env python
    # coding=utf-8
    
    from SPARQLWrapper import SPARQLWrapper, JSON
    
    from kgMovie.KBQA.patternREFO.utils.rules import customize_rules
    from kgMovie.KBQA.patternREFO.utils.word_tagging import Tagger
    
    if __name__ == "__main__":
        print("init...........")
        # 连接TDB数据库
        sparql_base = SPARQLWrapper("http://localhost:3030/kg_movie/query")
        # 加载外部词典
        tagger = Tagger(['data/actorName.txt', 'data/movieName.txt'])
        # 初始化并获取规则列表
        rules = customize_rules()
        print("done \n")
    
        while True:
            # 输入问题
            print("Please input your question: ")
            default_question = input()
            # 获取wordclass
            seg_list = tagger.get_word_objects(default_question)
            for rule in rules:
                # 将规则列表应用到问题上得到查询模板
                query = rule.apply(seg_list)
                if query:
                    # 设置查询相关
                    sparql_base.setQuery(query)
                    sparql_base.setReturnFormat(JSON)
                    # 得到返回结果并做转换
                    results = sparql_base.query().convert()
    
                    if not results["results"]["bindings"]:
                        print("No answer found :(")
                        continue
                    for result in results["results"]["bindings"]:
                        print("Result: ", result["x0"]["value"])
    
    

    在运行query.py:前,应按照前面的教程将电影类知识图谱导入到Jena的TDB数据库中,并运行fuseki服务器,这样我们才能进行访问查询。
    具体可见:知识图谱构建5——Jena 和 Fuseki安装与SPARQL查询

    python setup.py install
    

    在这里插入图片描述

    展开全文
  • MSP430 5x6x系列内部校准的低频REFO可用于成本敏感的应用场合,可以省去外部晶体。REFO内部校准为32.768kHz,可提供一个稳定的参考频率。 REFO可作为FLL的频率输入源使用。REFO与FLL相结合,提供了一个灵活的系统...

    MSP430 5x6x系列内部校准的低频REFO可用于成本敏感的应用场合,可以省去外部晶体。REFO内部校准为32.768kHz,可提供一个稳定的参考频率。

    REFO可作为FLL的频率输入源使用。REFO与FLL相结合,提供了一个灵活的系统时钟设置范围,而不需要晶体。REFO不使用时不消耗电力。

    本实例示范如何使用REFO,并将其作为ACLK SMLK MCLK时钟来使用,通过将此三个时钟输出到特定的管脚,便于示波器测量验证。

    工程介绍:

    MCU型号: MSP430F6736A

    编译平台: IAR for MSP430 6.40.1

    实验项目: 测试 MCU 内部时钟 REFOCLK ,选择 REFOCLK 作为 ACLK SMCLK MCLK,并将 ACLK SMCLK MCLK 输出到外部管脚, 以方便测试验证

    #include "msp430.h"
    #include "msp430f6736a.h"
    
    #define DELAY_1s __delay_cycles(32768) 
    /* 延时1秒: 延时32768个MCLK时钟周期,因为MCLK=REFOCLK=32.768kHz */
    
    void main(void)
    
    {
        WDTCTL = WDTPW + WDTHOLD; /* 禁止看门狗 */
        __bic_SR_register(GIE);   /* 禁止所有中断 */
    
        /* 选择 REFO作为 ACLK, SMCLK, MCLK */
        UCSCTL4 = SELA__REFOCLK | SELS__REFOCLK | SELM__REFOCLK;
    
        /****************************
        * 管脚96 : PJ.0 | SMCLK | TDO 包含 SMCLK 外围模块功能
        * 管脚97 : PJ.1 | MCLK | TDI | TCLK 包含 MCLK 外围模块功能
        * 管脚99 : PJ.3 | ACLK | TCK 包含 ACLK 外围模块功能
        * 所以将 PORT J.0 J.1 J.3 的功能选择: 外围模块功能, 所以就可以输出对应的时钟信号
        * PJ.0 功能选择: SMCLK
        * PJ.1 功能选择: MCLK
        * PJ.3 功能选择: ACLK
        *****************************/
        PJSEL = BIT3 | BIT1 | BIT0;
    
        PJDIR = 0xff; /* PJ输出模式 */
        PJOUT = 0xff; /* PJ输出0xff */
    
        /* PORT 3 : P3.7 P3.6 P3.5 P3.4用作流水灯输出, 管脚功能:I/O 模式:输出 */
        P3SEL = 0;
        P3DIR = 0xf0;
        P3OUT = 0xf0;
    
        /* 流水灯循环间隔时间=1s, 用来指示程序运行状态 */
        char LampValue;
        LampValue = 0x10;
    
        while(1)
        {
            P3OUT = ~LampValue;
            LampValue = LampValue<<1;
    
            if (LampValue == 0x00) LampValue = 0x10;
    
            DELAY_1s;
        }
    }

     

    展开全文
  • 1、利用结巴分词对中文句子进行分词,词性标注(词性标注使用的词性兼容了ICTCLAS汉语词性标准) ...3、利用REfo模块对词进行对象级别(object-level)的正则匹配,判断问题属于3中类型中的哪一种...
  • COVID-19知识图谱问答系统(基于REFO

    千次阅读 热门讨论 2020-04-28 09:50:08
    本文共669个字,预计阅读时间需要3分钟。 简介 基于知识图谱的问答系统,即KBQA。其中一个简单的实现方法是根据用户输入的自然语言问句,转化为图数据库中的关系查询,...refo jiaba 实例数据 此知识图谱的主题为C...
  • 5、确保数据导入成功,并且检查推理机是否生效 6、 使用 REfO 进行查询 6.1:由于作者提供的py文件是基于python2写的,对中文的支持不是很好,所以基于python3进行修改,并把相关内容的查询都改成中文 6.2: 一些...
  • 当MSP430 5xx/6xx 系列外部接入32768Hz的低频晶振时,满足不了需要高速运行的应用。所以需要通过MCU内部的DCO(数字控制振荡器)和FLL(锁相环)将低速时钟32768Hz进行倍频,达到需要的目标频率。 ...
  • 锁相环 (phase-locked loop)为无线电发射中使频率较为稳定的一种方法,主要有VCO(压控振荡器)和PLL IC ,压控振荡器给出一个信号,一部分作为输出,另一部分通过分频与PLL IC所产生的本振信号作相位比较,为了保持频率...
  • 该KBQA系统可以解析输入的自然语言问句,主要运用REFO库的"对象正则表达式"匹配得到结果, 进而生成对应 SPARQL 查询语句,再通过API请求后台基于TDB知识图谱数据库的 Apache Jena Fuseki 服务, 得到结果。...
  • MSP430时钟定性分析

    2018-07-14 00:55:45
    MSP430时钟定性分析 1.时钟参数 1.1 宏定义时钟注释 ...//宏定义外接时钟,设置时钟很重要 #define EXTAL_IN_XT1_HZ ( 32768...//宏定义内部REFO,VLO时钟频率 #define VLOCLK_FREQUENCY ( 10000) #define REFOC...
  • 嵌入式编程:UART

    2020-11-25 19:52:25
    //8~16MHZ } //内部低功耗低频时钟 if(ClockSource == REFO) //内部低功耗低频时钟 { //设置时钟频率 MAP_CS_setReferenceOscillatorFrequency(CS_REFO_32KHZ); //低功耗模式 MAP_PCM_setPowerMode(PCM_LF_MODE); } ...
  • 内部有一个REFO参考时钟,频率是32768Hz,精度在5%左右,因此在一般使用情况下,内部REFO时钟就已经够用,无需接外部晶振。当然,如果连接外部晶振使用的话,精度会比内部时钟更高。 MSP430FR2311内部还集成了一...
  • 2.2 内部低频参考振荡器REFO REFO可用作没有振荡器的低成本应用。典型值32.768KHZ,用于稳定DCO频率。REFO结合FLL提供可变范围的系统时钟。不启用不消耗能量。 2.3 XT1振荡器 XT1振荡器支持低频模式(XTS=0)下...
  • MAP_CS_setReferenceOscillatorFrequency(CS_REFO_128KHZ); MAP_CS_initClockSignal(CS_MCLK, CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_1); MAP_CS_initClockSignal(CS_SMCLK, CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_2)...
  • 初学MSP430F5529时钟以及FLL配置

    千次阅读 2019-09-09 15:21:09
    // Set DCO FLL reference = REFO,选择REFO来作为参考 2、检测时钟源是否稳定 do { UCSCTL7 &= ~(XT2OFFG + XT1LFOFFG + DCOFFG); // Clear XT2,XT1,DCO fault flags SFRIFG1 &= ~OFIFG; // Clear fault ...
  • ROSIE:使用增量更新的SPARQL查询运行时优化,盖磊,陈薇,当前RDF数据管理中广泛使用了关系数据库,而对于SPARQL查询优化,传统的查询优化器需要重新考虑。其中一个重要问题就是,如何处理由易于
  • REFO  内部低频参照源, 32.768KHZ ,常被用作锁相环 FLL 的基准频率,精度很高,不使用时不消耗电源,其设置往往要参考 LPM 模式的的设置;  ⑤ DCO  ( Internal digitally-controlled )内部数字控制振荡源 ...
  • 浅谈msp430f5529入门(2)——时钟配置、例程分析

    万次阅读 多人点赞 2014-07-12 11:19:54
     18和19行,将这两个时钟的时钟源取为了REFO,这样,就没有任何时钟在向XT1请求时钟源,DCO也没有问题,故而下面的do{}while语句能通过。这个语句就是检测时钟有没有问题,如果晶体正在起振,还没有达到工作状态,...
  • void timer_count_Init(void) ... CS_setReferenceOscillatorFrequency(CS_REFO_128KHZ); CS_initClockSignal(CS_ACLK, CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_4);//分频 /* Configuring Continuous
  • python里使用正则的finditer()函数

    万次阅读 2017-10-07 12:41:05
    在前面学习了findall()函数,它可以一次性找到多个匹配的字符串,但是不能提供所在的位置,并且是一起返回的,如果有数万个一起返回来,就不太好处理了,因此要使用finditer()函数来实现每次只返回一个,并且返回...
  • 报错 import tensorflow as tf ModuleNotFoundError: No module named 'tensorflow' 版本错误 检查版本应该为3.7
  • 本文主要通过python实例讲解基于RDF和SPARQL的KBQA系统的构建。该项目可在python2和python3...该问答系统可以解析输入的自然语言问句,主要运用REFO库的"对象正则表达式"匹配得到结果, 进而生成对应 SPARQ...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 243
精华内容 97
关键字:

refo