A state corresponds to a "place" in the application in terms of the overall UI and navigation.
The UI-Router is a routing framework for AngularJS built by the AngularUI team. It provides a different approach than ngRoute in that it changes your application views based on state of the application and not just the route URL.
A state describes (via the controller / template / view properties) what the UI looks like and does at that place. States often have things in common, and the primary way of factoring out these commonalities in this model is via the state hierarchy, i.e. parent/child states aka nested states.
Using resolve in UI-router($stateProvider) is powerful, because it allows you to provide your controller with data before it gets loaded
$stateProvider.state('frontend.controller', {
url: '/controller',
templateUrl: 'views/frontend.controller.html',
controller: 'GoatsCtrl', // Referring to the controller
controllerAs: 'goats', // Binding the controller to a specific variable
// Promises that will be resolved before the State is changed
resolve: {
// load all the available goats form the GoatsService
goats: ['GoatsService',
function(GoatsService) {
return GoatsService.getGoats();
}
],
// The Controllers expects a promise for a single goat,
goat: function() {
return {};
},
// Tutorial Services.
addBreadCrumb: function(BreadCrumbService) {
BreadCrumbService.add('frontend.main', 'Frontend');
BreadCrumbService.add('frontend.controller', 'Controller');
},
addReferences: function(ReferencesService) {
ReferencesService.add('https://scotch.io/tutorials/making-skinny-angularjs-controllers', 'https://scotch.io/tutorials/making-skinny-angularjs-controllers', 'Scotch.io');
}
},
})
A state describes (via the controller / template / view properties) what the UI looks like and does at that place. States often have things in common, and the primary way of factoring out these commonalities in this model is via the state hierarchy, i.e. parent/child states aka nested states.
$stateProvider
.state('frontend', {
url: '/frontend',
templateUrl: 'views/frontend.html',
controller: ['BreadCrumbService', 'ReferencesService', function(BreadCrumbService, ReferencesService) {
var self = this;
self.breadCrumbs = BreadCrumbService.crumbs;
self.references = ReferencesService.references;
return self;
}],
controllerAs: 'frontend',
abstract: true
})
.state('frontend.main', {
url: '/main',
templateUrl: 'views/frontend.main.html',
resolve: {
addBreadCrumb: function(BreadCrumbService) {
BreadCrumbService.add('frontend.main', 'Frontend');
}
}
})


Contact
As an internet based company, we prefer to handle all questions
regarding your order, products on our website or general information
about Cat club through the form provided below. This also works as a
great "paper-trail" for record keeping. Most messages are responded to
in less than 24 hours. You can fill out the form or send us an email at
<EMAIL_ADDRESS>If you must call, we are usually available Mon. - Fri. 10am - 4pm EST at<PHONE_NUMBER>.
If you get a recording please leave your name, phone number, order number
and a brief message and we will get back to you as soon as possible.


If one kaing holds 272 atises about how many atises are there in 21 kaing?
How will you solve for the answer to the given problem ?
The phrase “about how many“ does not ask for an actual answer but an estimate. You will estimate the product to solve for the answer.
Study the solution below :
Round each of the factors to its highest place value , then multiply the rounded numbers.
Answer : There are about 6000 atises in 21 kaing.
You can find the actual product to check if the estimated product is reasonable.
Notice that the estimated product is close to the actual product.


Renew books; check due dates; save records
Request books, articles, and more from other libraries; review due dates
Register to research, schedule visits, and order copies at Burns Library
Borrow and renew popular ebooks and audiobooks


Upload File to update index/type
{% block content %}
Hmmm... there's no content here.
{% endblock %}


Reunions: Oklahoma high school reunions
Midwest City
Carl Albert High School class of 1970: Looking for classmates for a 50th reunion. For more information, email<EMAIL_ADDRESS>or go to facebook.com/groups/1468681683142392/.
Oklahoma City
Capitol Hill High School class of 1960: Ladies monthly lunch, third Thursday. Location changes. Please RSVP one week before. For more information, contact Connie at 634-3854.
Capitol Hill High School class of 1960: Monthly lunch, 11:30 a.m. first Tuesday, Grill on the Hill, 324 SW 25. No registration needed. For more information, call Ed Hendrix at 249-4474.
Capitol Hill High School class of 1961: Monthly lunch, 11:30 a.m. first Tuesday, Grill on the Hill, 324 SW 25. No registration needed.
Capitol Hill High School class of 1962: Monthly lunch, 11:30 a.m. first Wednesday, Grill on the Hill, 324 SW. 25. No registration needed.
Capitol Hill High School class of 1963: Monthly lunch, 11:30 a.m. first Monday, Grill on the Hill, 324 SW 25. No registration needed.
Capitol Hill High School class of 1964: Monthly lunch, 11 a.m. last Monday, Grill on the Hill, 324 SW 25. All classes welcome.
Capitol Hill High School class of 1970: Looking for classmates for a 50th reunion in 2020. For more information, email<EMAIL_ADDRESS>or call Larry Clark at<PHONE_NUMBER>.
Classen High School class of 1965: Looking for classmates for a 55th reunion. For more information, email<EMAIL_ADDRESS>John Marshall High School class of 1968: Monthly lunch, 11:30 a.m. first Monday, Johnnie's Charcoal Broiler, 2652 W Britton Road. For more information, contact Halcy Hall at<EMAIL_ADDRESS>John Marshall High School class of 1970: Looking for classmates for a 50th reunion June 5-6. For more information, email<EMAIL_ADDRESS>Northeast High School class of 1969: Looking for classmates for a 50th reunion Nov. 29. For more information, contact Sheryl (Thomas) Jones at 608-0318 or email<EMAIL_ADDRESS>Southeast High School class of 1956: 5:30 p.m. every second Tuesday, Western Sizzlin, Interstate 240 and S Pennsylvania. Call Pete White at 232-8888.
Southeast High School class of 1958: Monthly breakfast, 9 a.m. every first Thursday, Denny's, Interstate 240 and S Pennsylvania. Call Bob at 634-0777 or email<EMAIL_ADDRESS>Southeast High School class of 1960: Monthly meeting, 11:30 a.m. third Tuesday, Grill on the Hill, 324 SW 25. Call Glenda (Crist) McConnell at 378-2865.
U.S. Grant High School class of 1959: 9 a.m. every second Tuesday, Denny's, Interstate 240 service road and Pennsylvania. For more information, email Robert Greenwell at<EMAIL_ADDRESS>U.S. Grant High School class of 1961: 9:30 a.m. every third Monday, Grill on the Hill, 324 SW 25. For more information, email Sidney Smith Hartman at<EMAIL_ADDRESS>U.S. Grant High School class of 1965: Monthly lunch, 11:30 a.m. every last Thursday, Hollies Flatiron in Moore. For more information, contact Vickie Munsey at<EMAIL_ADDRESS>To submit a reunion, email DLindauer@Oklahoman.com.


Lecture 4
#SyntaxSwag
A function can have multiple patterns
Almost like overloading methods in Java or C++
guess :: Int -> [Char]
guess 42 = "correct!"
guess x = "wrong guess!"
Each pattern has the same type decelerationp>
Patterns are matched in order, top-down
Only the first matched pattern is evaluated
The patterns must exhaust the entire domain
fib :: Int -> Int
fib n = fib(n-1) + fib(n-2)
fib 0 = 1
fib 1 = 1
The base case is never hit.

The "_" symbol is called a wildcard in Haskell.
This is how it's used:
head (x:_) = x
tail (_:xs) = xs
When GHCi is angry, it produces error messages through the error
function.
error :: [Char] -> a
The official implementation of head
is
head :: [a] -> a
head (x:_) = x
head [] = error "Prelude.head: empty list"
Guards are clean if
statements.
Just like with pattern matching, order matters.
A guard is introduced by the |
symbol.
And it's followed by a Bool expression.
Then followed by the function body
guessMyNumber x
| x > 27 = "Too high!"
| x < 27 = "Too low!"
| otherwise = "Correct!"
otherwise
is just a fancy word for True
Guards are very powerful.
Anything done with pattern matching can be done with guards.
head'' :: [a] -> a
head'' xs
| null xs = error "list is empty"
| otherwise = xs !! 0
These are not like your typical Java variables
In Java or C++, you can redefine variables:
x = 1;
...
x = 2;
Mathematically, this makes no sense.
1=2
Preposterous!Haskell variables are immutable.
Once defined, they can't change.
They can be used with the let
keyword.
slope (x1,y1) (x2,y2) = let dy = y2-y1
dx = x2-x1
in dy/dx
Or with the where
keyword.
slope (x1,y1) (x2,y2) = dy/dx
where dy = y2-y1
dx = x2-x1
In Haskell, indentation matters.
Level-1
Level-2
Level-3
Level-3
Level-3
Level-2
Level-3
Level-3
Level-1
Level-2
Level-2
Level-1
Don't use tab. Use spaces '
'.
Convert between metric and imperial.
convert :: (Double, [Char]) -> (Double, [Char])
Prelude> convert (1, "m")
(1.09361, "yd")
Prelude> convert (1, "L")
(0.264172, "gal")
Prelude> convert (1, "kg")
(2.20462, "lb")


Design is the art of expressing thoughts. It is a freehand manifestation of vision. It is the draftsman’s job to use lab instruments to reflect that vision into precision. The purpose of design is to understand how best we can absorb natural elements spread all around us.
Lack of knowledge creates too many complexities around us. Outside wisdom is unlikely to remove these intricacies. It is from the study of the self, through concentration and practice, emerges design. Total simplicity of the cosmic order. From creation to another creation, and yet another. Unlimited forms, shapes, variants and matter – all bound together by the invisible force of life.
Symmetry in true harmony, yet not perfectly symmetrical. Continuous friction causing everything to turn round-cornered. How visually appealing look the electrons in an atom, or iOS icons! It is that appeal in the design that raises inquisitiveness to know more of the unknown. Sometimes, even surpassing logic.
Inter-dependence is intrinsic to design. Just like in a machine, different parts behave differently to serve distinct objectives; and to that end not only do they work in harmony but also are interdependent, to receive and to deliver, meeting the intended aim. Civilization, spread through thousands of years of natural evolution, has established societies functioning with different classes of people in total inter-dependence. A similar inter-dependence is between How and Why. When you understand the objective and the context of a work, that’s when you answer How and start to make it useful.
The relationship between form and purpose—How and Why—is symbiotic. But despite this link, Why is usually neglected, because How is more easily framed. It is easier to recognize failures of technique than those of strategy or purpose, and simpler to ask “How do I paint this tree?” than to answer “Why does this painting need a tree in it?”
Design is future. It is a reaction against the contemporary, both technology and belief system. It is basically a blueprint which lays the foundation for newer development. Design is simplification, but not just limited to the removal of clutter: How the whole thing works on so many levels; bringing order to complexity; giving the user what they want only when they want it. From a watch to a coffee mug to a scooter, there is a profound beauty in simplicity, clarity, and efficiency.
I believe in design, not decoration. Making things useful, not usable. Crafting experiences, not interfaces.


e-pigeon
Implementation of an handmade application protocol for messaging
Be careful this is an alpha version of the software and many bugs can be found in it. If you use it and found some, please create an issue, it can be helpful.
What does it do ?
That's a simple messaging server / client using node-ipc in the hood\ It garantee the order of sended messages and that the message has been received.\ You can send a message to a group of clients.\ Server cannot receive message, but you can start a client in the same app of the server and will use localhost to communicate.
Getting started
Works on node 8+\
Install it with npm i @lug/e-pigeon
You can check example for an simple use of this module.
Server
const { EPigeonServer } = require('@lug/e-pigeon')
const server = new EPigeonServer()
server.serve(9999)
Client
const { EPigeonClient } = require('@lug/e-pigeon')
const client = new EPigeonClient()
client.connect('host', 9999)
Documentation
For debugging, you can set the env debug variable to epigeon:*
like described in the debug module
Server
Methods
| name | params | description |
|---|---|---|
| serve | port:Int | serve on this port |
| stop | - | stop the server |
Client
Methods
| name | params | description |
|---|---|---|
| connect | host:string / port:Int | connect to server |
| disconnect | - | disconnect from server |
| updateSession | {key:value,...} | set values to your client session |
| sendMessage | to: uuid or {key:value} / content:any | send a message to a uuid or to all client that match the key:value on their session |
Events
You can add en event handler with client.on(<event>, <callback>)
| event | callback params | description |
|---|---|---|
| connected | - | when the client is connected to the server |
| disconnected | - | when the client is disconnected |
| authenticated | - | when the client is authenticated |
| session.update | {uuid, session} | when a client update his session |
| message | message | when a message is recieved, contains many things but the content is stored in message.payload |
| client.connect | uuid | when a client connect to the server |
| client.disconnect | uuid | when a client disconnect from the server |


Try to shoot as many blobs as possible by moving and shooting with the controller.
As you level up, your accuracy gets higher, but be wary of missing too many blobs or game over...
During gameplay you'll be able to catch some powerups to improve accuracy or get some bonus points.
May the best marksman win!


menu
Games - PYX Reloaded
Search
search
refresh
format_paint
exit_to_app
No games available.
add
casino
{{Name of Player's Game}}
{{Likes}}
{{Dislikes}}
Players:
Spectators:
Goal:
Decks:
JOIN
SPECTATE
thumb_up
thumb_down


|
M4521 BSP V3.01.000
The Board Support Package for M4521
|
Macros | |
| #define | PWM_ENABLE_COMPLEMENTARY_MODE(pwm) |
| This macro enable complementary mode. More... | |
| #define | PWM_DISABLE_COMPLEMENTARY_MODE(pwm) |
| This macro disable complementary mode, and enable independent mode. More... | |
| #define | PWM_ENABLE_GROUP_MODE(pwm) |
| This macro enable group mode. More... | |
| #define | PWM_DISABLE_GROUP_MODE(pwm) |
| This macro disable group mode. More... | |
| #define | PWM_ENABLE_TIMER_SYNC(pwm, u32ChannelMask) |
| Enable timer synchronous mode of specified channel(s) More... | |
| #define | PWM_DISABLE_TIMER_SYNC(pwm, u32ChannelMask) |
| Disable timer synchronous mode of specified channel(s) More... | |
| #define | PWM_ENABLE_OUTPUT_INVERTER(pwm, u32ChannelMask) |
| This macro enable output inverter of specified channel(s) More... | |
| #define | PWM_GET_CAPTURE_RISING_DATA(pwm, u32ChannelNum) |
| This macro get captured rising data. More... | |
| #define | PWM_GET_CAPTURE_FALLING_DATA(pwm, u32ChannelNum) |
| This macro get captured falling data. More... | |
| #define | PWM_MASK_OUTPUT(pwm, u32ChannelMask, u32LevelMask) |
| This macro mask output logic to high or low. More... | |
| #define | PWM_SET_PRESCALER(pwm, u32ChannelNum, u32Prescaler) |
| This macro set the prescaler of the selected channel. More... | |
| #define | PWM_SET_CMR(pwm, u32ChannelNum, u32CMR) |
| This macro set the comparator of the selected channel. More... | |
| #define | PWM_SET_FTCMR(pwm, u32ChannelNum, u32FTCMR) |
| This macro set the free trigger comparator of the selected channel. More... | |
| #define | PWM_SET_CNR(pwm, u32ChannelNum, u32CNR) |
| This macro set the period of the selected channel. More... | |
| #define | PWM_SET_ALIGNED_TYPE(pwm, u32ChannelMask, u32AlignedType) |
| This macro set the PWM aligned type. More... | |
| #define | PWM_SET_LOAD_WINDOW(pwm, u32ChannelMask) |
| Set load window of window loading mode for specified channel(s) More... | |
| #define | PWM_TRIGGER_SYNC(pwm, u32ChannelNum) |
| Trigger synchronous event from specified channel(s) More... | |
| #define | PWM_CLR_COUNTER(pwm, u32ChannelMask) |
| Clear counter of specified channel(s) More... | |
| #define | PWM_SET_OUTPUT_LEVEL(pwm, u32ChannelMask, u32ZeroLevel, u32CmpUpLevel, u32PeriodLevel, u32CmpDownLevel) |
| Set output level at zero, compare up, period(center) and compare down of specified channel(s) More... | |
| #define | PWM_TRIGGER_BRAKE(pwm, u32ChannelMask, u32BrakeType) |
| Trigger brake event from specified channel(s) More... | |
| #define | PWM_SET_DEADZONE_CLK_SRC(pwm, u32ChannelNum, u32AfterPrescaler) |
| Set Dead zone clock source. More... | |
Functions | |
| uint32_t | PWM_ConfigCaptureChannel (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32UnitTimeNsec, uint32_t u32CaptureEdge) |
| Configure PWM capture and get the nearest unit time. More... | |
| uint32_t | PWM_ConfigOutputChannel (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32Frequency, uint32_t u32DutyCycle) |
| This function Configure PWM generator and get the nearest frequency in edge aligned auto-reload mode. More... | |
| void | PWM_Start (PWM_T *pwm, uint32_t u32ChannelMask) |
| Start PWM module. More... | |
| void | PWM_Stop (PWM_T *pwm, uint32_t u32ChannelMask) |
| Stop PWM module. More... | |
| void | PWM_ForceStop (PWM_T *pwm, uint32_t u32ChannelMask) |
| Stop PWM generation immediately by clear channel enable bit. More... | |
| void | PWM_EnableADCTrigger (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32Condition) |
| Enable selected channel to trigger EADC. More... | |
| void | PWM_DisableADCTrigger (PWM_T *pwm, uint32_t u32ChannelNum) |
| Disable selected channel to trigger EADC. More... | |
| void | PWM_ClearADCTriggerFlag (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32Condition) |
| Clear selected channel trigger EADC flag. More... | |
| uint32_t | PWM_GetADCTriggerFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Get selected channel trigger EADC flag. More... | |
| void | PWM_EnableFaultBrake (PWM_T *pwm, uint32_t u32ChannelMask, uint32_t u32LevelMask, uint32_t u32BrakeSource) |
| This function enable fault brake of selected channel(s) More... | |
| void | PWM_EnableCapture (PWM_T *pwm, uint32_t u32ChannelMask) |
| Enable capture of selected channel(s) More... | |
| void | PWM_DisableCapture (PWM_T *pwm, uint32_t u32ChannelMask) |
| Disable capture of selected channel(s) More... | |
| void | PWM_EnableOutput (PWM_T *pwm, uint32_t u32ChannelMask) |
| Enables PWM output generation of selected channel(s) More... | |
| void | PWM_DisableOutput (PWM_T *pwm, uint32_t u32ChannelMask) |
| Disables PWM output generation of selected channel(s) More... | |
| void | PWM_EnablePDMA (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32RisingFirst, uint32_t u32Mode) |
| Enables PDMA transfer of selected channel for PWM capture. More... | |
| void | PWM_DisablePDMA (PWM_T *pwm, uint32_t u32ChannelNum) |
| Disables PDMA transfer of selected channel for PWM capture. More... | |
| void | PWM_EnableDeadZone (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32Duration) |
| Enable Dead zone of selected channel. More... | |
| void | PWM_DisableDeadZone (PWM_T *pwm, uint32_t u32ChannelNum) |
| Disable Dead zone of selected channel. More... | |
| void | PWM_EnableCaptureInt (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32Edge) |
| Enable capture interrupt of selected channel. More... | |
| void | PWM_DisableCaptureInt (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32Edge) |
| Disable capture interrupt of selected channel. More... | |
| void | PWM_ClearCaptureIntFlag (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32Edge) |
| Clear capture interrupt of selected channel. More... | |
| uint32_t | PWM_GetCaptureIntFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Get capture interrupt of selected channel. More... | |
| void | PWM_EnableDutyInt (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32IntDutyType) |
| Enable duty interrupt of selected channel. More... | |
| void | PWM_DisableDutyInt (PWM_T *pwm, uint32_t u32ChannelNum) |
| Disable duty interrupt of selected channel. More... | |
| void | PWM_ClearDutyIntFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Clear duty interrupt flag of selected channel. More... | |
| uint32_t | PWM_GetDutyIntFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Get duty interrupt flag of selected channel. More... | |
| void | PWM_EnableFaultBrakeInt (PWM_T *pwm, uint32_t u32BrakeSource) |
| This function enable fault brake interrupt. More... | |
| void | PWM_DisableFaultBrakeInt (PWM_T *pwm, uint32_t u32BrakeSource) |
| This function disable fault brake interrupt. More... | |
| void | PWM_ClearFaultBrakeIntFlag (PWM_T *pwm, uint32_t u32BrakeSource) |
| This function clear fault brake interrupt of selected source. More... | |
| uint32_t | PWM_GetFaultBrakeIntFlag (PWM_T *pwm, uint32_t u32BrakeSource) |
| This function get fault brake interrupt flag of selected source. More... | |
| void | PWM_EnablePeriodInt (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32IntPeriodType) |
| Enable period interrupt of selected channel. More... | |
| void | PWM_DisablePeriodInt (PWM_T *pwm, uint32_t u32ChannelNum) |
| Disable period interrupt of selected channel. More... | |
| void | PWM_ClearPeriodIntFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Clear period interrupt of selected channel. More... | |
| uint32_t | PWM_GetPeriodIntFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Get period interrupt of selected channel. More... | |
| void | PWM_EnableZeroInt (PWM_T *pwm, uint32_t u32ChannelNum) |
| Enable zero interrupt of selected channel. More... | |
| void | PWM_DisableZeroInt (PWM_T *pwm, uint32_t u32ChannelNum) |
| Disable zero interrupt of selected channel. More... | |
| void | PWM_ClearZeroIntFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Clear zero interrupt of selected channel. More... | |
| uint32_t | PWM_GetZeroIntFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Get zero interrupt of selected channel. More... | |
| void | PWM_EnableAcc (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32IntFlagCnt, uint32_t u32IntAccSrc) |
| Enable interrupt flag accumulator of selected channel. More... | |
| void | PWM_DisableAcc (PWM_T *pwm, uint32_t u32ChannelNum) |
| Disable interrupt flag accumulator of selected channel. More... | |
| void | PWM_EnableAccInt (PWM_T *pwm, uint32_t u32ChannelNum) |
| Enable interrupt flag accumulator interrupt of selected channel. More... | |
| void | PWM_DisableAccInt (PWM_T *pwm, uint32_t u32ChannelNum) |
| Disable interrupt flag accumulator interrupt of selected channel. More... | |
| void | PWM_ClearAccInt (PWM_T *pwm, uint32_t u32ChannelNum) |
| Clear interrupt flag accumulator interrupt of selected channel. More... | |
| uint32_t | PWM_GetAccInt (PWM_T *pwm, uint32_t u32ChannelNum) |
| Get interrupt flag accumulator interrupt of selected channel. More... | |
| void | PWM_ClearFTDutyIntFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Clear free trigger duty interrupt flag of selected channel. More... | |
| uint32_t | PWM_GetFTDutyIntFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Get free trigger duty interrupt flag of selected channel. More... | |
| void | PWM_EnableLoadMode (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32LoadMode) |
| Enable load mode of selected channel. More... | |
| void | PWM_DisableLoadMode (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32LoadMode) |
| Disable load mode of selected channel. More... | |
| void | PWM_ConfigSyncPhase (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32SyncSrc, uint32_t u32Direction, uint32_t u32StartPhase) |
| Configure synchronization phase of selected channel. More... | |
| void | PWM_EnableSyncPhase (PWM_T *pwm, uint32_t u32ChannelMask) |
| Enable SYNC phase of selected channel(s) More... | |
| void | PWM_DisableSyncPhase (PWM_T *pwm, uint32_t u32ChannelMask) |
| Disable SYNC phase of selected channel(s) More... | |
| void | PWM_EnableSyncNoiseFilter (PWM_T *pwm, uint32_t u32ClkCnt, uint32_t u32ClkDivSel) |
| Enable PWM SYNC_IN noise filter function. More... | |
| void | PWM_DisableSyncNoiseFilter (PWM_T *pwm) |
| Disable PWM SYNC_IN noise filter function. More... | |
| void | PWM_EnableSyncPinInverse (PWM_T *pwm) |
| Enable PWM SYNC input pin inverse function. More... | |
| void | PWM_DisableSyncPinInverse (PWM_T *pwm) |
| Disable PWM SYNC input pin inverse function. More... | |
| void | PWM_SetClockSource (PWM_T *pwm, uint32_t u32ChannelNum, uint32_t u32ClkSrcSel) |
| Set PWM clock source. More... | |
| void | PWM_EnableBrakeNoiseFilter (PWM_T *pwm, uint32_t u32BrakePinNum, uint32_t u32ClkCnt, uint32_t u32ClkDivSel) |
| Enable PWM brake noise filter function. More... | |
| void | PWM_DisableBrakeNoiseFilter (PWM_T *pwm, uint32_t u32BrakePinNum) |
| Disable PWM brake noise filter function. More... | |
| void | PWM_EnableBrakePinInverse (PWM_T *pwm, uint32_t u32BrakePinNum) |
| Enable PWM brake pin inverse function. More... | |
| void | PWM_DisableBrakePinInverse (PWM_T *pwm, uint32_t u32BrakePinNum) |
| Disable PWM brake pin inverse function. More... | |
| void | PWM_SetBrakePinSource (PWM_T *pwm, uint32_t u32BrakePinNum, uint32_t u32SelAnotherModule) |
| Set PWM brake pin source. More... | |
| uint32_t | PWM_GetWrapAroundFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Get the time-base counter reached its maximum value flag of selected channel. More... | |
| void | PWM_ClearWrapAroundFlag (PWM_T *pwm, uint32_t u32ChannelNum) |
| Clear the time-base counter reached its maximum value flag of selected channel. More... | |
| #define PWM_CLR_COUNTER | ( | pwm, | |
| u32ChannelMask | |||
| ) |
Clear counter of specified channel(s)
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Bit 0 represents channel 0, bit 1 represents channel 1... |
This macro is used to clear counter of specified channel(s).
| #define PWM_DISABLE_COMPLEMENTARY_MODE | ( | pwm | ) |
| #define PWM_DISABLE_GROUP_MODE | ( | pwm | ) |
| #define PWM_DISABLE_TIMER_SYNC | ( | pwm, | |
| u32ChannelMask | |||
| ) |
Disable timer synchronous mode of specified channel(s)
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Bit 0 represents channel 0, bit 1 represents channel 1... |
This macro is used to disable timer synchronous mode of specified channel(s).
| #define PWM_ENABLE_COMPLEMENTARY_MODE | ( | pwm | ) |
| #define PWM_ENABLE_GROUP_MODE | ( | pwm | ) |
| #define PWM_ENABLE_OUTPUT_INVERTER | ( | pwm, | |
| u32ChannelMask | |||
| ) |
This macro enable output inverter of specified channel(s)
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Bit 0 represents channel 0, bit 1 represents channel 1... |
This macro is used to enable output inverter of specified channel(s).
| #define PWM_ENABLE_TIMER_SYNC | ( | pwm, | |
| u32ChannelMask | |||
| ) |
Enable timer synchronous mode of specified channel(s)
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Bit 0 represents channel 0, bit 1 represents channel 1... |
This macro is used to enable timer synchronous mode of specified channel(s).
| #define PWM_GET_CAPTURE_FALLING_DATA | ( | pwm, | |
| u32ChannelNum | |||
| ) |
| #define PWM_GET_CAPTURE_RISING_DATA | ( | pwm, | |
| u32ChannelNum | |||
| ) |
| #define PWM_MASK_OUTPUT | ( | pwm, | |
| u32ChannelMask, | |||
| u32LevelMask | |||
| ) |
This macro mask output logic to high or low.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Bit 0 represents channel 0, bit 1 represents channel 1... |
| [in] | u32LevelMask | Output logic to high or low |
This macro is used to mask output logic to high or low of specified channel(s).
| #define PWM_SET_ALIGNED_TYPE | ( | pwm, | |
| u32ChannelMask, | |||
| u32AlignedType | |||
| ) |
This macro set the PWM aligned type.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Bit 0 represents channel 0, bit 1 represents channel 1... |
| [in] | u32AlignedType | PWM aligned type, valid values are: |
This macro is used to set the PWM aligned type of specified channel(s).
| #define PWM_SET_CMR | ( | pwm, | |
| u32ChannelNum, | |||
| u32CMR | |||
| ) |
This macro set the comparator of the selected channel.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32CMR | Comparator of specified channel. Valid values are between 0~0xFFFF |
This macro is used to set the comparator of specified channel.
| #define PWM_SET_CNR | ( | pwm, | |
| u32ChannelNum, | |||
| u32CNR | |||
| ) |
This macro set the period of the selected channel.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32CNR | Period of specified channel. Valid values are between 0~0xFFFF |
This macro is used to set the period of specified channel.
| #define PWM_SET_DEADZONE_CLK_SRC | ( | pwm, | |
| u32ChannelNum, | |||
| u32AfterPrescaler | |||
| ) |
Set Dead zone clock source.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32AfterPrescaler | Dead zone clock source is from prescaler output. Valid values are TRUE (after prescaler) or FALSE (before prescaler). |
This macro is used to set Dead zone clock source. Every two channels share the same setting.
| #define PWM_SET_FTCMR | ( | pwm, | |
| u32ChannelNum, | |||
| u32FTCMR | |||
| ) |
This macro set the free trigger comparator of the selected channel.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32FTCMR | Free trigger comparator of specified channel. Valid values are between 0~0xFFFF |
This macro is used to set the free trigger comparator of specified channel.
| #define PWM_SET_LOAD_WINDOW | ( | pwm, | |
| u32ChannelMask | |||
| ) |
Set load window of window loading mode for specified channel(s)
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Bit 0 represents channel 0, bit 1 represents channel 1... |
This macro is used to set load window of window loading mode for specified channel(s).
| #define PWM_SET_OUTPUT_LEVEL | ( | pwm, | |
| u32ChannelMask, | |||
| u32ZeroLevel, | |||
| u32CmpUpLevel, | |||
| u32PeriodLevel, | |||
| u32CmpDownLevel | |||
| ) |
Set output level at zero, compare up, period(center) and compare down of specified channel(s)
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Bit 0 represents channel 0, bit 1 represents channel 1... |
| [in] | u32ZeroLevel | output level at zero point, valid values are: |
| [in] | u32CmpUpLevel | output level at compare up point, valid values are: |
| [in] | u32PeriodLevel | output level at period(center) point, valid values are: |
| [in] | u32CmpDownLevel | output level at compare down point, valid values are: |
This macro is used to Set output level at zero, compare up, period(center) and compare down of specified channel(s).
| #define PWM_SET_PRESCALER | ( | pwm, | |
| u32ChannelNum, | |||
| u32Prescaler | |||
| ) |
This macro set the prescaler of the selected channel.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32Prescaler | Clock prescaler of specified channel. Valid values are between 1 ~ 0xFFF |
This macro is used to set the prescaler of specified channel.
| #define PWM_TRIGGER_BRAKE | ( | pwm, | |
| u32ChannelMask, | |||
| u32BrakeType | |||
| ) |
Trigger brake event from specified channel(s)
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Bit 0 represents channel 0, bit 1 represents channel 2 and bit 2 represents channel 4 |
| [in] | u32BrakeType | Type of brake trigger. |
This macro is used to trigger brake event from specified channel(s).
| #define PWM_TRIGGER_SYNC | ( | pwm, | |
| u32ChannelNum | |||
| ) |
Trigger synchronous event from specified channel(s)
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32ChannelNum | PWM channel number. Valid values are 0, 2, 4 Bit 0 represents channel 0, bit 1 represents channel 2 and bit 2 represents channel 4 |
This macro is used to trigger synchronous event from specified channel(s).
| void PWM_ClearAccInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Clear interrupt flag accumulator interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to clear interrupt flag accumulator interrupt of selected channel.
| void PWM_ClearADCTriggerFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32Condition | ||
| ) |
Clear selected channel trigger EADC flag.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32Condition | This parameter is not used |
This function is used to clear selected channel trigger EADC flag.
| void PWM_ClearCaptureIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32Edge | ||
| ) |
Clear capture interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32Edge | Rising or falling edge to latch counter. |
This function is used to clear capture interrupt of selected channel.
| void PWM_ClearDutyIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Clear duty interrupt flag of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to clear duty interrupt flag of selected channel.
| void PWM_ClearFaultBrakeIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32BrakeSource | ||
| ) |
This function clear fault brake interrupt of selected source.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32BrakeSource | Fault brake source. |
This function is used to clear fault brake interrupt of selected source. The write-protection function should be disabled before using this function.
| void PWM_ClearFTDutyIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Clear free trigger duty interrupt flag of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to clear free trigger duty interrupt flag of selected channel.
| void PWM_ClearPeriodIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Clear period interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to clear period interrupt of selected channel.
| void PWM_ClearWrapAroundFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Clear the time-base counter reached its maximum value flag of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to clear the time-base counter reached its maximum value flag of selected channel.
| void PWM_ClearZeroIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Clear zero interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to clear zero interrupt of selected channel.
| uint32_t PWM_ConfigCaptureChannel | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32UnitTimeNsec, | ||
| uint32_t | u32CaptureEdge | ||
| ) |
Configure PWM capture and get the nearest unit time.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32UnitTimeNsec | The unit time of counter |
| [in] | u32CaptureEdge | The condition to latch the counter. This parameter is not used |
This function is used to Configure PWM capture and get the nearest unit time.
Definition at line 38 of file pwm.c.
| uint32_t PWM_ConfigOutputChannel | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32Frequency, | ||
| uint32_t | u32DutyCycle | ||
| ) |
This function Configure PWM generator and get the nearest frequency in edge aligned auto-reload mode.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32Frequency | Target generator frequency |
| [in] | u32DutyCycle | Target generator duty cycle percentage. Valid range are between 0 ~ 100. 10 means 10%, 20 means 20%... |
Definition at line 102 of file pwm.c.
| void PWM_ConfigSyncPhase | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32SyncSrc, | ||
| uint32_t | u32Direction, | ||
| uint32_t | u32StartPhase | ||
| ) |
Configure synchronization phase of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32SyncSrc | PWM synchronize source selection. |
| [in] | u32Direction | Phase direction. Control PWM counter count decrement or increment after synchronizing. |
| [in] | u32StartPhase | Synchronous start phase value. Valid values are between 0~65535. |
This function is used to configure synchronization phase of selected channel.
| void PWM_DisableAcc | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Disable interrupt flag accumulator of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to Disable interrupt flag accumulator of selected channel.
| void PWM_DisableAccInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Disable interrupt flag accumulator interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to disable interrupt flag accumulator interrupt of selected channel.
| void PWM_DisableADCTrigger | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Disable selected channel to trigger EADC.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to disable selected channel to trigger EADC.
| void PWM_DisableBrakeNoiseFilter | ( | PWM_T * | pwm, |
| uint32_t | u32BrakePinNum | ||
| ) |
Disable PWM brake noise filter function.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32BrakePinNum | Brake pin selection. Valid values are 0 or 1. |
This function is used to disable PWM brake noise filter function.
| void PWM_DisableBrakePinInverse | ( | PWM_T * | pwm, |
| uint32_t | u32BrakePinNum | ||
| ) |
Disable PWM brake pin inverse function.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32BrakePinNum | Brake pin selection. Valid values are 0 or 1. |
This function is used to disable PWM brake pin inverse function.
| void PWM_DisableCapture | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask | ||
| ) |
Disable capture of selected channel(s)
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel. Bit 0 is channel 0, bit 1 is channel 1... |
This function is used to disable capture of selected channel(s).
| void PWM_DisableCaptureInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32Edge | ||
| ) |
Disable capture interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32Edge | Rising or falling edge to latch counter. |
This function is used to disable capture interrupt of selected channel.
| void PWM_DisableDeadZone | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Disable Dead zone of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to disable Dead zone of selected channel. The write-protection function should be disabled before using this function.
| void PWM_DisableDutyInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Disable duty interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to disable duty interrupt of selected channel.
| void PWM_DisableFaultBrakeInt | ( | PWM_T * | pwm, |
| uint32_t | u32BrakeSource | ||
| ) |
This function disable fault brake interrupt.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32BrakeSource | Fault brake source. |
This function is used to disable fault brake interrupt. The write-protection function should be disabled before using this function.
| void PWM_DisableLoadMode | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32LoadMode | ||
| ) |
Disable load mode of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32LoadMode | PWM counter loading mode. |
This function is used to disable load mode of selected channel.
| void PWM_DisableOutput | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask | ||
| ) |
Disables PWM output generation of selected channel(s)
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel Set bit 0 to 1 disables channel 0 output, set bit 1 to 1 disables channel 1 output... |
This function is used to disable PWM output generation of selected channel(s).
| void PWM_DisablePDMA | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Disables PDMA transfer of selected channel for PWM capture.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. |
This function is used to enable PDMA transfer of selected channel(s) for PWM capture.
| void PWM_DisablePeriodInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Disable period interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to disable period interrupt of selected channel.
| void PWM_DisableSyncNoiseFilter | ( | PWM_T * | pwm | ) |
| void PWM_DisableSyncPhase | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask | ||
| ) |
Disable SYNC phase of selected channel(s)
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel. Bit 0 is channel 0, bit 1 is channel 1... |
This function is used to disable SYNC phase of selected channel(s).
| void PWM_DisableSyncPinInverse | ( | PWM_T * | pwm | ) |
| void PWM_DisableZeroInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Disable zero interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to disable zero interrupt of selected channel.
| void PWM_EnableAcc | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32IntFlagCnt, | ||
| uint32_t | u32IntAccSrc | ||
| ) |
Enable interrupt flag accumulator of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32IntFlagCnt | Interrupt flag counter. Valid values are between 0~15. |
| [in] | u32IntAccSrc | Interrupt flag accumulator source selection. |
This function is used to enable interrupt flag accumulator of selected channel.
| void PWM_EnableAccInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Enable interrupt flag accumulator interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to enable interrupt flag accumulator interrupt of selected channel.
| void PWM_EnableADCTrigger | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32Condition | ||
| ) |
Enable selected channel to trigger EADC.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32Condition | The condition to trigger EADC. Combination of following conditions:
|
This function is used to enable selected channel to trigger EADC.
| void PWM_EnableBrakeNoiseFilter | ( | PWM_T * | pwm, |
| uint32_t | u32BrakePinNum, | ||
| uint32_t | u32ClkCnt, | ||
| uint32_t | u32ClkDivSel | ||
| ) |
Enable PWM brake noise filter function.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32BrakePinNum | Brake pin selection. Valid values are 0 or 1. |
| [in] | u32ClkCnt | SYNC Edge Detector Filter Count. This controls the counter number of edge detector |
| [in] | u32ClkDivSel | SYNC Edge Detector Filter Clock Selection. |
This function is used to enable PWM brake noise filter function.
| void PWM_EnableBrakePinInverse | ( | PWM_T * | pwm, |
| uint32_t | u32BrakePinNum | ||
| ) |
Enable PWM brake pin inverse function.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32BrakePinNum | Brake pin selection. Valid values are 0 or 1. |
This function is used to enable PWM brake pin inverse function.
| void PWM_EnableCapture | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask | ||
| ) |
Enable capture of selected channel(s)
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel. Bit 0 is channel 0, bit 1 is channel 1... |
This function is used to enable capture of selected channel(s).
| void PWM_EnableCaptureInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32Edge | ||
| ) |
Enable capture interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32Edge | Rising or falling edge to latch counter. |
This function is used to enable capture interrupt of selected channel.
| void PWM_EnableDeadZone | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32Duration | ||
| ) |
Enable Dead zone of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32Duration | Dead zone length in PWM clock count, valid values are between 0~0xFFF, but 0 means there is no Dead zone. |
This function is used to enable Dead zone of selected channel. The write-protection function should be disabled before using this function.
| void PWM_EnableDutyInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32IntDutyType | ||
| ) |
Enable duty interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32IntDutyType | Duty interrupt type, could be either |
This function is used to enable duty interrupt of selected channel.
| void PWM_EnableFaultBrake | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask, | ||
| uint32_t | u32LevelMask, | ||
| uint32_t | u32BrakeSource | ||
| ) |
This function enable fault brake of selected channel(s)
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel. |
| [in] | u32LevelMask | Output high or low while fault brake occurs, each bit represent the level of a channel while fault brake occurs. Bit 0 represents channel 0, bit 1 represents channel 1... |
| [in] | u32BrakeSource | Fault brake source, could be one of following source |
This function is used to enable fault brake of selected channel(s). The write-protection function should be disabled before using this function.
| void PWM_EnableFaultBrakeInt | ( | PWM_T * | pwm, |
| uint32_t | u32BrakeSource | ||
| ) |
This function enable fault brake interrupt.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32BrakeSource | Fault brake source. |
This function is used to enable fault brake interrupt. The write-protection function should be disabled before using this function.
| void PWM_EnableLoadMode | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32LoadMode | ||
| ) |
Enable load mode of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32LoadMode | PWM counter loading mode. |
This function is used to enable load mode of selected channel.
| void PWM_EnableOutput | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask | ||
| ) |
Enables PWM output generation of selected channel(s)
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel. Set bit 0 to 1 enables channel 0 output, set bit 1 to 1 enables channel 1 output... |
This function is used to enable PWM output generation of selected channel(s).
| void PWM_EnablePDMA | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32RisingFirst, | ||
| uint32_t | u32Mode | ||
| ) |
Enables PDMA transfer of selected channel for PWM capture.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. |
| [in] | u32RisingFirst | The capture order is rising, falling first. Every two channels share the same setting. Valid values are TRUE and FALSE. |
| [in] | u32Mode | Captured data transferred by PDMA interrupt type. It could be either |
This function is used to enable PDMA transfer of selected channel(s) for PWM capture.
| void PWM_EnablePeriodInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32IntPeriodType | ||
| ) |
Enable period interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32IntPeriodType | Period interrupt type. This parameter is not used. |
This function is used to enable period interrupt of selected channel.
| void PWM_EnableSyncNoiseFilter | ( | PWM_T * | pwm, |
| uint32_t | u32ClkCnt, | ||
| uint32_t | u32ClkDivSel | ||
| ) |
Enable PWM SYNC_IN noise filter function.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ClkCnt | SYNC Edge Detector Filter Count. This controls the counter number of edge detector. The valid value is 0~7. |
| [in] | u32ClkDivSel | SYNC Edge Detector Filter Clock Selection. |
This function is used to enable PWM SYNC_IN noise filter function.
| void PWM_EnableSyncPhase | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask | ||
| ) |
Enable SYNC phase of selected channel(s)
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel. Bit 0 is channel 0, bit 1 is channel 1... |
This function is used to enable SYNC phase of selected channel(s).
| void PWM_EnableSyncPinInverse | ( | PWM_T * | pwm | ) |
| void PWM_EnableZeroInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Enable zero interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
This function is used to enable zero interrupt of selected channel.
| void PWM_ForceStop | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask | ||
| ) |
Stop PWM generation immediately by clear channel enable bit.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel. Bit 0 is channel 0, bit 1 is channel 1... |
This function is used to stop PWM generation immediately by clear channel enable bit.
| uint32_t PWM_GetAccInt | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Get interrupt flag accumulator interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| 0 | Accumulator interrupt did not occur |
| 1 | Accumulator interrupt occurred |
This function is used to Get interrupt flag accumulator interrupt of selected channel.
| uint32_t PWM_GetADCTriggerFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Get selected channel trigger EADC flag.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| 0 | The specified channel trigger EADC to start of conversion flag is not set |
| 1 | The specified channel trigger EADC to start of conversion flag is set |
This function is used to get PWM trigger EADC to start of conversion flag for specified channel.
| uint32_t PWM_GetCaptureIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Get capture interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| 0 | No capture interrupt |
| 1 | Rising edge latch interrupt |
| 2 | Falling edge latch interrupt |
| 3 | Rising and falling latch interrupt |
This function is used to get capture interrupt of selected channel.
| uint32_t PWM_GetDutyIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Get duty interrupt flag of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| 0 | Duty interrupt did not occur |
| 1 | Duty interrupt occurred |
This function is used to get duty interrupt flag of selected channel.
| uint32_t PWM_GetFaultBrakeIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32BrakeSource | ||
| ) |
This function get fault brake interrupt flag of selected source.
| [in] | pwm | The pointer of the specified PWM module |
| [in] | u32BrakeSource | Fault brake source, could be either |
| 0 | Fault brake interrupt did not occurred |
| 1 | Fault brake interrupt occurred |
This function is used to get fault brake interrupt flag of selected source.
| uint32_t PWM_GetFTDutyIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Get free trigger duty interrupt flag of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| 0 | Free trigger duty interrupt did not occur |
| 1 | Free trigger duty interrupt occurred |
This function is used to get free trigger duty interrupt flag of selected channel.
| uint32_t PWM_GetPeriodIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Get period interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| 0 | Period interrupt did not occur |
| 1 | Period interrupt occurred |
This function is used to get period interrupt of selected channel.
| uint32_t PWM_GetWrapAroundFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Get the time-base counter reached its maximum value flag of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| 0 | Count to max interrupt did not occur |
| 1 | Count to max interrupt occurred |
This function is used to get the time-base counter reached its maximum value flag of selected channel.
| uint32_t PWM_GetZeroIntFlag | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum | ||
| ) |
Get zero interrupt of selected channel.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| 0 | Zero interrupt did not occur |
| 1 | Zero interrupt occurred |
This function is used to get zero interrupt of selected channel.
| void PWM_SetBrakePinSource | ( | PWM_T * | pwm, |
| uint32_t | u32BrakePinNum, | ||
| uint32_t | u32SelAnotherModule | ||
| ) |
Set PWM brake pin source.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32BrakePinNum | Brake pin selection. Valid values are 0 or 1. |
| [in] | u32SelAnotherModule | Select to another module. Valid values are TRUE or FALSE. |
This function is used to set PWM brake pin source.
| void PWM_SetClockSource | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelNum, | ||
| uint32_t | u32ClkSrcSel | ||
| ) |
Set PWM clock source.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelNum | PWM channel number. Valid values are between 0~5 |
| [in] | u32ClkSrcSel | PWM external clock source. |
This function is used to set PWM clock source.
| void PWM_Start | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask | ||
| ) |
Start PWM module.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel. Bit 0 is channel 0, bit 1 is channel 1... |
This function is used to start PWM module.
| void PWM_Stop | ( | PWM_T * | pwm, |
| uint32_t | u32ChannelMask | ||
| ) |
Stop PWM module.
| [in] | pwm | The pointer of the specified PWM module
|
| [in] | u32ChannelMask | Combination of enabled channels. Each bit corresponds to a channel. Bit 0 is channel 0, bit 1 is channel 1... |
This function is used to stop PWM module.


#assign kotlinfinder="active">
ebeaninit
command line tool to generate Finders for us.
We can create and use a Finder for each of our entity beans, for example a CustomerFinder for the Customer entity bean. We do this to organise our code grouping all the "finder logic" for a given bean type into it's finder (so that everyone knows where it is).
A CustomerFinder generated by the ebeaninit
command line tool.
When we generate Finders these are also linked to the entity via a public field.
We can use ebean-mocker
when we want to mock or stub the finders for
testing purposes.
With Kotlin we have the finder as a companion object
.
With the CustomerFinder linked as a field to Customer we can then easily use it.
```java // find by id val customer = Customer.byId(1L) // reference val customerReference = Customer.ref(1L) val customers = Customer.query() .where() .istartsWith("name", "hello") .findList(); // generally it is recommended that we move "find logic" for Customer // into the CustomerFinder so instead we should create a "byName" method // on CustomerFinder and end up with: val customers = Customer.byName("hello"); ``` <@next_edit "Repository" "/docs/getting-started/java-repository" "/docs/getting-started/java-finder.html"/>


| 01.05.05
Dear Gwen McCurry:
Thank
you for the opportunity to talk with you today about the marketing
& e-commerce supervisor position. Our discussion was very enjoyable
and gave me a clear understanding of what this position involves.
The more I learned about the duties associated with this position—print
production, web/ui design, promotional materials, and collaborating
with programers—the more convinced I became that this would
be the ideal arrangement for me.
I
believe that I can contribute a lot of energy and enthusiasm toward
the work assigned me. I am confident that, should you decide to
hire me,
I am capable of taking on all of the responsibilities that this
position requires, acquiring and improving new skills, and meeting
challenges and deadlines in a professional manner. I look forward
to hearing from you soon.
Kindly,
Beatrice
|


---
layout: post
title: 'Question: European tour? Maybe with some help...'
date: '2012-06-02T13:41:00.000-05:00'
author: Tom Ray
tags:
- blog
modified_time: '2013-02-09T22:55:20.936-06:00'
blogger_id: tag:blogger.com,1999:blog-11319466.post-1952943133578960848
blogger_orig_url: http://www.lorenzosmusic.com/2012/06/question-european-tour-maybe-with-some.html
---
Just a quick question...
We were talking at practice the other night about how in recent years a lot of our album downloads and purchases have been coming from Europe. And we thought wouldn't it be great if we could go to there and play these places even if it's just for a week long tour?
So here is our question:
Would it be crazy for us to start a fan funded campaign to tour Europe?
Let us know in the comments below.


[§206E-18] Assistance by state and county agencies. Any state or county agency may render services upon request of the authority. [L 1976, c 153, pt of §1]


DfE enquiries
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Press release
1,600 academy heads took part in headteacher board elections
The Department for Education has announced the names of the 32 headteachers who have been voted by their peers to sit on the boards of the 8 new regional schools commissioners ( RSCs ).
More than 1,600 headteachers took part in the vote to elect their peers to the headteacher boards ( HTBs ), which start in September. These new bodies, of 6 to 8 members, will help the 8 newly appointed RSCs be champions for academy freedoms, identify where new academies can be created, and provide a failure regime for the small number of academies which are struggling.
The 32 elected are education experts with the experience and local knowledge needed to help academies in their areas flourish. They are all headteachers, or recent headteachers, from schools judged by Ofsted to have ‘outstanding’ leadership and management.
RSCs will take on responsibilities previously held by the Secretary of State, such as agreeing or rejecting academy applications, and their combined local insight will mean they can make informed decisions on when and how to intervene.
Schools Minister Lord Nash said:
Headteacher boards will provide an excellent body of support for our regional school commissioners in their task of improving the education of pupils across England.
These elections show heads recognise the value that HTBs can play in shaping the future of the education system.
The collective expertise and wisdom of HTBs will help keep schools to account, champion academy freedoms and ensure swift action is taken when things go wrong.
The number of academy schools has increased dramatically since May 2010, when there were just 203 academies, all sponsored and all secondary. Latest figures show there are now 4,199 academies overall, with 58% of secondary schools now academies and 12% of primaries now academies.
RSCs ’ responsibilities will include:
Two additional board members will be appointed by each RSC, and the board will be able to co-opt further members to fill skills or expertise gaps.
Schools Commissioner Frank Green said:
I am absolutely delighted that we have had so many headteachers taking part in the establishment of the headteacher boards. 159 candidates stood for election for the 32 elected posts on the 8 regional HTBs with a turnout of almost 40% in the elections.
The academy and free school leaders have demonstrated their appetite and commitment to leading our new, self-managing, self-improving education system, which augurs well for its success. And this means that many more children will have better outcomes as a result.
The headteachers elected to the HTBs are:
| RSC (region) | Elected headteachers (school) |
|---|---|
| Paul Smith (Lancashire and west Yorkshire) | Jane Acklam (Moor End Academy), Pamela Birch (Hambleton Primary School), Martin Shevill (Ossett Academy and Sixth-Form College), Alan Yellup (Wakefield City Academy) |
| Janet Renou (north of England) | Zoe Carr (Town End Academy), Chris Clarke (Queen Elizabeth School), Nick Hurn (Cardinal Hume Catholic School), Lesley Powell (The Academy at Shotton Hall) |
| Dominic Herrington (south London and south-east England) | Rhona Julia Barnfield (Howard of Effingham School), Ian Bauckham (Bennett Memorial Diocesan School), Andrew Carter (South Farnham School), Denise Shepherd (Rochester Grammar School) |
| Martin Post (north-west London and south central England) | Richard Edwards (Nicholas Hawksmoor Primary School), Sir Michael Griffiths (Northampton School for Boys), Claire Robins (Sir John Lawes School), Teresa Tunnadine (The Compton School) |
| Pank Patel (west Midlands) | Mike Donoghue (John Taylor High School), Billy Downie (The Streetly Academy), David Andrew Seddon (Baxter College), Sally Yates (Deanery Church of England Primary School) |
| Sir David Carter (south-west England) | Dave Baker (Bradley Stoke Community School and Abbeywood Community School), Lorraine Heath (Uffculme School), Lisa Mannall (Trenance Learning Academy), Roger Pope (Kingsbridge Community College) |
| Dr Tim Coulson (north-east London and east of England) | Caroline Mary Bronwyn Haynes (Tendring Technology College), Stephen Munday (Comberton Village College), Debbie Rogan (The Wickford Church of England School and Briscoe Primary), Margaret Wilson (The King John School Academy Trust) |
| Jenny Bexon-Smith (east Midlands and the Humber) | Chris Beckett (The Deepings School), Hugh Howe (Beauchamp College), Christine Linnitt (Holywell Primary School), Geoff Lloyd (Tuxford Academy) |
or
or
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Published: 17 July 2014
From: Department for Education
Part of: Teaching and school leadership


Limit orders fill when the security price passes the limit price. To monitor the fills of your order, save a reference to the order ticket.
// Buy 10 shares of XLK at $140
var ticket = LimitOrder("XLK", 10, 140); Debug($"Quantity filled: {ticket.QuantityFilled}; Fill price: {ticket.AverageFillPrice}");
# Buy 10 shares of XLK at $140 ticket = self.LimitOrder("XLK", 10, 140) self.Debug(f"Quantity filled: {ticket.QuantityFilled}; Fill price: {ticket.AverageFillPrice}")
For more information about how LEAN models order fills in backtests, see Trade Fills.


How We Made This Site
IM Interactive Media: A Redesign Case Study
What began as a team assignment in IMG-130 Project Management, a required course in NIC's Interactive Media Programs, has ended in the production and launch of this IM Design + Development website. What you see here is the culmination of countless - nay, hundreds of - volunteer hours given by Brittany King, Ian McKenzie and Matt Boucher, over the course of three summer months.
The Team
The original scope of the IMG 130 assignment was to redesign the Interactive Media’s existing online gallery; this pre-existing website was intended to showcase the diverse skills that students were developing in the Interactive Media programs. Five teams, each comprised of three students, completed their own version of the website redesign. The work produced by the five teams was so impressive; it only made sense to adopt one of these redesigns as an updated presentation for the Interactive Media program. After much discussion, the redesign of what was known at the time as “Team 9” was selected.
However, the redesign process didn’t stop there. The team, Brittany, Ian, and Matt, completely redesigned their redesign – branding the Interactive Media programs from scratch. Together, the team did it all: content strategy and collection, asset production, copywriting, animation design, html, css and javascript coding, quality assurance, search engine optimization and endless - really, endless - design iterations.
Who Did What
Brittany King
- Branding: typography, style guide
- HTML & CSS coding
- Copy editing & quality assurance
- Modal design: student / alumni and faculty profiles, ‘what we do’ & information pages
Ian Mckenzie
- Copywriting
- Content strategy & content collection
- HTML, CSS & Javascript coding
- Animations across website & modals
- SVG Animations
Matt Boucher
- Branding: logo design, colour palette, layout
- Asset creation: illustrations, icons, photo-based images
- Main page wireframe & mock up design
- Masonry panel layout & hover effects
the creators of the im design + development website
brittany king:
design, code, content
ian mckenzie:
code, content
matt boucher:
design
Brittany King
Ian McKenzie
Matt Boucher


{% extends "base.html" %} {% import "bootstrap/wtf.html" as wtf %} {% block title %}Home{% endblock %} {% block page_content %}
To link your user with your AGA account, enter your AGA # in the form below and click "submit".
We will send an email to the e-mail address registered with your AGA account. You can change this email at the AGA Membership Manager.
{{ wtf.quick_form(form) }}


‘Meet Your Muslim Neighbour’ event bridges gap on Semiahmoo Peninsula, association says
Event serves as an educational space for residents in South Surrey-White Rock
by Aaron HinksLast week’s ‘Meet Your Muslim Neighbour’ event served as a way to bridge a gap in the community, says the White Rock Muslim Association (WRMA) outreach co-ordinator.
Organized by the WRMA, the Nov. 10 event at the South Surrey Recreation and Arts Centre served as an educational venue for people in the South Surrey-White Rock community, Asad Syed said.
The event featured a presentation on the history of Muslims in Canada and the main pillars of belief in Islam.
“Various informational posters and literature were available at the event, as well as a display featuring art pieces and clothing from a plethora of different cultures that exist within the Muslim world. The event also included booths such as an Arabic calligraphy station, a henna station, and a food section featuring delicious treats and goodies from across the Muslim world,” Syed told Peace Arch News.
White Rock Mayor Darryl Walker attended with Couns. Anthony Manning and Christopher Trevelyan. Surrey Coun. Linda Annis and Doug Elford also attended.
“There was a great turnout of community members throughout the afternoon with wonderful discussions taking place between all those present,” Syed told PAN. “The WRMA hopes that events like these will continue to bridge the gap and allow all of us to move towards a tighter knit community.”


I am tradesman who began his journey doing home weatherization and green energy retrofitting through a company called Got Green. Yirim completed the program, became certified in retrofitting homes for energy efficiency, joined local 242 labor union and increasingly became recognized as one of the few local success stories emerging from President Obama’s 2008 green energy initiative. He feels that through a progressive merging of art and activism he can help people on both sides of the ‘green gap’ traverse the barriers that separate them. Yirim has been committed to not only making great music, but using music and performance as a platform for ‘green activism’ and alliance building across the diverse sectors of our society. Over the past 9 years Yirim Seck has been working to strategically develop a stronger civic and social media presence and explore new ways to have a positive and enduring impact on the community.


Welcome to Studio West! Known as one of the most unique dining experiences in Minneapolis, Studio West offers a brand new perspective on eating out! The lush menu is designed to give you a harmony of wonderful flavors using all-fresh ingredients and ingenious composition. You will enjoy these creations inside some of the world's most well known recording studios, including Abbey Road and Sunset Sound. Our brilliant imagery and a beautifully deep sound track will surely bring you a sensory experience that you will never forget! Call now, as we are reservation-only!