Rust Language Cheat Sheet
06.08.2019
Contains clickable links to The Book BK, Rust by Example EX, Std Docs STD, Nomicon NOM, Reference REF. Other symbols used: largely deprecated 🗑, has a minimum edition ‘18, is work in progress 🚧, or bad 🛑.
Night Mode 💡
Language Constructs
- Data Structures
- References & Pointers
- Functions & Behavior
- Control Flow
- Organizing Code
- Type Aliases and Casts
- Code Generation
- Pattern Matching
- Generics & Constraints
- Strings & Chars
- Comments
- Miscellaneous
Guides
Misc
Hello, Rust!
If you have never seen Rust before, or if you want to try the things below:
fn main() {
println!("Hello, world!");
}
▶ Edit & Run
Data Structures
Data types and memory locations defined via keywords.
Example
Explanation
struct S {}
Define a struct BK EX STD REF with named fields.
struct S { x: T }
Define struct with named field x
of type T
.
struct S
(T)
Define “tupled” struct with numbered field .0
of type T
.
struct S;
Define zero sized unit struct.
enum E {}
Define an enum BK EX REF , c. algebraic data types, tagged unions.
enum E { A, B
(), C {} }
Define variants of enum; can be unit- A
, tuple- B
()
and struct-like C{}
.
enum E { A = 1 }
If variants are only unit-like, allow discriminant values, e.g., for FFI.
union U {}
Unsafe C-like union REF for FFI compatibility.
static X: T = T();
Global variable BK EX REF with 'static
lifetime, single memory location.
const X: T = T();
Defines constant, BK EX REF. Copied into a temporary when used.
let x: T;
Allocate T
bytes on stack bound as x
. Assignable once, not mutable.
let mut x: T;
Like let
, but allow for mutability and mutable borrow. *
x = y
Moves y
to x
, invalidating y
if T
is not Copy
, and copying y
otherwise.
- Note that technically mutable and immutable are a bit of a misnomer. Even if you have an immutable binding or shared reference, it might contain a Cell, which supports so called interior mutability.
Creating and accessing data structures; and some more sigilic types.
Example
Explanation
S { x: y }
Create struct S {}
or use
‘ed enum E::S {}
with field x
set to y
.
S { x }
Same, but use local variable x
for field x
.
S { ..s }
Fill remaining fields from s
, esp. useful with Default.
S { 0: x }
Like S
(x)
below, but set field .0
with struct syntax.
S
(x)
Create struct S
(T)
or use
‘ed enum E::S
()
with field .0
set to x
.
S
If S
is unit struct S;
or use
‘ed enum E::S
create value of S
.
E::C { x: y }
Create enum variant C
. Other methods above also work.
()
Empty tuple, both literal and type, aka unit STD
(x)
Parenthesized expression.
(x,)
Single-element tuple expression. EX STD REF
(S,)
Single-element tuple type.
[S]
Array type of unspecified length, i.e., slice. STD EX REF Can’t live on stack. *
[S; n]
Array type EX STD of fixed length n
holding elements of type S
.
[x; n]
Array instance with n
copies of x
. REF
[x, y]
Array instance with given elements x
and y
.
x[0]
Collection indexing. Overloadable Index, IndexMut
x[..]
Collection slice-like indexing via RangeFull, c. slices.
x[a..]
Collection slice-like indexing via RangeFrom.
x[..b]
Collection slice-like indexing RangeTo.
x[a..b]
Collection slice-like indexing via Range.
a..b
Right-exclusive range REF creation, also seen as ..b
.
a..=b
Inclusive range creation, also seen as ..=b
.
s.x
Named field access, REF might try to Deref if x
not part of type S
.
s.0
Numbered field access, used for tuple types S
(T)
.
- For now, see tracking issue and corresponding RFC 1909.
References & Pointers
Granting access to un-owned memory. Also see section on Generics & Constraints.
Example
Explanation
&S
Shared reference BK STD NOM REF (space for holding any &s
).
&[S]
Special slice reference that contains (address
, length
).
&str
Special string reference that contains (address
, length
).
&dyn S
Special trait object BK reference that contains (address
, vtable
).
&mut S
Exclusive reference to allow mutability (also &mut [S]
, &mut dyn S
, …)
*const S
Immutable raw pointer type BK STD REF w/o memory safety.
*mut S
Mutable raw pointer type w/o memory safety.
&s
Shared borrow BK EX STD (e.g., address, len, vtable, … of this s
, like 0x1234
).
&mut s
Exclusive borrow that allows mutability. EX
ref s
*r
Dereference BK STD NOM a reference r
to access what it points to.
*r = s
If r
is a mutable reference, move or copy s
to target memory.
s = *r
Make s
a copy of whatever r
references, if that is Copy
.
s = *my_box
Special case for Box
that can also move out Box’ed content if it isn’t Copy
.
'a
A lifetime parameter, BK EX NOM REF, duration of a flow in static analysis.
&'a S
Only accepts a s
with an address that lives 'a
or longer.
&'a mut S
Same, but allow content of address to be changed.
S<'a>
Signals S
will contain address with lifetime 'a
. Creator of S
decides 'a
.
fn f<'a>(t: &'a T)
Same, for function. Caller decides 'a
.
'static
Special lifetime lasting the entire program execution.
Functions & Behavior
Define units of code and their abstractions.
Sigil
Explanation
trait T {}
trait T : R {}
T
is subtrait of supertrait REF R
. Any S
must impl R
before it can impl T
.
impl S {}
Implementation REF of functionality for a type S
.
impl T for S {}
Implement trait T
for type S
.
impl !T for S {}
Disable an automatically derived auto trait NOM REF.
fn f() {}
Definition of a function BK EX REF; or associated function if inside impl
.
fn f() -> S {}
Same, returning a value of type S.
fn f(&self) {}
Define a method as part of an impl
.
const fn f() {}
Constant fn
usable at compile time, e.g., const X: u32 = f(Y)
. ‘18
async fn f() {}
Async 🚧 ‘18 function transformation, makes f
return an impl Future
. STD
async fn f() -> S {}
The call f()
returns an impl Future<Output=S>
, does not execute f
!
async {}
Block async { x }
transforms last expression x
into Future<Output=X>
.
fn() -> S
Function pointers, BK STD REF don’t confuse with trait Fn.
|| {}
A closure BK EX REF that borrows its captures.
|x| {}
Closure with a bound parameter x
.
|x| x + x
Closure without block expression.
move |x| x + y
Closure taking ownership of its captures.
return || true
Closures may sometimes look like logical ORs (here: return a closure).
f()
Invoke callable f
(e.g., a function, closure, function pointer, Fn
, …).
x.f()
Call member function, requires f
takes self
, &self
, … as first argument.
X::f(x)
Same as x.f()
. Unless impl Copy for X {}
, f
can only be called once.
X::f(&x)
Same as x.f()
.
X::f(&mut x)
Same as x.f()
.
S::f(&x)
Same as x.f()
if X
derefs to S
(i.e., x.f()
finds methods of S
).
T::f(&x)
Same as x.f()
if X impl T
(i.e., x.f()
finds methods of T
if in scope).
X::f()
Call associated function, e.g., X::new()
.
<X as T>::f()
Call trait method T::f()
implemented for X
.
unsafe {}
If you need to crash your code in production; unsafe code. BK EX NOM REF
Control Flow
Control execution within a function.
Sigil
Explanation
while x {}
Loop REF, run while expression x
is true.
loop {}
Loop infinitely REF until break
. Can yield value with break x
.
for x in iter {}
Syntactic sugar to loop over iterators. BK STD REF
if x {} else {}
Conditional branch REF if expression is true.
'label: loop {}
Loop label EX REF, useful for flow control in nested loops.
break
Break expression REF to exit a loop.
break x
Same, but make x
value of the loop expression (only in actual loop
).
break 'label
Exit not only this loop, but the enclosing one marked with 'label
.
continue
Continue expression REF to the next loop iteration of this loop.
continue 'label
Same, but instead of enclosing loop marked with 'label
.
x.await
Only works inside async
. Yield flow until Future or Stream ? x
ready. 🚧 ‘18
return x
Early return from function. More idiomatic way is to end with expression.
x?
If x
is Err or None, return and propagate. BK EX STD REF
Organizing Code
Segment projects into smaller units and minimize dependencies.
Sigil
Explanation
mod m {}
Define a module BK EX REF, get definition from inside {}
.
mod m;
Define a module, get definition from m.rs
or m/mod.rs
.
a::b
Namespace path EX REF to element b
within a
(mod
, enum
, …).
::b
Search b
relative to crate root. 🗑
crate::b
Search b
relative to crate root. ‘18
self::b
Search b
relative to current module.
super::b
Search b
relative to parent module.
use a::b;
Use EX REF b
directly in this scope without requiring a
anymore.
use a::{b, c};
Same, but bring b
and c
into scope.
use a::b as x;
Bring b
into scope but name x
, like use std::error::Error as E
.
use a::b as _;
Bring b
anonymously into scope, useful for traits with conflicting names.
use a::*;
Bring everything from a
into scope.
pub use a::b;
Bring a::b
into scope and reexport from here.
pub T
“Public if parent path is public” visibility BK for T
.
pub(crate) T
Visible at most in current crate.
pub(self) T
Visible at most in current module.
pub(super) T
Visible at most in parent.
pub(in a::b) T
Visible at most in a::b
.
extern crate a
;
Declare dependency on external crate BK EX REF 🗑 ; just use a::b
in ‘18.
extern "C" fn
External dependency for FFI. BK EX NOM REF
Type Aliases and Casts
Short-hand names of types, and methods to convert one type to another.
Sigil
Explanation
type T = S;
Create a type alias BK REF, i.e., another name for S
.
Self
Type alias for implementing type REF, e.g. fn new() -> Self
.
self
Method subject in fn f(self) {}
, same as fn f(self: Self) {}
.
&self
Same, but refers to self as borrowed, same as f(self: &Self)
&mut self
Same, but mutably borrowed, same as f(self: &mut Self)
self: Box<Self>
Arbitrary self type, add methods to smart pointers (my_box.f_of_self()
).
S as T
Disambiguate BK REF type S
as trait T
, e.g., <X as T>::f()
.
S as R
In use
of symbol, import S
as R
, e.g., use a::b as x
.
x as u32
Primitive cast EX REF, may truncate and be a bit surprising. NOM
Code Generation
Constructs expanded before the actual compilation happens.
Example
Explanation
m!()
Macro BK STD REF invocation, also m!{}
, m![]
(depending on macro).
$x:ty
Macro capture, also $x:expr
, $x:ty
, $x:path
, … see next table.
$x
Macro substitution in macros by example. BK EX REF
$(x),*
Macro repetition “zero or more times” in macros by example.
$(x),?
Same, but “zero or one time”.
$(x),+
Same, but “one or more times”.
$(x)<<+
In fact separators other than ,
are also accepted. Here: <<
.
$crate
Special hygiene variable, crate where macros is defined. ?
#[attr]
Outer attribute. EX REF, annotating the following item.
#![attr]
Inner attribute, annotating the surrounding item.
In a macro_rules!
implementation, the following macro captures can be used:
Macro Capture
Explanation
$x:item
An item, like a function, struct, module, etc.
$x:block
A block {}
of statements or expressions, e.g., { let x = 5; }
$x:stmt
A statement, e.g., let x = 1 + 1;
, String::new();
or vec![];
$x:expr
An expression, e.g., x
, 1 + 1
, String::new()
or vec![]
$x:pat
A pattern, e.g., Some(t)
, (17, 'a')
or _
.
$x:ty
A type, e.g., String
, usize
or Vec<u8>
.
$x:ident
An identifier, for example in let x = 0;
the identifier is x
.
$x:path
A path (e.g. foo
, ::std::mem::replace
, transmute::<_, int>
, …).
$x:literal
A literal (e.g. 3
, "foo"
, b"bar"
, etc.).
$x:meta
A meta item; the things that go inside #[...]
and #![...]
attributes.
$x:tt
A single token tree, see here for more details.
Pattern Matching
Constructs found in match
or let
expressions, or function parameters.
Example
Explanation
match m {}
Initiate pattern matching BK EX REF, then use match arms, c. next table.
let Some(x) = Some(5)
Notably, let
also pattern matches similar to the table below.
let S { x } = s
Only x
will be bound to value s.x
.
let (_, b, _) = abc
Only b
will be bound to value abc.1
.
let (a, ..) = abc
Ignoring ‘the rest’ also works.
let Some(x) = get()
Will not work 🛑 if pattern can be refuted REF, use if let
instead.
if let Some(x) = get()
Branch if pattern can actually be assigned (e.g., enum
variant).
fn f(S { x }: S)
Function parameters also work like let
, here x
bound to s.x
of f(s)
.
Pattern matching arms in match
expressions. The left side of these arms can also be found in let
expressions.
Example
Explanation
E::A => {}
Match enum variant A
, c. pattern matching. BK EX REF
E::B ( .. ) => {}
Match enum tuple variant B
, wildcard any index.
E::C { .. } => {}
Match enum struct variant C
, wildcard any field.
S { x: 0, y: 1 } => {}
Match struct with specific params.
S { x, y } => {}
Match struct with any values, bind respective fields as variables x
and y
.
S { .. } => {}
Match struct with any values.
D => {}
Match enum variant E::D
if D
in use
.
D => {}
Match anything, bind D
; possibly false friend 🛑 of E::D
if D
not in use
.
_ => {}
Proper wildcard that matches anything / “all the rest”.
[a, 0] => {}
Match array with any value for a
and 0
for second.
(a, 0) => {}
Match tuple with any value for a
and 0
for second.
x @ 1..=5 => {}
Bind matched to x
; pattern binding BK EX.
0 | 1 => {}
Pattern alternatives (or-patterns).
E::A | E::Z
Same, but on enum variants.
E::C {x} | E::D {x}
Same, but bind x
if all variants have it.
S { x } if x > 10
Generics & Constraints
Generics combine with many other constructs such as struct S<T>
, fn f<T>()
, …
Example
Explanation
S<T>
A generic BK EX type with a type parameter (T
is placeholder name here).
S<T: R>
Type short hand trait bound BK EX specification (R
must be actual trait).
T: R, P: S
Independent trait bounds (here one for T
and one for P
).
T: R, S
Compile error 🛑, you probably want compound bound R + S
below.
T: R + S
Compound trait bound BK EX, T
must fulfill R
and S
.
T: R + 'a
Same, but w. lifetime. T
must fulfill R
, if T
has lifetimes, must outlive 'a
.
T: ?Sized
Opt out of a pre-defined trait bound, here Sized
. ?
T: 'a
Type lifetime bound EX; if T has references, they must outlive 'a
.
'b: 'a
Lifetime 'b
must live at least as long as (i.e., outlive) 'a
bound.
S<T> where T: R
Same as S<T: R>
but more pleasant to read for longer bounds.
S<T = R>
Default type parameter BK for associated type.
S<'_>
Inferred anonymous lifetime.
S<_>
Inferred anonymous type, e.g., as let x: Vec<_> = iter.collect()
S::<T>
Turbofish STD call site type disambiguation, e.g. f::<u32>()
.
trait T<X> {}
A trait generic over X
. Can have multiple impl T for S
(one per X
).
trait T { type X; }
Defines associated type BK REF X
. Only one impl T for S
possible.
type X = R;
Set associated type within impl T for S { type X = R; }
.
impl<T> S<T> {}
Implement functionality for any T
in S<T>
.
impl S<T> {}
Implement functionality for exactly S<T>
(e.g., S<u32>
).
fn f() -> impl T
Existential types BK, returns an unknown-to-caller S
that impl T
.
fn f(x: &impl T)
Trait bound,”impl traits” BK, somewhat similar to fn f<S:T>(x: &S)
.
fn f(x: &dyn T)
Marker for dynamic dispatch BK REF, f
will not be monomorphized.
fn f() where Self: R
In a trait T {}
, mark f
as accessible only on types that also impl R
.
for<'a>
Higher-rank trait bounds. NOM REF
Strings & Chars
Rust has several ways to create string or char literals, depending on your needs.
Example
Explanation
"..."
String literal REF, will escape \n
, …
r"..."
,
Raw string literal. REF, won’t escape \n
, …
r#"..."#
, etc.
Raw string literal, but can also contain "
.
b"..."
Byte string literal REF; constructs ASCII [u8]
, not a string.
br"..."
, br#"..."#
, etc.
Raw byte string literal, combination of the above.
'🦀'
Character literal REF, can contain unicode.
b'x'
ASCII byte literal. REF
Comments
No comment.
Example
Explanation
//
Line comment, use these to document code flow or internals.
//!
Inner line doc comment BK EX REF for auto generated documentation.
///
Outer line doc comment, use these on types.
/*...*/
Block comment.
/*!...*/
Inner block doc comment.
/**...*/
Outer block doc comment.
rust ...
In doc comments, include a doc test (doc code running on cargo test
).
#
In doc tests, hide line from documentation (# use x::hidden;
).
Miscellaneous
These sigils did not fit any other category but are good to know nonetheless.
Example
Explanation
!
Always empty never type. 🚧 BK EX STD REF
_
Unnamed variable binding, e.g., |x, _| {}
.
_x
Variable binding explicitly marked as unused.
1_234_567
Numeric separator for visual clarity.
1_u8
Type specifier for numeric literals EX REF (also i8
, u16
, …).
0xBEEF
, 0o777
, 0b1001
Hexadecimal (0x
), octal (0o
) and binary (0b
) integer literals.
r#foo
A raw identifier BK EX for edition compatibility.
x;
Statement REF terminator, c. expressions EX REF
Common Operators
Rust supports all common operators you would expect to find in a language (+
, *
, %
, =
, ==
…). Since they behave no differently in Rust we do not list them here. For some of them Rust also supports operator overloading. STD
Invisible Sugar
If something works that “shouldn’t work now that you think about it”, it might be due to one of these.
Name
Description
Coercions NOM
‘Weaken’ types to match signature, e.g., &mut T
to &T
.
Deref NOM
Deref x: T
until *x
, **x
, … compatible with some target S
.
Prelude STD
Automatic import of basic types.
Reborrow
Since x: &mut T
can’t be copied; move new &mut *x
instead.
Automatically annotate f(x: &T)
to f<'a>(x: &'a T)
.
Method Resolution REF
Deref or borrow x
until x.f()
works.
Closures
There is a subtrait relationship Fn
: FnMut
: FnOnce
. That means, a closure that implements Fn
, also implements FnMut
and FnOnce
. Likewise, a closure that implements FnMut
, also implements FnOnce
.
From a call site perspective that means:
Signature
Function g
can call …
Function g
accepts …
g<F: FnOnce()>(f: F)
… f()
once.
Fn
, FnMut
, FnOnce
g<F: FnMut()>(mut f: F)
… f()
multiple times.
Fn
, FnMut
g<F: Fn()>(f: F)
… f()
multiple times.
Fn
Notice how asking for a Fn
closure as a function is most restrictive for the caller; but having a Fn
closure as a caller is most compatible with any function.
From the perspective of someone defining a closure:
Closure
Implements*
Comment
|| { moved_s; }
FnOnce
Caller must give up ownership of moved_s
.
|| { &mut s; }
FnOnce
, FnMut
Allows g()
to change caller’s local state s
.
|| { &s; }
FnOnce
, FnMut
, Fn
May not mutate state; but can share and reuse s
.
- Rust prefers capturing by reference (resulting in the most “compatible”
Fn
closures from a caller perspective), but can be forced to capture its environment by copy or move via themove || {}
syntax.
That gives the following advantages and disadvantages:
Requiring
Advantage
Disadvantage
F: FnOnce
Easy to satisfy as caller.
Single use only, g()
may call f()
just once.
F: FnMut
Allows g()
to change caller state.
Caller may not reuse captures during g()
.
F: Fn
Many can exist at same time.
Hardest to produce for caller.
Idiomatic Rust
If you are used to programming Java or C, consider these.
Idiom
Code
Think in Expressions
x = if x { a } else { b };
x = loop { break 5 };
fn f() -> u32 { 0 }
Think in Iterators
(1..10).map(f).collect()
names.iter().filter(|x| x.starts_with("A"))
Handle Absence with ?
x = try_something()?;
get_option()?.run()?
Use Strong Types
enum E { Invalid, Valid { ... } }
over ERROR_INVALID = -1
enum E { Visible, Hidden }
over visible: bool
struct Charge(f32)
over f32
Provide Builders
Car::new("Model T").hp(20).run();
Split Implementations
Generic types S<T>
can have a separate impl
per T
.
Rust doesn’t have OO, but with separate impl
you can get specialization.
Unsafe
Avoid unsafe {}
, often safer, faster solution without it. Exception: FFI.
Implement Traits
#[derive(Debug, Copy, ...)]
and custom impl
where needed.
Tooling
With clippy you can improve your code quality.
Formatting with rustfmt helps others to read your code.
Add unit tests BK (#[test]
) to ensure your code works.
Add doc tests BK (my_api::f()
) to ensure docs match code.
Documentation
Annotate your APIs with doc comments that can show up on docs.rs.
Don’t forget to include a summary sentence and the Examples heading.
If applicable: Panics, Errors, Safety, Abort and Undefined Behavior.
🔥 We highly recommend you also follow the API Guidelines (Checklist) for any shared project! 🔥
A Guide to Reading Lifetimes
Lifetimes can be overwhelming at times. Here is a simplified guide on how to read and interpret constructs containing lifetimes if you are familiar with C.
Construct
How to read
let s: S = S(0)
A location that is S
-sized, named s
, and contains the value S(0)
.
If declared with let
, that location lives on the stack.
Generally, s
can mean location of s
, and value within s
.
As a location, s = S(1)
means, assign value S(1)
to location s
.
As a value, f(s)
means call f
with value inside of s
.
To explicitly talk about its location (address) we do &s
.
To explicitly talk about a location that can hold such a location we do &S
.
&'a S
A &S
is a location that can hold (at least) an address, called reference.
Any address stored in here must be that of a valid S
.
Any address stored must live at least for (outlive) duration 'a
.
That means during 'a
memory targeted by &S
can’t be invalidated.
During 'a
target of &S
may switch as long as new one also lives for 'a
.
Also, this &S
must be stopped being used before 'a
ends.
Duration of 'a
is purely compile time view, based on static analysis.
&S
Sometimes 'a
might be elided (or can’t be specified) but it still exists.
Within methods bodies, lifetimes are determined automatically.
Within signatures, lifetimes may be ‘elided’ (annotated automatically).
&s
This will produce the actual address of location s
, called ‘borrow’.
The moment &s
is produced, location s
is put into a borrowed state.
Checking if in borrowed state is based on compile-time analysis.
This analysis is based on all possible address propagation paths.
As long as any &s
could be around, s
cannot be altered directly.
For example, in let a = &s; let b = a;
, also b
needs to go.
Borrowing of s
stops once last &s
is last used, not when &s
dropped.
&mut s
Same, but will produce a mutable borrow.
A &mut
will allow the owner of the borrow (address) to change s
content.
This reiterates that not the value in s
, but location of s
is borrowed.
S<'a> {}
Signals that S
will hold at least one address (i.e., reference).
'a
will be determined automatically by the user of this struct.
'a
will be chosen as small as possible.
f<'a>(x: &'a T)
Signals this function will accept an address (i.e., reference).
-> &'a S
… and that it returns one.
'a
will be determined automatically by the caller.
'a
will be chosen as small as possible.
'a
will be picked so that it satisfies input and output at call site.
'a
is mix of where x
comes from and f(x)
goes.
In addition, propagate borrow state according to lifetime names!
So while result address with 'a
is used, input address with 'a
is locked.
Here: while s
from let s = f(&x)
is around, x
counts as ‘borrowed’.
<'a, 'b: 'a>
The lifetimes declared in S<>
and f<>
can also have bounds.
The <'a, 'b>
part means the type will handle at least 2 addresses.
The 'b: 'a
part is a lifetime bound, and means 'b
must outlive 'a
.
Any address in an &'b X
must exist at least as long as any in an &'a Y
.
Formatting Strings
Formatting applies to print!
, eprint!
, write!
(and their -ln
siblings like println!
). The format!
macro can create a formatted String
.
Each format argument follows a basic grammar:
{[argument][':'[[fill]align][sign]['#']['0'][width]['.' precision][type]]}
The full grammar is specified in the std::fmt
documentation, but here are some commonly used flags:
Element
Meaning
argument
Omitted (next {}
), number (0
, 1
, …) or identifier for named arguments.
align
Left (<
), center (^
), or right (>
) , if width is specified, fills with fill
.
#
Alternate formatting. Pretty-print with {:#?}
, for example.
0
Zero-pads numeric values.
width
Minimum width (≥ 0), padding with fill
(default to space).
precision
Decimal digits (≥ 0) for numerics, or max width for non-numerics.
type
Debug (?
), hex (x
), binary (b
), or octal (o
) (there are more, using Traits).
Note that width and precision can use other arguments as their values, allowing for dynamic sizing of fields.
Examples:
Example
Explanation
{#?}
Pretty-print the next argument using Debug.
{2:#?}
Pretty-print the 3rd argument using Debug.
{val:^2$}
Center the val
named argument, width specified by the 3rd argument.
{:<10.3}
Left align with width 10 and a precision of 3.
{val:#x}
Format val
argument as hex, with a leading 0x
(alternate format for x
).
Tooling
Some commands and tools that are good to know.
Command
Description
cargo init
Create a new project for the latest edition.
cargo build
Build the project in debug mode (--release
for all optimization).
cargo check
Check if project would compile (much faster).
cargo test
Run tests for the project.
cargo run
Run your project, if a binary is produced (main.rs).
cargo doc --open
Locally generate documentation for your code and dependencies.
cargo rustc -- -Zunpretty=X
Show more desugared Rust code, in particular with X being:
expanded
Show with expanded macros, …
cargo +{nightly, stable} ...
Runs command with given toolchain, e.g., for ‘nightly only’ tools.
rustup docs
Open offline Rust documentation (incl. the books), good on a plane!
A command like cargo build
means you can either type cargo build
or just cargo b
.
These are optional rustup
components. Install them with rustup component add [tool]
.
Tool
Description
cargo clippy
Additional (lints) catching common API misuses and unidiomatic code. 🔗
cargo fmt
Automatic code formatter (rustup component add rustfmt
). 🔗
These are 3rd party tools and usually need to be installed with cargo install cargo-[tool]
first. They often require unstable and are subject to break.
Command
Description
cargo asm
Show generated assembly instructions for code. 🔗
cargo outdated
List upgradable dependencies. 🔗
cargo tree
Print dependencies as a tree. 🔗
cargo-edit
Meta package (cargo install cargo-edit
) 🔗. Provides:
cargo add <crate>
Add latest version of <crate>
to your Cargo.toml
.
cargo rm <crate>
Remove <crate>
from your Cargo.toml
.
cargo upgrade <crate>
Upgrade the version of <crate>
to the latest.
cargo flamegraph
Visualize CPU time (cargo install flamegraph
). 🔗 OSX, Linux only
Links & Services
These are other great visual guides and tables.
[](https://docs.google.com/presentation/d/1q-c7UAyrUlM-eZyTo1pd8SZ0qwA_wYxmPZVOQkoDmH4/edit)
Containers
[](https://lukaslueg.github.io/macro_railroad_wasm_demo/)
Macro Railroad
[](https://rufflewind.com/2017-02-15/rust-move-copy-borrow)
Lifetimes
Cheat Sheets
Description
Probably the best collection of links about learning Rust.
A collection of functional programming jargon explained in Rust.
How to get type of string from another.
How various types and references correlate.
How to construct and work with futures.
Summary of iterator-related methods from std::iter
and itertools
.
Lists common types and how they convert.
All major Rust books developed by the community.
Books 📚
Description
Standard introduction to Rust, start here if you are new.
How to write idiomatic and re-usable Rust.
Explains async
code, Futures
, …
Working with Rust 2015, Rust 2018, and beyond.
The Little Book of Rust Macros 🚧
Community’s collective knowledge of Rust macros.
Reference of the Rust language.
Look up accepted RFCs and how they change the language.
Explains how the compiler works internally.
Tips how to customize cargo doc
and rustdoc
.
Dark Arts of Advanced and Unsafe Rust Programming.
Work with u8x32
or f32x8
to speed up your computations.
Concise information about writing unsafe
code.
Information about unstable items, e.g, #![feature(...)]
.
How to use cargo
and write Cargo.toml
.
Information about creating CLI tools.
Working with embedded and #![no_std]
devices.
First #![no_std]
from scratch on a Cortex-M.
Working with the web and producing .wasm
files.
How to bind Rust and JavaScript APIs in particular.
Comprehensive lookup tables for common components.
Tables 📋
Description
Ever wondered what E0404
means?
All the clippy lints you might be interested in.
All rustfmt options you can use in rustfmt.toml
.
See all the things that changed in a particular version.
Lists release train and links for people working on the compiler.
All supported platforms and their Tier.
Check nightly status of various Rust tools for a platform.
Online services which provide information or tooling.
Services ⚙
Description
All 3rd party libraries for Rust.
Documentation for 3rd party libraries, automatically generated from source.
Unofficial overview of quality Rust libraries and applications.
Try and share snippets of Rust code.


A starting template if you want to develop a RESTful micro service with docker.
Then, we have the following objectives:
activator run
should be enough
to run all services at the same time.
This template uses the dependency injected router Dependency Injection
So, every route starts with an @ like @controllers.Application.index()
which leads to non-static actions.
The logger is configured for a better output and contains a rolling file appender.
The logs are look like
2015-08-17 10:21:17,914 INFO [ForkJoinPool-1-worker-3] application: Class::Method:#Line - Message
.


The National Historic Preservation Act (NHPA) was signed into law in 1966 by Lyndon B. Johnson and is the nation's primary historic preservation law.
Congress agreed that "the spirit and direction of the Nation are founded upon and reflected in its historic heritage" and that "the historic and cultural foundations of the Nation should be preserved as a living part of our community life and development in order to give a sense of orientation to the American people." Because historic properties significant to the Nation’s heritage are being lost or substantially altered, often inadvertently, with increasing frequency; the preservation of this irreplaceable heritage is in the public interest so that its vital legacy of cultural, educational, aesthetic, inspirational, economic, and energy benefits will be maintained and enriched for future generations of Americans."
As technologies and methods improve for all fields and disciplines, not only do we have increased expansion and development but we also have better means of identifying the past and by improving our planning for preservation through the execution of federal and federally assisted projects will benefit everyone.
The National Register of Historic Places is the official list of the Nation's historic places worthy of preservation. The National Park Service's National Register of Historic Places is part of a national program to coordinate and support public and private efforts to identify, evaluate, and protect America's historic and archeological resources.
Almost every county in the United States has at least one place listed in the National Register and listing in the National Register is the first step towards eligibility for National Park Service-administered federal preservation tax credits, leveraging more than $45 billion in private investment and National Park Service grant programs like Save America's Treasures and Preserve America.
This will direct you to the More Information section for this NHPA that lists links to many sources for further information.


|
y=0
(probability 0.083, score -2.612)
top features
|
y=1
(probability 0.105, score -2.354)
top features
|
y=2
(probability 0.119, score -2.224)
top features
|
y=3
(probability 0.070, score -2.800)
top features
|
y=4
(probability 0.099, score -2.424)
top features
|
y=5
(probability 0.097, score -2.450)
top features
|
y=6
(probability 0.103, score -2.381)
top features
|
y=7
(probability 0.092, score -2.499)
top features
|
y=8
(probability 0.112, score -2.287)
top features
|
y=9
(probability 0.121, score -2.204)
top features
|
|
Contribution?
|
Feature |
|
+2.018
|
xchg xchg
|
|
+0.212
|
repz xchg
|
|
-0.156
|
<BIAS>
|
|
-0.303
|
repz
|
|
-4.383
|
xchg
|
|
|
Contribution?
|
Feature |
|
+2.198
|
xchg xchg
|
|
+0.267
|
repz xchg
|
|
-0.088
|
<BIAS>
|
|
-0.408
|
repz
|
|
-4.322
|
xchg
|
|
|
Contribution?
|
Feature |
|
+1.988
|
xchg xchg
|
|
+0.290
|
repz xchg
|
|
-0.214
|
<BIAS>
|
|
-0.373
|
repz
|
|
-3.915
|
xchg
|
|
|
Contribution?
|
Feature |
|
+1.393
|
xchg xchg
|
|
+0.295
|
repz xchg
|
|
-0.194
|
<BIAS>
|
|
-0.363
|
repz
|
|
-3.931
|
xchg
|
|
|
Contribution?
|
Feature |
|
+1.797
|
xchg xchg
|
|
+0.301
|
repz xchg
|
|
-0.161
|
<BIAS>
|
|
-0.317
|
repz
|
|
-4.044
|
xchg
|
|
|
Contribution?
|
Feature |
|
+2.196
|
xchg xchg
|
|
+0.291
|
repz xchg
|
|
-0.116
|
<BIAS>
|
|
-0.332
|
repz
|
|
-4.488
|
xchg
|
|
|
Contribution?
|
Feature |
|
+2.083
|
xchg xchg
|
|
+0.278
|
repz xchg
|
|
-0.148
|
<BIAS>
|
|
-0.331
|
repz
|
|
-4.262
|
xchg
|
|
|
Contribution?
|
Feature |
|
+1.660
|
xchg xchg
|
|
+0.200
|
repz xchg
|
|
-0.193
|
<BIAS>
|
|
-0.203
|
repz
|
|
-3.962
|
xchg
|
|
|
Contribution?
|
Feature |
|
+1.693
|
xchg xchg
|
|
+0.345
|
repz xchg
|
|
-0.162
|
<BIAS>
|
|
-0.444
|
repz
|
|
-3.719
|
xchg
|
|
|
Contribution?
|
Feature |
|
+2.136
|
xchg xchg
|
|
+0.212
|
repz xchg
|
|
-0.124
|
<BIAS>
|
|
-0.352
|
repz
|
|
-4.076
|
xchg
|
|


BindingLoader
Static Method Summary
| Static Public Methods | ||
| public static |
load(arg_id: string, arg_runtime: RuntimeBase, arg_component: Component, arg_binding_cfg: Immutable.Map | undefined): BindingStream | array Load and apply a component binding configuration. |
|
| public static |
normalize_objects(arg_runtime: RuntimeBase, arg_component: Component, arg_selectors: array, arg_dom_types: array | string): array Normalize an array of objects selectors in an array of objects. |
Constructor Summary
| Public Constructor | ||
| public |
constructor(): nothing Creates an instance of BindingLoader. |
Static Public Methods
public static load(arg_id: string, arg_runtime: RuntimeBase, arg_component: Component, arg_binding_cfg: Immutable.Map | undefined): BindingStream | array source
Load and apply a component binding configuration.


December 28, 2017
The HackX 2k17 is an information technology-oriented & innovation-based hackathon ....
The students of developing nations like ours rarely get the opportunities to explore the dynamics and the challenges in the real-world when reading for industrially oriented engineering or business undergraduate degrees. Furthermore, the academics who teach the aforementioned, face challenges when designing and delivering the curricula to embed the real-world complexities and systems’ dynamics.....
Nine hours a day, five days a week, approximately 230 days a year – that is how big of a role a job plays in an adult’s life. ..


Project IceStorm aims at documenting the bitstream format of Lattice iCE40 FPGAs and providing simple tools for analyzing and creating bitstream files. This is work in progress.
The image on the right shows the span-wires of a left (or right) io cell (click to enlarge).
A left/right io cell has 16 connections named span4_vert_t_0 to span4_vert_t_15 on its top edge and 16 connections named span4_vert_b_0 to span4_vert_b_15 on its bottom edge. The nets span4_vert_t_0 to span4_vert_t_11 are connected to span4_vert_b_4 to span4_vert_b_15. The span-4 and span-12 wires of the adjacent logic cell are connected to the nets span4_horz_0 to span4_horz_47 and span12_horz_0 to span12_horz_23.
A top/bottom io cell has 16 connections named span4_horz_l_0 to span4_horz_l_15 on its left edge and 16 connections named span4_horz_r_0 to span4_horz_r_15 on its right edge. The nets span4_horz_l_0 to span4_horz_l_11 are connected to span4_horz_r_4 to span4_horz_r_15. The span-4 and span-12 wires of the adjacent logic cell are connected to the nets span4_vert_0 to span4_vert_47 and span12_vert_0 to span12_vert_23.
The vertical span4 wires of left/right io cells are connected "around the corner" to the horizontal span4 wires of the top/bottom io cells. For example span4_vert_b_0 of IO cell (0 1) is connected to span4_horz_l_0 (span4_horz_r_4) of IO cell (1 0).
Note that unlike the span-wires connection LOGIC and RAM tiles, the span-wires connecting IO tiles to each other are not pairwise crossed out.
Each IO tile contains two IO blocks. Each IO block essentially implements the SB_IO primitive from the Lattice iCE Technology Library. Some inputs are shared between the two IO blocks. The following table lists how the wires in the logic tile map to the SB_IO primitive ports:
| SB_IO Port | IO Block 0 | IO Block 1 |
|---|---|---|
| D_IN_0 | io_0/D_IN_0 | io_1/D_IN_0 |
| D_IN_1 | io_0/D_IN_1 | io_1/D_IN_1 |
| D_OUT_0 | io_0/D_OUT_0 | io_1/D_OUT_0 |
| D_OUT_1 | io_0/D_OUT_1 | io_1/D_OUT_1 |
| OUTPUT_ENABLE | io_0/OUT_ENB | io_1/OUT_ENB |
| CLOCK_ENABLE | io_global/cen | |
| INPUT_CLK | io_global/inclk | |
| OUTPUT_CLK | io_global/outclk | |
| LATCH_INPUT_VALUE | io_global/latch |
Like the inputs to logic cells, the inputs to IO blocks are routed to the IO block via a two-stage process. A signal is first routed to one of 16 local tracks in the IO tile and then from the local track to the IO block.
The io_global/latch signal is shared among all IO tiles on an edge of the chip and is driven by fabout from one dedicated IO tile on that edge. For the HX1K chips the tiles driving the io_global/latch signal are: (0, 7), (13, 10), (5, 0), and (8, 17)
A logic tile sends the output of its eight logic cells to its neighbour tiles. An IO tile does the same thing with the four D_IN signals created by its two IO blocks. The D_IN signals map to logic function indices as follows:
| Function Index | D_IN Wire |
|---|---|
| 0 | io_0/D_IN_0 |
| 1 | io_0/D_IN_1 |
| 2 | io_1/D_IN_0 |
| 3 | io_1/D_IN_1 |
| 4 | io_0/D_IN_0 |
| 5 | io_0/D_IN_1 |
| 6 | io_1/D_IN_0 |
| 7 | io_1/D_IN_1 |
For example the signal io_1/D_IN_0 in IO tile (0, 5) can be seen as neigh_op_lft_2 and neigh_op_lft_6 in LOGIC tile (1, 5).
Each IO Tile has 2 NegClk configuration bits, suggesting that the clock signals can be inverted independently for the the two IO blocks in the tile. However, the Lattice tools refuse to pack two IO blocks with different clock polarity into the same IO tile. In our tests we only managed to either set or clear both NegClk bits.
Each IO block has two IoCtrl IE bits that enable the input buffers and two IoCtrl REN bits that enable the pull up resistors. Both bits are active low, i.e. an unused IO tile will have both IE bits set and both REN bits cleared (the default behavior is to enable pullup resistors on all unused pins). Note that icebox_explain.py will ignore all IO tiles that only have the two IoCtrl IE bits set.
However, the IoCtrl IE_0/IE_1 and IoCtrl REN_0/REN_1 do not necessarily configure the IO PIN that are connected to the IO block in the same tile, and if they do the numbers (0/1) do not necessarily match. As a general rule, the pins on the right and bottom side of the chips match up with the IO blocks and for the pins on the left and top side the numbers must be swapped. But in some cases the IO block and the set of IE/REN are not even located in the same tile. The following table lists the correlation between IO blocks and IE/REN bits for the 1K chip:
|
|
|
|
When an input pin pair is used as LVDS pair (IO standard SB_LVDS_INPUT, bank 3 / left edge only), then the four bits IoCtrl IE_0/IE_1 and IoCtrl REN_0/REN_1 are all set, as well as the IoCtrl LVDS bit.
In the iCE 8k devices the IoCtrl IE bits are active high. So an unused IO tile on an 8k chip has all bits cleared.
iCE40 FPGAs have 8 global nets. Each global net can be driven directly from an IO pin. In the FPGA bitstream, routing of external signals to global nets is not controlled by bits in the IO tile. Instead bits that do not belong to any tile are used. In IceBox nomenclature such bits are called "extra bits".
The following table lists which pins / IO blocks may be used to drive which global net, and what .extra statements in the IceStorm ASCII file format to represent the corresponding configuration bits:
| Glb Net | Pin (HX1K-TQ144) | IO Tile + Block # | IceBox Statement |
|---|---|---|---|
| 0 | 93 | 13 8 1 | .extra_bit 0 330 142 |
| 1 | 21 | 0 8 1 | .extra_bit 0 331 142 |
| 2 | 128 | 7 17 0 | .extra_bit 1 330 143 |
| 3 | 50 | 7 0 0 | .extra_bit 1 331 143 |
| 4 | 20 | 0 9 0 | .extra_bit 1 330 142 |
| 5 | 94 | 13 9 0 | .extra_bit 1 331 142 |
| 6 | 49 | 6 0 1 | .extra_bit 0 330 143 |
| 7 | 129 | 6 17 1 | .extra_bit 0 331 143 |
Signals internal to the FPGA can also be routed to the global nets. This is done by routing the signal to the fabout net on an IO tile. The same set of I/O tiles is used for this, but in this case each of the I/O tiles corresponds to a different global net:
| Glb Net | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|---|
| IO Tile | 7 0 | 7 17 | 13 9 | 0 9 | 6 17 | 6 0 | 0 8 | 13 8 |
Each LOGIC, IO, and RAMB tile has 8 ColBufCtrl bits, one for each global net. In most tiles this bits have no function, but in tiles in rows 4, 5, 12, and 13 (for RAM columns: rows 3, 5, 11, and 13) this bits control which global nets are driven to the column of tiles below and/or above that tile (including that tile), as illustrated in the image to the right (click to enlarge).
In 8k chips the rows 8, 9, 24, and 25 contain the column buffers. 8k RAMB and RAMT tiles can control column buffers, so the pattern looks the same for RAM, LOGIC, and IO columns.
The SB_WARMBOOT primitive in iCE40 FPGAs has three inputs and no outputs. The three inputs of that cell are driven by the fabout signal from three IO tiles. In HX1K chips the tiles connected to the SB_WARMBOOT primitive are:
| Warmboot Pin | IO Tile |
|---|---|
| BOOT | 12 0 |
| S0 | 13 1 |
| S1 | 13 2 |
The PLL primitives in iCE40 FPGAs are configured using the PLLCONFIG_* bits in the IO tiles. The configuration for a single PLL cell is spread out over many IO tiles. For example, the PLL cell in the 1K chip are configured as follows (bits listed from LSB to MSB):
|
|
The PLL inputs are routed to the PLL via the fabout signal from various IO tiles. The non-clock PLL outputs are routed via otherwise unused neigh_op_* signals in fabric corners. For example in case of the 1k chip:
| Tile | Net-Segment | SB_PLL40_* Port Name |
|---|---|---|
| 0 1 | fabout | REFERENCECLK |
| 0 2 | fabout | EXTFEEDBACK |
| 0 4 | fabout | DYNAMICDELAY |
| 0 5 | fabout | |
| 0 6 | fabout | |
| 0 10 | fabout | |
| 0 11 | fabout | |
| 0 12 | fabout | |
| 0 13 | fabout | |
| 0 14 | fabout | |
| 1 1 | neigh_op_bnl_1 | LOCK |
| 1 0 | fabout | BYPASS |
| 2 0 | fabout | RESETB |
| 5 0 | fabout | LATCHINPUTVALUE |
| 12 1 | neigh_op_bnr_3 | SDO |
| 4 0 | fabout | SDI |
| 3 0 | fabout | SCLK |
The PLL clock outputs are fed directly into the input path of certain IO tiles. In case of the 1k chip the PORTA clock is fed into PIO 1 of IO Tile (6 0) and the PORTB clock is fed into PIO 0 of IO Tile (7 0). Because of this, those two PIOs can only be used as output Pins by the FPGA fabric when the PLL ports are being used.
The input path that are stolen are also used to implement the ICEGATE function. If the input pin type of the input path being stolen is set to PIN_INPUT_LATCH, then the ICEGATE function is enabled for the corresponding CORE output of the PLL.


Preparation time
less than 30 mins
Cooking time
over 2 hours
Serves
Serves 2
Lamb takes centre stage, served on a fresh coriander salad.
For the lamb’s tongue, bring a large saucepan of water to the boil, add the tongue and your vegetables, then return to a simmer and cook for 2½–3 hours. Remove from the heat and let the tongue cool in the water. Lift the tongue out of the water, peel it and cut it in half lengthways. Strain and reserve the stock.
Rub the lamb loin lightly with the oil and season well with salt and pepper. Preheat a griddle pan over a high heat and griddle the lamb for 8–10 minutes, or until cooked, turning regularly. Leave to rest for 5 minutes.
Meanwhile, heat half the butter in a small frying pan. Add the kidney and sauté for 3–4 minutes on each side, or until cooked. Remove and set aside to rest.
Heat the remaining butter in a heavy-based saucepan and sauté the cooked tongue cut side-down for 3–4 minutes, until coloured and hot through. Set aside to rest.
For the coriander sauce, purée all the ingredients together with a pinch of salt and pepper in a food processor. Start with 100ml/3½fl oz oil and increase if needed.
For the coriander salad, mix the celery, shallot and coriander together in a bowl. Combine the oil and vinegar in a small jar, then pour this over the salad and season well with salt and pepper.
To serve, slice the lamb loin. Put half the slices in each of two shallow bowls with a piece of tongue and kidney. Ladle over some the tongue stock and drizzle over a little coriander sauce. Serve with the salad.


{% for favorite in favorites %}
{% with favorite.parent_set as set %}
{% endfor %}
Note {{ set.pk }}{% if set.name %}: {{ set.name }}{% endif %}
{{ set.commit_set.all.count }} commit{{ set.commit_set.all.count|pluralize }} {% with set.commit_set.latest as latest %} {{ latest.created|elapsed }} by {% if latest.owner %}you{% else %}{{ latest.email }}{% endif %}. {% endwith %}
{% endwith %}
{% empty %}
{{ set.commit_set.all.count }} commit{{ set.commit_set.all.count|pluralize }} {% with set.commit_set.latest as latest %} {{ latest.created|elapsed }} by {% if latest.owner %}you{% else %}{{ latest.email }}{% endif %}. {% endwith %}
What is a favorite if you don't show love?
(a.k.a. go find notes to favorite)


{% extends 'menu.html' %} {% block content %}
{{order.order_description}}
phonenumber:
Address:
Domain..:

Delivery (Standard - 20 working days):


Welcome to Freezr - Set Up your Personal Server.
Congratulations! You have set up your freezr server.
Please choose your file system and database.
Please choose your file system and database.
You are set up on freezr as user id comes here.
Please choose your file system and database.
Please choose your file system and database.
freezr is an Expermintal Prototype. Do not store important personal data on it.. yet!
User Information
Enter a user name and password.
| User Name: | |
| Password: | |
| Confirm Password: | |
| email: |
Remember there is no way to recover a forgotten password!
(There are no outside servers that store your data.)
(There are no outside servers that store your data.)
There are no password recovery options on freezr yet.
So please remember your password.
So please remember your password.
Your file system
Authenticate
Click here for more (technical) options.
The Authorization Code is retrieved automatically when you authenitcate with your account.
If you are a developer, you can also find your access token, and use it instead.
This freezr uses a default authentication service. However, you can choose another authenticator. You really need to trust the host of the authenticator, because it could potentially have access to all your data.
If you are a developer, you can also find your access token, and use it instead.
This freezr uses a default authentication service. However, you can choose another authenticator. You really need to trust the host of the authenticator, because it could potentially have access to all your data.
| authenticator url: |
Your database
Launch freezr
freezr is an Expermintal Prototype. Do not store important personal data on it... yet.


Brett Schiff |
|---|
|
Contact Info<EMAIL_ADDRESS>LinkedIn |
Home |
Personal Projects |
Academic Projects |
Resume |
Academic ProjectsPictures, Links, and more Data coming soon! |
|---|
ShortstackShortstack is a multiplayer, couch-co-op, side-scrolling, 2D, fantasy platformer where player gnomes use stacking and ability combinations to defeat corrupted creatures.
Trailer |
Relics of LightRelics of Light is a top-down, 2D, puzzle-adventure game set in an archipelago where the player uses beams of light to activate ancient magic and solve puzzles.
Trailer |


WITNESS LIST Workers' Compensation, Select Interim Committee February 26, 2004 -10:00A Charge 1 ON: Buchanan, Katherine Daunno Member (Labor- HNAC), Houston, TX Faith, David IAM & AW Business Representative (Labor- HNAC), Fort Worth, TX Nash, John President- Smith Co Labor Council (Labor- HNAC), Chandler, TX Nemeth, Dr. Bill Medical Advisor (Texas Workers' Compensation Commission), Austin, TX Registering, but not testifying: On: Dendy, Phillip Director Risk Management (University of Texas System), Austin, TX McGinnis, Kevin Director of Risk Management (The Texas A&M University System), College Station, TX Charge 6 ON: Crumpton, Laurie Director of Strategic Planning (Texas Worker's Compensation Commission), Austin, TX Dendy, Phillip Director of Risk Management (University of Texas System), Austin, TX Josselet, Ron Executive Director (State Office of Risk Management), Austin, TX Lee, Amy Team Leader- Research Group (Texas Department of Insurance), Austin, TX McGinnis, Kevin Director of Risk Management (The Texas A&M University System), College Station, TX Myers, Gus Director Risk Management (University of North Texas), Denton, TX Myers, Terry Director of Claims OPS (SORM), Austin, TX Schroeder, Ron Director- Workers Compensation Section (Tx DOT), Austin, TX Sims, Ed Director- Occupational Safety Divison (Tx DOT), Austin, TX Welch, Doug Risk Manager (University of North Texas), Denton, TX Registering, but not testifying: On: Buchanan, Katherine Daunno Member (Labor- HNAC), Houston, TX


We're sorry but weatherapplication doesn't work properly without JavaScript enabled. Please enable it to continue.


Pivot4D provides an effective and easy to use content management tool. This provides for you to upload and download your content anytime from anywhere. Your content is stored and backed up through our cloud based servers. Media content includes, photo and static images, movies, audio files, graphics and 360 degree panoramas.


| Bits | Field | Descriptions |
| [0] | FIER0 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [1] | FIER1 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [2] | FIER2 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [3] | FIER3 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [4] | FIER4 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [5] | FIER5 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [6] | FIER6 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [7] | FIER7 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [8] | FIER8 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [9] | FIER9 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [10] | FIER10 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [11] | FIER11 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [12] | FIER12 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [13] | FIER13 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [14] | FIER14 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [15] | FIER15 | GPIO Port [X] Pin [N] Interrupt Enable By Input Falling Edge Or Input Level Low |
| | FIER[n] used to enable the interrupt for each of the corresponding input GPIO_PIN[n]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the FIER[n] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[n] state at level "low" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[n] state change from "high-to-low" will generate the interrupt. |
| | 1 = PIN[n] state low-level or high-to-low change interrupt Enabled. |
| | 0 = PIN[n] state low-level or high-to-low change interrupt Disabled. |
| | Note: For GPIOF_IER, bits [15:6] are reserved. |
| [16] | RIER0 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [17] | RIER1 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [18] | RIER2 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [19] | RIER3 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [20] | RIER4 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [21] | RIER5 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [22] | RIER6 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [23] | RIER7 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [24] | RIER8 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [25] | RIER9 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [26] | RIER10 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [27] | RIER11 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [28] | RIER12 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [29] | RIER13 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [30] | RIER14 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |
| [31] | RIER15 | GPIO Port [X] Pin [N] Interrupt Enable By Input Rising Edge Or Input Level High |
| | RIER[x] used to enable the interrupt for each of the corresponding input GPIO_PIN[x]. |
| | Set bit "1" also enable the pin wake-up function. |
| | When set the RIER[x] bit "1": |
| | If the interrupt is level mode trigger, the input PIN[x] state at level "high" will generate the interrupt. |
| | If the interrupt is edge mode trigger, the input PIN[x] state change from "low-to-high" will generate the interrupt. |
| | 1 = PIN[x] level-high or low-to-high interrupt Enabled. |
| | 0 = PIN[x] level-high or low-to-high interrupt Disabled. |
| | Note: For GPIOF_IE, bits [31:22] are reserved. |


Issues and weaknesses of livestock farming •Requires large quantities of water •Restriction of space •Conditions of captivity and bad animal welfare •Management of farming wastes •Cannot meet the ever increasing needs for animal protein, from meat and other products.
 During trawling, the sea bottom is dredged and a great number of organisms get crushed to death or accidently caught in the nets. Small or noncommercial fish discarded into the sea injured or dead. Bottom trawlers dispose 30-70% (by weight) of their catches back to the sea.
Fish landing
Central fish auction site
Local fish market
Consumer’s plate
The fish are usually landed at the port, transported to a central fish auction site, and then distributed to local stores ultimately ending up on our plate.
Advantages
•Freshness •Large variety of species •Direct contact with the seller
Disadvantages
•Reduced wild fish stocks due to overfishing •Negative impact of fishing methods also on non-commercial species •Negative impact of fishing methods on the environment
The commonly farmed species, about 95% of total production, in Greece are sea bream and sea bass. Recently, there is an effort to increase the number of famed species with new species such as pagrus, dentex etc. Especially, Red porgy is a popular dish in many restaurants, though it is a fairly expensive fish. Its successful farming will lead to the reduction in both its price and the pressure on its wild stocks.
1. Broodstock is kept in tanks under controlled conditions in small groups of with a specific sex ratio.
2. Male fish release sperm and female fish eggs. The fertilization of the eggs takes place in the water. A few hours after the fertilization the fish eggs begin to hatch.
3. The juveniles pass into the ongrowing phase.
4. They are transported to fish cages at the sea where the main farming stage begins.
5. When they reach the commercial size they are harvested using nets.
•No need for freshwateŕ. •Production of animal protein with lower ecological cost. •Reduction of over-fishing of natural populations.
•Provides employment opportunities in remote and rural areas. •Expansion of production on isolated coasts and small islands
Disadvantages
•Small diversity of farmed species. •Conflicts with other uses in the coastal zone (i.e. tourism). •Use of non-commercial wild fish captures to produce food for farmed fish (fishmeal).


Welcome to my website. I did my Undergrad in Nanotechnology Engineering and my masters specializing in MEMS and optoelectronics at the Sensors and Integrated Microsystems lab at the University of Waterloo. I have dabbled with some cool projects.
I have worked with startups (like ExVivo Labs, Vitameter) at Waterloo helping them solve technical challenges big and small. I was working at P&P Optica working primarily on design some really cool spectrometers. The spectrometers I designed were used for a wide variety of things ranging from studying the atmosphere to underwater material analysis
I currently work at Nicoya Lifesciences working on some really cool projects. I designed a lot of the OpenSPR
Feel free to contact me with requests or even just to say hi!


THE NEXT STEP
Reviewed by Harvey Karten, Ph.D. Phaedra Cinema Director: Christian Faber Writer: Aaron Reed Cast:Rick Negron, Kristin Moreu, Denise Faye, Taylor Nichols, Gerry McIntyre, Aubrey Lynch
Everyone knows the expression "Rich or poor, it's nice to have money." Now, "The Next Step" advances our knowledge of life thusly: "Youthful or ancient, it's nice to be young." And, sad to say, maybe kids are right when they think of a guy who has passed his 35th birthday as an old man--but only if you have a career as a professional basketball player or dancer. "The Next Step" tells the tale of a hoofer who leads quite a good life, at least while he has a glamorous job. He's making enough money to splurge at a yuppie restaurant for Perrier champagne and best of all he has his pick of great-looking women with whom he works.
"The Next Step" is a movie with an apt title about Nick Mendez (Rick Negron) who has a live-in girl friend, Amy (Kristin Moreu), a hormone-crazed woman-on-the-side, Heidi (Denise Faye) and, later on, a lovely French Miss, Michelle (Michelle Pertier) to add to his collection. Amy, a former dancer who now enjoys a career as a physical therapist, seems clueless about her boy friend's peregrinations, but he's taking flak from Heidi, who scornfully refers to Amy as Nick's wife and pressures him to split and move in with her. Nick's world changes suddenly when his current gig in a Broadway show closes and his agent, later his choreographer, shy away from him: a man who, in his mid-thirties, is washed up. But Nick loves his job and is determined to gain a principal role in a new musical about youthful gangs. To cover himself meanwhile he takes a restaurant job while anticipating a series of auditions for the big musical, where he will pit his experience against a more youthful group of aspirants.
A large number in the cast of this picture are themselves professional dancers and, in fact, the "aging" Rick Negron is currently in the chorus of the big Broadway musical "Ragtime." As such, many performers do better on the dance floor than in the acting department, but writer Aaron Reed has peppered the movie with enough sharp dialogue and humorous situations to keep this high-energy indie absorbing. Older members of the movie's audience will identify with the geriatric couple who wander into a restaurant without realizing that the place seems to have targeted the under-35 crowd. Asking for fish and salad and a well-done baked potato--no oil, no anchovies, light on the spices--they provide a touch of humor in a finely honed vignette, returning the undercooked fish because they "didn't come here for sushi."  In another pithy slice of life, Nick takes a job in an all-male strip bar and, when told by fellow waiters that the real money is made after hours, he encounters a disastrous situation with a middle-aged woman who is shocked when asked for money.
Donald Byrd provides the choreography in a movie that recalls "A Chorus Line" and "All That Jazz," and Christian Faber's direction is particularly impressive in two quick scenes which involve Nick's imagination.
 When Box Office, an online journal, reviewed the movie, its critic held that the work "never leaps above 'All That Jazz'/ 'A Chorus Line' cliches." Now, "A Chorus Line" you can keep, but "All that Jazz" was one terrific picture. A reviewer can do worse than to compare Faber's offering to Bob Fosse's 1979 show-stopper. "The Next Step" focuses intensely on its lead character, who turns in a sympathetic performance as a man who faces what all of us must come to terms with some day. Not Rated. Running time: 96 minutes. (C) Harvey Karten 1998
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


18
1 The one who keeps himself away from other people will only live for his own desires,
and he never acts with good judgment.
2 A foolish person does not enjoy understanding anything;
he only wants to tell others what he thinks.
3 A wicked person comes, and with them comes the contempt they have for other people—
and then comes shame and disgrace following along.
4 The words a man speaks are like the deep waters of an ocean
or a fountain that flows with wisdom.
5 When the wicked are treated with special honor, it is not good,
and it is not good to refuse to give justice to those who do what is right.
6 A foolish person says things that start arguments;
he says things that make other people want to beat him with a stick.
7 A foolish person brings himself to ruin by the things he says;
his very words set a trap in which he will be caught.
8 When a person gossips, his words are as sweet to other people as candy is in their mouths,
and they love to listen to them.
9 The person who does a poor job when he is working
is a relative to the one who destroys everything.
10 The name of Yahweh is like a castle that can never be overrun;
those who do what is right run for safety into it, and in the fortress of his name, they are safe.
11 The wealthy person depends on his wealth as a city depends on its fortifications;
he thinks it protects him as well as a high wall.
12 When a person is about to be ruined, it is his proud heart that brings his destruction,
but before a person can gain great honor, he must first learn to become humble.
13 A person who gives you an answer before he listens to you—
there is nothing more foolish
and nothing that gives him more shame.
14 A person may survive a terrible sickness in his body,
but if he feels his inner self is crushed, how can he survive?
15 Intelligent people have a desire to get more and more knowledge,
and wise people will find someone to teach them even more knowledge.
16 If you take a gift to an important person, you will open the way to allow you to talk to him.
17 The first person to present his case before a judge seems right
until the other side comes and questions him.
18 When there are two strong people having a dispute,
casting lots can help to settle the dispute.
19 If you offend your brother, finding a way to have peace with him again
may be harder than waging a battle to win a city.
and having an argument is more difficult to overcome
than breaking down the bars of a castle.
20 The words a person speaks can bring satisfaction to himself,
like the food he eats satisfies his stomach.
21 People are able to kill others or keep them alive by means of what they say.


Often in development we want to activate a set of commands when a file system. We can use a python library watchdog
for this.
Installation
To install watchdog
we can use pip
like most of python library
pip install watchdog
Setup
A simple program that keeps watch on changes in a folder recursively, means each files in subfolder as well is the follwing
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | import os
import sys
import time
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
class MyHandler(PatternMatchingEventHandler):
patterns = ["*.py", "*.md"]
def process(self, event):
"""
event.event_type
'modified' | 'created' | 'moved' | 'deleted'
event.is_directory
True | False
event.src_path
path/to/observed/file
"""
# the file will be processed there
print(event.src_path, event.event_type)
os.system("write your command here.")
def on_modified(self, event):
self.process(event)
def on_created(self, event):
self.process(event)
if __name__ == '__main__':
args = sys.argv[1:]
path=args[0] if args else '.'
observer = Observer()
observer.schedule(MyHandler(), path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
|
Save the above script in a file watcher.py
in root of project. Now activate the watcher simply by
python watcher.py [optional path of directory]
Now whenever any file mentioned in patterns will change, the command in process
function will executed automatically.


THE FIFTH ELEMENT Starring: Bruce Willis
The start of this movie reminded me of parts from the movie STARGATE. People are looking around in an Egyptian temple reading about some dangerous thing that is going to destroy Earth in the future. After a sort of confusing bit involving fake-looking cyborg things, the movie jumps into the future and the movie improves by leaps and bounds.
The basic idea behind the movie is that every once in a while (make that every 1000 years or so) an evil force comes to destroy Earth. The things needed to defend against this menace are the four Elements of Nature plus the Fifth Element. The plot in this movie really isn't that important to the thing though.
This movie has very good special effects, for the most part. The techno-ish music in the background fits the mood very well. Bruce Willis is an illegal taxi-cab driver in a futuristic New York City. One day a lady draped with a few bandages drops down into his trunk. This movie is about what happens.
The plot twists are interesting and the movie never fails to present the viewer with a variety of different locations. Also there is a fair bit of action in the film, particularly towards the end. Some characters are just plain strange including a highly-energetic deejay in drag. Bruce Willis does his normal job of blowing things away like he always does.
The movie is definitely watchable and rarely slows down. It is one of those sci-fi films where you'll be saying "cool" followed by a "what the hell?!?!". I give The Fifth Element *** out of ****.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 4
Dietary
Aubergines are wonderful roasted, serve with couscous and topped with chickpeas to make this flavourful vegetarian dish.
With a GI of 43 this meal is
high protein, low GI
and provides 202 kcal per portion.
Preheat the oven to 200C/180C Fan/Gas 6.
Cut the aubergines in half from top to bottom and score in a criss-cross pattern through the flesh. Place on a small baking tray and spray with oil. Season with a little black pepper and bake for 30-40 minutes or until very tender and lightly browned.
Meanwhile, spray a large non-stick frying pan with oil and place over a medium heat. Add the onion and cook for five minutes, stirring regularly until softened and lightly browned. Add the cumin, coriander, chilli and cinnamon and cook for a few seconds, stirring constantly.
Pour the tomatoes into the pan. Add the pepper, courgette, chickpeas, coriander and stock. Season with a little salt and lots of ground black pepper and bring to a gentle simmer. Cook for around 20 minutes, stirring occasionally until the vegetables are tender and the sauce is thick.
Just before the sauce is ready, make the couscous. Dissolve the stock cube in 100ml/3½fl oz just-boiled water in a medium bowl. Stir in the couscous, cover and rest for three minutes. Add the lemon zest, coriander and season to taste. Toss well together, using a fork to break up the clumps of couscous.
Divide the aubergines between two plates. Stir the lemon juice into the chickpeas and season to taste. Spoon the spiced chickpeas over the aubergines. Add the couscous and sprinkle with chopped nuts. Garnish with coriander and yoghurt.


Base class for pure substances of one chemical substance
| Name | Description |
|---|---|
| setState_pT | Return thermodynamic state from p and T |
| setState_ph | Return thermodynamic state from p and h |
| setState_ps | Return thermodynamic state from p and s |
| setState_dT | Return thermodynamic state from d and T |
| density_ph | Return density from p and h |
| temperature_ph | Return temperature from p and h |
| pressure_dT | Return pressure from d and T |
| specificEnthalpy_dT | Return specific enthalpy from d and T |
| specificEnthalpy_ps | Return specific enthalpy from p and s |
| temperature_ps | Return temperature from p and s |
| density_ps | Return density from p and s |
| specificEnthalpy_pT | Return specific enthalpy from p and T |
| density_pT | Return density from p and T |
| BaseProperties |


array([[ 3., 2., 1., 1., 1., 1., 1., 1., 1.],
[ 2., 2., 0., 0., 1., 1., 1., 0., 1.],
[ 1., 0., 1., 1., 0., 0., 0., 1., 0.],
[ 1., 0., 1., 1., 0., 0., 0., 1., 0.],
[ 1., 1., 0., 0., 1., 1., 0., 0., 0.],
[ 1., 1., 0., 0., 1., 1., 0., 0., 0.],
[ 1., 1., 0., 0., 0., 0., 1., 0., 1.],
[ 1., 0., 1., 1., 0., 0., 0., 1., 0.],
[ 1., 1., 0., 0., 0., 0., 1., 0., 1.]])
Social Network Analysis¶
Note
A Touch of Cloth,linked in countless ways. – old Chinese proverb
Co-occurrence Network¶
Co-occurrence networks are generally used to provide a graphic visualization of potential relationships between people, organizations, concepts or other entities represented within written material. The generation and visualization of co-occurrence networks has become practical with the advent of electronically stored text amenable to text mining.
Methodology¶
There are four main components in this algorithm in the algorithm: Corpus C, Document-Term matrix D, Term-Document matrix and Adjacency Matrix A. In this demo part, I will show how to build those four main components.
Given that we have three groups of friends, they are
Then we can build the following corpus based on the unique elements in the given group data:
The corresponding elements frequency:
Coding Puzzle from my interview¶
The attached utf-8 encoded text file contains the tags associated with an online biomedical scientific article formatted as follows (size: 100000). Each Scientific article is represented by a line in the file delimited by carriage return.
Write a program that, using this file as input, produces a list of pairs of tags which appear TOGETHER in any order and position in at least fifty different Scientific articles. For example, in the above sample, [Female] and [Humans] appear together twice, but every other pair appears only once. Your program should output the pair list to stdout in the same form as the input (eg tag 1, tag 2n).
The corresponding Co-occurrence network:
Then you will get Figure Co-occurrence network
Correlation Network¶


DESPERATE RESCUE: THE CATHY MAHONE STORY A film review by Ken Johnson Copyright 1993 Ken Johnson
98 min., not rated, Drama, 1993, Made-for-American-Television Director: Richard Colla Cast: Mariel Hemingway, Clancy Brown, Jeff Kober, James Russo, Lindsey Haun, Andrew Masset, Graham Beckel, Laura Innes, Maria O'Brien
Andrew Masset, Mariel Hemingway's ex-husband, abducts their daughter Lindsey Haun and goes to his home country of Jordan. The United States government won't help Hemingway get Haun back, because by Jordanian laws Masset has all rights over her. Hemingway hires three ex-Delta Force commandos to help her get back her daughter.
DESPERATE RESCUE: THE CATHY MAHONE STORY aired on NBC on January 18. I expect because of the high quality of this film, that it will be repeated again, and may possibly be released on home video. DESPERATE RESCUE is an excellent film that I highly recommend you attempt to see. DESPERATE RESCUE is of such high quality, that it doesn't look like a television film, but like a theatrical release. This film appears to have a large budget, which the film makers used very well. I give DESPERATE RESCUE a five on a scale of zero to five.
The performances in this film are excellent. Especially Mariel Hemingway ("Civil Wars", STEAL THE SKY); and Clancy Brown (BAD BOYS, HIGHLANDER), Jeff Kober (THE FIRST POWER), and James Russo (COLD HEAVEN, BEVERLY HILLS COP), who played the ex-Delta Force commandos. Lindsey Haun also gives a great performance and Andrew Masset gives a very good performance.
The locations used for this film are excellent. DESPERATE RESCUE was partly filmed in Israel, where some of the film actually takes place, and the scenery is beautiful. The buildings used, of which I expect most really exist, are excellent and the vehicles used are great.
DESPERATE RESCUE is very well written and kept up my interest throughout the film. The film starts out a little slow, but the rest of the film more than makes up for it. The film is based on a true story. How closely the film follows what really happened, I don't know.
-------- Ken Johnson<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Hello, my name is Christian Pecaut. I'm the inheritor of a new system of analysis, a theory of principled hierarchies, that was developed by an independent social researcher in the 1980's. He tragically died in the early 00's, and I have since tried to carry on his work.


Sama The Llama
About
Portfolio
Contact
Portfolio
Sweets
Hoops
Badminton
Volleyball
Music
Graphic Design
Connect with Me