- 浏览: 580068 次
- 性别:
- 来自: 广州
文章分类
- 全部博客 (338)
- 已过时文章(留念用) (39)
- Android学习笔记 (30)
- Android开发指引自译 (100)
- Android NDK文档自译 (23)
- Android设计指引自译 (2)
- xp(ペケピー)&linux(理奈、铃)酱~ (4)
- ui酱&歌词自译~ (9)
- lua酱~ (9)
- 自我反省 (1)
- 羽game计划 (1)
- XSL酱 (2)
- java酱 (3)
- 设计的领悟 (58)
- 涂鸦作品(pixiv) (1)
- ruby酱 (2)
- Objective-C编程语言自译 (2)
- Android开发月报 (6)
- objc酱 (2)
- photoshop (3)
- js酱 (6)
- cpp酱 (8)
- antlr酱 (7)
- Lua 5.1参考手册自译 (11)
- 收藏品 (3)
- 待宵草计划 (4)
- 体验版截图 (1)
最新评论
-
naruto60:
太给力了!!!!我这网打不开Intel官网,多亏楼主贴了连接, ...
使用HAXM加速的Android x86模拟器(和一些问题) -
yangyile2011:
谢谢博主,翻译得很好哦
【翻译】(4)片段 -
ggwang:
牙痛的彼岸:痹!
牙痛的彼岸 -
ggwang:
总结得很简练清晰啊,学习了!
ANTLR学习笔记一:概念理解 -
leisurelife1990:
mk sdd
用git下载Android自带app的源代码
【翻译】(LRM5.1-4)可见性规则(2.6)、错误处理(2.7)、元表(2.8)
See also:
http://www.lua.org/manual/5.1/manual.html
原文见
http://www.lua.org/manual/5.1/manual.html
-----------------------------------------
Lua 5.1 Reference Manual
Lua 5.1参考手册
by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
作者:Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
Copyright ? 2006-2008 Lua.org, PUC-Rio. Freely available under the terms of the Lua license.
版权所有 (c) 2006-2008 Lua.org, PUC-Rio. 根据Lua许可证自由地(注:免费)可用
-----------------------------------------
2.6 - Visibility Rules
2.6 - 可见性规则
Lua is a lexically scoped language. The scope of variables begins at the first statement after their declaration and lasts until the end of the innermost block that includes the declaration. Consider the following example:
Lua是一个词法上拥有作用域限制的语言。变量的作用域,开始于其声明后的第一个语句,直到包含声明的最内层block块的结束。考虑下面的例子:
x = 10 -- global variable
do -- new block
local x = x -- new 'x', with value 10
print(x) --> 10
x = x+1
do -- another block
local x = x+1 -- another 'x'
print(x) --> 12
end
print(x) --> 11
end
print(x) --> 10 (the global one)
(注:翻译如下:
x = 10 -- 全局变量
do -- 新的block块
local x = x -- 新变量'x', 值为10
print(x) --> 10
x = x+1
do -- 另一个block块
local x = x+1 -- 另一个变量 'x'
print(x) --> 12
end
print(x) --> 11
end
print(x) --> 10 (那个全局变量x)
)
Notice that, in a declaration like local x = x, the new x being declared is not in scope yet, and so the second x refers to the outside variable.
注意在像local x = x这样的声明中,被定义的新的x还不是在作用域内,所以第二个x引用的是外部变量。
Because of the lexical scoping rules, local variables can be freely accessed by functions defined inside their scope. A local variable used by an inner function is called an upvalue, or external local variable, inside the inner function.
因为词法上的作用域规则,局部变量可以被定义在它作用域内的函数自由访问。一个被内部函数使用的局部变量称为upvalue,或者称为内部函数内的外部(注:导入)局部变量。
Notice that each execution of a local statement defines new local variables. Consider the following example:
注意,每一个local语句的执行定义新的局部变量。考虑下面的例子:
a = {}
local x = 20
for i=1,10 do
local y = 0
a[i] = function () y=y+1; return x+y end
end
The loop creates ten closures (that is, ten instances of the anonymous function). Each of these closures uses a different y variable, while all of them share the same x.
循环创建了10个闭包(即10个匿名函数实例)。这个闭包每个都使用(注:引用)不同的y变量,但都共享(注:引用)相同的x。
2.7 - Error Handling
2.7 - 错误处理
Because Lua is an embedded extension language, all Lua actions start from C code in the host program calling a function from the Lua library (see lua_pcall). Whenever an error occurs during Lua compilation or execution, control returns to C, which can take appropriate measures (such as printing an error message).
因为Lua是一个嵌入的扩展语言,Lua的所有操作在宿主程序调用Lua库函数(见lua_pcall)的C代码处开始工作。每当在Lua编译或执行期间发生错误,控制将返回到C,进行适当的处理(如打印错误消息)。
Lua code can explicitly generate an error by calling the error function. If you need to catch errors in Lua, you can use the pcall function.
Lua代码可以显式地通过调用error函数产生错误。如果你需要在Lua代码中捕获错误,你可以使用pcall函数。
2.8 - Metatables
2.8 - 元表
Every value in Lua can have a metatable. This metatable is an ordinary Lua table that defines the behavior of the original value under certain special operations. You can change several aspects of the behavior of operations over a value by setting specific fields in its metatable. For instance, when a non-numeric value is the operand of an addition, Lua checks for a function in the field "__add" in its metatable. If it finds one, Lua calls this function to perform the addition.
Lua中每个值都可以有一个元表。这个元表是一个普通的Lua表,定义某些特定操作下原始值的行为。你可以通过把元表的特定字段设置为一个值来改变操作行为的某些角度(注:切面,相位)例如,当非数值的值是加法的操作数,Lua用它的元表的"__add"字段的函数检查。如果找到,Lua调用这个函数来执行加法。
We call the keys in a metatable events and the values metamethods. In the previous example, the event is "add" and the metamethod is the function that performs the addition.
我们调用在元表事件中和在值的元方法中的键。在前一个例子中,事件是"add"而元方法是执行加法的函数。
You can query the metatable of any value through the getmetatable function.
你可以通过getmetatable函数查询任意值的元表。
You can replace the metatable of tables through the setmetatable function. You cannot change the metatable of other types from Lua (except by using the debug library); you must use the C API for that.
你可以通过setmetatable函数替换表的元表。你不可以在Lua中改变其它类型的元表(除非使用debug库);你必须使用C API来完成。
Tables and full userdata have individual metatables (although multiple tables and userdata can share their metatables). Values of all other types share one single metatable per type; that is, there is one single metatable for all numbers, one for all strings, etc.
表和完全userdata拥有各自的元表(虽然多重表和userdata可以共享它们的元表)。其它所有类型的值对每个类型共享一个单独的元表;即所有数有一个单一元表,所有字符串有一个单一元表,等等。
A metatable controls how an object behaves in arithmetic operations, order comparisons, concatenation, length operation, and indexing. A metatable also can define a function to be called when a userdata is garbage collected. For each of these operations Lua associates a specific key called an event. When Lua performs one of these operations over a value, it checks whether this value has a metatable with the corresponding event. If so, the value associated with that key (the metamethod) controls how Lua will perform the operation.
元表控制一个对象在算术操作,书序比较,连接,长度操作和索引时的行为方式。元表还能定义一个函数,当一个userdata被垃圾回收时调用它。Lua把每个操作关联到一个特定的键,称为事件。当Lua用一个值来执行这些操作时,它会检查这个值是否有相应事件的元表。如果有,关联那个键的值(元方法)控制Lua执行该操作的方式。
Metatables control the operations listed next. Each operation is identified by its corresponding name. The key for each operation is a string with its name prefixed by two underscores, '__'; for instance, the key for operation "add" is the string "__add". The semantics of these operations is better explained by a Lua function describing how the interpreter executes the operation.
元表控制下面列举的操作。每个操作通过它相应的名字来标识。每个操作的键是一个带有双下划线'__'前缀的名称的字符串。例如,"add"操作的键是字符串"__add"。通过一个描述解释器如何执行操作的Lua函数可以更好地解释这些操作的语义。
The code shown here in Lua is only illustrative; the real behavior is hard coded in the interpreter and it is much more efficient than this simulation. All functions used in these descriptions (rawget, tonumber, etc.) are described in §5.1. In particular, to retrieve the metamethod of a given object, we use the expression
这里展示的Lua代码只是为了说明;真实的行为时被硬编码进解释器使之比这个模拟更为有效。这些描述中使用的所有函数(rawget,tonumber,等等)在§5.1中描述。特别地,为了获得给定对象的元方法,我们使用表达式
metatable(obj)[event]
This should be read as
这个表达式可以读作
rawget(getmetatable(obj) or {}, event)
That is, the access to a metamethod does not invoke other metamethods, and the access to objects with no metatables does not fail (it simply results in nil).
即对一个元方法的访问不会调用其它元方法,而对不带元表的对象的访问不会失败(只是简单地返回nil)。
"add": the + operation.
"add":加号操作。
The function getbinhandler below defines how Lua chooses a handler for a binary operation. First, Lua tries the first operand. If its type does not define a handler for the operation, then Lua tries the second operand.
下面的函数getbinhandler定义Lua如何为一个二元操作选择处理句柄。首先,Lua尝试第一个操作数。如果它的类型没有定义一个操作的处理句柄,那么Lua尝试第二操作数。
function getbinhandler (op1, op2, event)
return metatable(op1)[event] or metatable(op2)[event]
end
By using this function, the behavior of the op1 + op2 is
通过使用这个函数,op1 + op2的行为如下
function add_event (op1, op2)
local o1, o2 = tonumber(op1), tonumber(op2)
if o1 and o2 then -- both operands are numeric?
return o1 + o2 -- '+' here is the primitive 'add'
else -- at least one of the operands is not numeric
local h = getbinhandler(op1, op2, "__add")
if h then
-- call the handler with both operands
return (h(op1, op2))
else -- no handler available: default behavior
error(···)
end
end
end
(注:翻译如下:
function add_event (op1, op2)
local o1, o2 = tonumber(op1), tonumber(op2)
if o1 and o2 then -- 操作数都是数值吗?
return o1 + o2 -- 这里的'+'是原始的'add'
else -- 至少有一个操作数不是数值
local h = getbinhandler(op1, op2, "__add")
if h then
-- 用两个操作数调用处理句柄
return (h(op1, op2))
else -- 没有可用的处理句柄:默认行为
error(···)
end
end
end
)
"sub": the - operation. Behavior similar to the "add" operation.
"sub":减号操作。行为类似于"add"操作。
"mul": the * operation. Behavior similar to the "add" operation.
"mul":乘号操作。行为类似于"add"操作。
"div": the / operation. Behavior similar to the "add" operation.
"div":除号操作。行为类似于"add"操作。
"mod": the % operation. Behavior similar to the "add" operation, with the operation o1 - floor(o1/o2)*o2 as the primitive operation.
"mod":取模操作。行为类似于"add"操作,以操作o1 - floor(o1/o2)*o2作为原始操作。
"pow": the ^ (exponentiation) operation. Behavior similar to the "add" operation, with the function pow (from the C math library) as the primitive operation.
"pow":乘幂(指数)操作。 行为类似于"add"操作,以函数pow(出自C的数学库)作为原始操作。
"unm": the unary - operation.
"unm":一元负号操作.
function unm_event (op)
local o = tonumber(op)
if o then -- operand is numeric?
return -o -- '-' here is the primitive 'unm'
else -- the operand is not numeric.
-- Try to get a handler from the operand
local h = metatable(op).__unm
if h then
-- call the handler with the operand
return (h(op))
else -- no handler available: default behavior
error(···)
end
end
end
(注:翻译如下:
function unm_event (op)
local o = tonumber(op)
if o then -- 操作数是数字吗?
return -o -- 这里的'-'是原始的'unm'
else -- 操作数不是数字
-- 尝试从操作数中获得一个处理句柄
local h = metatable(op).__unm
if h then
-- 用操作数调用处理句柄
return (h(op))
else -- 没有可用的句柄:默认行为
error(···)
end
end
end
)
"concat": the .. (concatenation) operation.
"concat": 双点号(拼接)操作.
function concat_event (op1, op2)
if (type(op1) == "string" or type(op1) == "number") and
(type(op2) == "string" or type(op2) == "number") then
return op1 .. op2 -- primitive string concatenation
else
local h = getbinhandler(op1, op2, "__concat")
if h then
return (h(op1, op2))
else
error(···)
end
end
end
(注:翻译如下:
function concat_event (op1, op2)
if (type(op1) == "string" or type(op1) == "number") and
(type(op2) == "string" or type(op2) == "number") then
return op1 .. op2 -- 原始字符串连接
else
local h = getbinhandler(op1, op2, "__concat")
if h then
return (h(op1, op2))
else
error(···)
end
end
end
)
"len": the # operation.
"len": 取长度操作。
function len_event (op)
if type(op) == "string" then
return strlen(op) -- primitive string length
elseif type(op) == "table" then
return #op -- primitive table length
else
local h = metatable(op).__len
if h then
-- call the handler with the operand
return (h(op))
else -- no handler available: default behavior
error(···)
end
end
end
(注:翻译如下:
function len_event (op)
if type(op) == "string" then
return strlen(op) -- 原始字符串长度
elseif type(op) == "table" then
return #op -- 原始表长度
else
local h = metatable(op).__len
if h then
-- 用操作数调用处理句柄
return (h(op))
else -- 没有可用的处理句柄:默认行为
error(···)
end
end
end
)
See §2.5.5 for a description of the length of a table.
见§2.5.5关于表长度的描述。
"eq": the == operation. The function getcomphandler defines how Lua chooses a metamethod for comparison operators. A metamethod only is selected when both objects being compared have the same type and the same metamethod for the selected operation.
"eq": 等号操作。函数getcomphandler定义Lua如何为比较操作符选择一个元方法。当相同类型的对象比较并且选择操作具有相同的元方法时才会选择那个元方法。
function getcomphandler (op1, op2, event)
if type(op1) ~= type(op2) then return nil end
local mm1 = metatable(op1)[event]
local mm2 = metatable(op2)[event]
if mm1 == mm2 then return mm1 else return nil end
end
The "eq" event is defined as follows:
"eq"事件定义如下:
function eq_event (op1, op2)
if type(op1) ~= type(op2) then -- different types?
return false -- different objects
end
if op1 == op2 then -- primitive equal?
return true -- objects are equal
end
-- try metamethod
local h = getcomphandler(op1, op2, "__eq")
if h then
return (h(op1, op2))
else
return false
end
end
(注意:翻译如下:
function eq_event (op1, op2)
if type(op1) ~= type(op2) then -- 是不同类型吗?
return false -- 不同的对象
end
if op1 == op2 then -- 是原始相等吗?
return true -- 对象相等
end
-- 尝试元方法
local h = getcomphandler(op1, op2, "__eq")
if h then
return (h(op1, op2))
else
return false
end
end
)
a ~= b is equivalent to not (a == b).
a ~= b 等效于not (a == b).
"lt": the < operation.
"lt": 小于操作。
function lt_event (op1, op2)
if type(op1) == "number" and type(op2) == "number" then
return op1 < op2 -- numeric comparison
elseif type(op1) == "string" and type(op2) == "string" then
return op1 < op2 -- lexicographic comparison
else
local h = getcomphandler(op1, op2, "__lt")
if h then
return (h(op1, op2))
else
error(···)
end
end
end
(注:翻译如下:
function lt_event (op1, op2)
if type(op1) == "number" and type(op2) == "number" then
return op1 < op2 -- 数值比较
elseif type(op1) == "string" and type(op2) == "string" then
return op1 < op2 -- 字典序比较
else
local h = getcomphandler(op1, op2, "__lt")
if h then
return (h(op1, op2))
else
error(···)
end
end
end
)
a > b is equivalent to b < a.
a > b等效于b < a.
"le": the <= operation.
"le": 小于等于操作。
function le_event (op1, op2)
if type(op1) == "number" and type(op2) == "number" then
return op1 <= op2 -- numeric comparison
elseif type(op1) == "string" and type(op2) == "string" then
return op1 <= op2 -- lexicographic comparison
else
local h = getcomphandler(op1, op2, "__le")
if h then
return (h(op1, op2))
else
h = getcomphandler(op1, op2, "__lt")
if h then
return not h(op2, op1)
else
error(···)
end
end
end
end
(注:翻译如下:
function le_event (op1, op2)
if type(op1) == "number" and type(op2) == "number" then
return op1 <= op2 -- 数值比较
elseif type(op1) == "string" and type(op2) == "string" then
return op1 <= op2 -- 字典序比较
else
local h = getcomphandler(op1, op2, "__le")
if h then
return (h(op1, op2))
else
h = getcomphandler(op1, op2, "__lt")
if h then
return not h(op2, op1)
else
error(···)
end
end
end
end
)
a >= b is equivalent to b <= a. Note that, in the absence of a "le" metamethod, Lua tries the "lt", assuming that a <= b is equivalent to not (b < a).
a >= b等效于b <= a。注意,缺少"le"元方法时, Lua尝试"lt",假设a <= b等效于not (b < a)。
"index": The indexing access table[key].
"index":当索引访问table[key]时被调用。
function gettable_event (table, key)
local h
if type(table) == "table" then
local v = rawget(table, key)
if v ~= nil then return v end
h = metatable(table).__index
if h == nil then return nil end
else
h = metatable(table).__index
if h == nil then
error(···)
end
end
if type(h) == "function" then
return (h(table, key)) -- call the handler
else return h[key] -- or repeat operation on it
end
end
(注:翻译如下:
function gettable_event (table, key)
local h
if type(table) == "table" then
local v = rawget(table, key)
if v ~= nil then return v end
h = metatable(table).__index
if h == nil then return nil end
else
h = metatable(table).__index
if h == nil then
error(···)
end
end
if type(h) == "function" then
return (h(table, key)) -- 调用处理句柄
else return h[key] -- 或者重复对它操作
end
end
)
"newindex": The indexing assignment table[key] = value.
"newindex":当索引赋值table[key] = value执行时调用。
function settable_event (table, key, value)
local h
if type(table) == "table" then
local v = rawget(table, key)
if v ~= nil then rawset(table, key, value); return end
h = metatable(table).__newindex
if h == nil then rawset(table, key, value); return end
else
h = metatable(table).__newindex
if h == nil then
error(···)
end
end
if type(h) == "function" then
h(table, key,value) -- call the handler
else h[key] = value -- or repeat operation on it
end
end
(注:翻译如下:
function settable_event (table, key, value)
local h
if type(table) == "table" then
local v = rawget(table, key)
if v ~= nil then rawset(table, key, value); return end
h = metatable(table).__newindex
if h == nil then rawset(table, key, value); return end
else
h = metatable(table).__newindex
if h == nil then
error(···)
end
end
if type(h) == "function" then
h(table, key,value) -- 调用处理句柄
else h[key] = value -- 或者重复对它操作
end
end
)
"call": called when Lua calls a value.
"call": 当Lua调用一个值时被调用。
function function_event (func, ...)
if type(func) == "function" then
return func(...) -- primitive call
else
local h = metatable(func).__call
if h then
return h(func, ...)
else
error(···)
end
end
end
(注:翻译如下:
function function_event (func, ...)
if type(func) == "function" then
return func(...) -- 原始调用
else
local h = metatable(func).__call
if h then
return h(func, ...)
else
error(···)
end
end
end
)
-----------------------------------------
参考自:
1. Lua 5.1 参考手册 (云风译)
http://www.codingnow.com/2000/download/lua_manual.html
2. hshqcn
http://hshqcn.iteye.com/blog/284901
(TODO:待修改)
发表评论
-
【翻译】(LRM5.1-11)协程操纵(5.2)、模块(5.3)
2012-07-17 00:09 1057【翻译】(LRM5.1-11)协程操纵(5.2)、模块( ... -
【翻译】(LRM5.1-10)标准库的基础函数(5.1)
2012-07-14 18:06 1074【翻译】(LRM5.1-10)标 ... -
【翻译】(LRM5.1-9)辅助库(4)
2012-07-09 21:19 1108【翻译】(LRM5.1-9)辅助库(4) See ... -
【翻译】(LRM5.1-8)调试接口(3.8)
2012-07-04 19:15 987【翻译】(LRM5.1-8)调试接口(3.8) ... -
【翻译】(LRM5.1-7)函数和类型(3.7)
2012-07-03 16:22 1233【翻译】(LRM5.1-7)函数和类型(3.7) ... -
【翻译】(LRM5.1-6)堆栈(3.1)、堆栈大小(3.2)、伪索引(3.3)、C闭包(3.4)、注册表(3.5)、C的错误处理(3.6)
2012-07-02 10:18 1168【翻译】(LRM5.1-6)堆栈(3.1)、堆栈大小(3 ... -
【翻译】(LRM5.1-5)环境(2.9)、垃圾回收(2.10)、协程(2.11)
2012-07-01 09:04 1119【翻译】(LRM5.1-5)环境(2.9)、垃圾回收(2 ... -
【翻译】(LRM5.1-3)表达式(2.5)
2012-06-30 09:22 990【翻译】(LRM5.1-3)表达式(2.5) S ... -
【翻译】(LRM5.1-2)语句(2.4)
2012-06-30 06:50 811【翻译】(LRM5.1-2)语句(2.4) Se ... -
【翻译】(LRM5.1-1)简介(1)、词法约定(2.1)、值与类型(2.2)、变量(2.3)
2012-06-29 21:03 1213【翻译】(LRM5.1-1)简介(1)、词法约定(2.1 ...
相关推荐
LRM连接器手册,欢迎查阅分享, LRM连接器手册,欢迎查阅分享, LRM连接器手册,欢迎查阅分享,
【10GBASE-LRM 光纤端口的互通性测试】 10GBASE-LRM是一种10 Gigabit Ethernet(10G以太网)的标准,根据IEEE Std. 802.3aq(tm)-2006制定,旨在提供在多模光纤上长达220米的数据传输能力。这个标准利用了电色散补偿...
This is the latest version of the IEEE Standard 1364-2005 Hardware Description Language - Verilog LRM.
这个标准是Verilog HDL的核心规范,也被称为Verilog LRM(Language Reference Manual)。在FPGA(Field-Programmable Gate Array)设计领域,Verilog被用来描述数字逻辑系统的结构和行为,为电路设计提供了抽象层次...
1800-2009 - IEEE Standard for SystemVerilog--Unified Hardware Design, Specification, and Verification Language (Active) IEEE标准1800-2009,是2009年发布的SystemVerilog语言标准。目前该标准的状态是...
oracle11g10g安装备份基础维护
使用lrm-mapzen时,Mapzen Turn-by-Turn替代了Leaflet Routing Machine中使用的默认路由服务。 您需要安装lrm-mapzen插件,并从获取API密钥。 开始使用lrm-mapzen 跟随一起使用lrm-mapzen构建地图。 并将对...
总的来说,IEEE 1364-2001 Verilog LRM是Verilog语言的重要里程碑,它的更新极大地提升了Verilog作为硬件描述语言的实用性和先进性,使其在现代电子设计自动化领域占据了核心地位。这个879页的文档详细阐述了这些新...
SystemVerilog语言标准还提供了与外部编程语言的接口API,这使得SystemVerilog能够利用其他编程语言的能力来实现复杂的验证算法和处理数据。通过编程语言接口(PLI),可以将SystemVerilog与如C、C++等语言进行交互,...
总的来说,SystemVerilog作为一种强大的硬件描述、规范和验证语言,其标准化过程得到了IEEE的权威认证,确保了其广泛的认可度和适用性。作为电子工程师,理解和掌握SystemVerilog的高级特性,如面向对象编程、随机...
5. **错误处理**:关于错误检测和处理的规则,包括异常处理和运行时检查。 通过这两本书,读者可以深入理解SystemC的基础概念,掌握其设计和仿真技巧,为硬件系统的早期原型设计和验证打下坚实基础。对于软件工程师...
"LRM"是“Language Reference Manual”的缩写,它提供了Verilog语言的官方规范和详细解释。《Verilog-AMS Language Reference Manual》特别提到了版本2.4.0,日期为2014年5月30日,这意味着它涵盖了Verilog-AMS,即...
IEEE Std 1364-2005标准的修订版不仅包含了上述的基本特性,还可能包含对2001年版本的改进和扩展,比如更明确的语法规定、增强的错误处理机制、对现代设计流程的支持等。这个标准的发布对于工具开发者和高级用户来说...
在IT行业中,车载LRM(Logical Resource Manager,逻辑资源管理器)模块化集成平台是针对特殊应用场景,如工业自动化、交通监控、军事通信等,设计的一种高性能、高可靠性的硬件解决方案。这类平台通常具备强大的抗...
LRM集成安装风冷机架使用说明书分享.pdf
Allegro Cadence 常用PCB封装库。1、常用的PCB封装库文件,里面的.dra文件可以用PCB Editor打开。2、常用的直插元件、贴片元件、BGA封装、LQFP封装都有。3、文件解压后为208MB。
- **数字系统**:指由数字电路构成的系统,如微处理器、数字信号处理器等。 - **电子系统**:更广泛的概念,包括但不限于数字系统,也涵盖模拟电路和混合信号系统。 - **硬件描述语言 (HDL)**:专门用于描述电子系统...
文件信息来源于《MPC5643LRM.pdf》这份文档,该文档是一本微控制器手册,专门介绍MPC5643L微控制器的相关信息。 知识点详细说明如下: ### 微控制器概述 - **微控制器型号**:MPC5643L,这是文档所描述的微控制器...
4. **关闭所有Oracle服务进程**:停止所有与Oracle相关的服务,包括数据库实例、监听器和后台进程,以防止升级过程中发生冲突。 5. **确认显示终端**:确保终端设置正确,能够接收并显示升级过程中的所有输出信息。 ...
在电子行业中,LRM(Load, Release, Mount)振动试验是一种重要的可靠性测试方法,用于评估电子模块集成安装架在实际工作环境中的耐受性。这种试验通常涉及到将电子设备暴露于模拟的振动环境中,以检验其结构完整性...