|
|
Quick Start Guide
|
The Uniform Server’s default configuration is set to allow only local access; users on your network or the Internet cannot access your server. This allows you to develop and view your website locally in a secure environment.
This guide shows you how to install and run the servers as standard programs. When run as standard programs, nothing is installed to the Windows registry. The servers are therefore fully portable.
Pre-configured server
|
If your are using Uniform Server Zero with pre-installed ZeroModules install as follows:
- Download and save the latest server file (for example 13_0_0_ZeroXIII.exe) to drive C:
- The file is a self-extracting archive, double click to run the extractor.
- A new folder UniServerZ is created containing UniController.exe and support folders and files.
- That completes installation jump to Installing your Website or Test pages.
Alternatively if your are installing a bespoke server follow the next three Install sections and proceed to Installing your Website or Test pages.
|
|
|
Install - UniController
|
The Uniform Server Zeros base component is the controller application. Download and extract this base component first.
- Download and save the latest controller file (ZeroXIII_controller_2_2_0.exe) to drive C:
- The file is a self-extracting archive, double click to run the extractor.
- The installation (extraction) defaults to creating folder C:\UniServerZ, with the folder
structure as shown on the right.
- Once extracted add plugins as required see next section for details
|
|
Server Paths
You can install The Uniform Server Zero in nearly any location, with the exception that the path to folder UniServerZ must not contain spaces. Do not use "C:\Program Files", for example (which has other problems as well, such as restricted permissions and system restore inconsistencies). We recommend installing to the drive root, such as "C:\" or "D:\" for simplicity, but other locations, such as "C:\test1\appserver" work just as well.
Note: The space character restriction is generic and applies to other WAMP stacks as well. Many applications that will be hosted on the server do not tolerate spaces in paths. The system restore issue applies mainly to individual component installs.
If the current installation is on a faulty path, the situation can eaily be resolved by just moving the UniServerZ directory to a proper location. You do not have to delete the directory and reinstall. For example, just rename "D:\bad path\UniServer" to "D:\good_loc\UniServerZ".
|
General note:
UniController on its own allows you to send test e-mails using the email utility msmtp. This utility provides support for PHP plugins allowing the PHP mail function to send emails.
In addition the controller provides a menu option to edit or view the UniServer PAC file. Creating an Apache Vhost automatically adds an entry to this file. Entries in the PAC file resolve domain names to local host allowing testing without the need for a DNS entry or writing an entry in the Windows hosts file.
The controller also provides a menu option to edit or view the Windows hosts file. Creating an Apache Vhost automatically adds an entry to this file if that user option is enabled (enabled by default). Entries in the hosts file resolve domain names to local host allowing testing without the need for a DNS entry.
Greyed out controller menu options and buttons indicate that option is unavailable until either the appropriate plugin is installed or the servers (Apache and MySQL) are running.
|
|
|
Install - Plugins
The Uniform Server Zero is designed for portability, emphasis is given to reducing code size. The Uniform Server Zero achieves this through a modular implementation. Install only plugins you require these are listed on the plugins page, plugins avoid the dreaded bloat-ware scenario.
Installing a plugin
- Close running servers and close UniController.
- Dounload and save required plugin file (ZeroXIII_x_x_x.exe) to folder UniServerZ.
- Execute the downloaded file (ZeroXIII_x_x_x.exe). Once extracted, the plugin is ready to run
- If you wish; delete the installation file.
After extraction plugins have additional documentation in the form of a xxx_read_me.txt file located in folder UniServerZ.
Install WAMP components
The following provides a complete guide for installing a WAMP (Windows Apache MySQL and PHP) server. Installing is a misnomer! Nothing is installed to your PCs registry all files are extracted to their appropriate location within the UniServer
folder structure.
To install a WAMP server proceed as follows:
- Download and save the latest controller file (ZeroXIII_controller_2_2_0.exe) to drive c:
- The file is a self-extracting archive, double click on above file to run the extractor.
- A new folder C:\UniServerZ is created containing the controller application UniController.exe and support folders and files.
- Download the following plugins (or latest version) and save to folder UniServerZ.
- ZeroXIII_apache_2_4_23_h.exe - Apache server
- ZeroXIII_mysql_5_6_31.exe - MySQL server
- ZeroXIII_php_7_0_8_h.exe - PHP (Use PHP modules from the Default list)
- ZeroXIII_phpmyadmin_4_6_3.exe - Admin for MySQL server
- For each of the above installation files double click to run the extractor.
- If prompted allow overwriting of existing files.
- If you wish; delete the installation files, they are no longer required.
Note 1: Each plugin contains a read-me file providing any additional instructions this is located in folder UniServerZ.
Note 2: Clean module install
|
Initial installation:
First time installation of modules
requires nothing special proceed as above.
Already installed modules:
Modules that have already been installed
first delete the corresponding module folder
and then proceed as above.
Module name and folder to delete
are listed on the right:
|
| Module | Folder | |
| ZeroXIII_apache_2_4_x.exe | UniServerZ\core\apache2 | |
| ZeroXIII_mariadb_5_5_x.exe | UniServerZ\core\mysql | |
| ZeroXIII_mariadb_10_x_x.exe | UniServerZ\core\mysql | |
| ZeroXIII_mysql_5_x_x.exe | UniServerZ\core\mysql | |
| ZeroXIII_php_5_3_x.exe | UniServerZ\core\php53 | |
| ZeroXIII_php_5_4_x.exe | UniServerZ\core\php54 | |
| ZeroXIII_php_5_5_x.exe | UniServerZ\core\php55 | |
| ZeroXIII_php_5_6_x.exe | UniServerZ\core\php56 | |
| ZeroXIII_phpmyadmin_4_x_x.exe | UniServerZ\home\us_opt1 | |
| ZeroXIII_adminer_4_x_x.exe | UniServerZ\home\us_opt2 | |
| ZeroXIII_phpmybackuppro_2_4.exe | UniServerZ\home\us_opt3 | |
| ZeroXIII_sypex_dumper_2_x_x.exe | UniServerZ\home\us_opt3 | |
| ZeroXIII_strawberry_perl_5_x_x_x.exe | UniServerZ\home\perl | |
| ZeroXIII_strawberry_perl_mini_5_x_x_x.exe | UniServerZ\home\perl | |
|
General note:
The instructions that follow assume you have installed the above WAMP server or a pre-configured server.
Installing your Website or Test pages
|
Server root folder:
- B) Web pages are served from folder UniServerZ\www , which is commonly referred to as the server root folder.
- Simply copy your Website into this root folder.
The root folder www already contains a very simple web-site consisting of a single page named index.php
including its associated folders css and images. Its purpose is to provide a test page, allowing you to
confirm that the server is functioning properly.
|
|
Before installing your Website, you can delete the index.php file and folders css and images.
Don't delete the .htaccess and favicon.ico files. They have the following purposes:
- .htaccess - This file is part of the server security and should not be deleted.
- favicon.ico - This is a small image file displayed in a browser next to a Web page name.
You can replace this with your own file, but use the name favicon.ico so browsers will display it properly.
Note: Having a favicon image is not a requirement, but modern browsers attempt to load this image by default. If your server does not contain one, an error is logged in Apache's log file.
General notes:
Note 1: Unix installations use a root folder named htdocs. When using an application installation guide that refers to htdocs, use folder www instead.
Note 2: The file structure is not static. For example, running Vhost creates the new folder UniServerZ\vhosts containing Vhost root folders.
Server Control
The UniServerZ folder contains file UniController.exe which opens The Uniform Server's control application for running the servers as a standard program.
Run servers as a Program
UniController runs the servers as a standard program. When using UniController nothing is installed to your operating system's registry. This is ideal for a development server, especially when running from a USB memory stick, since you do not have to perform anything special to stop or remove the servers.
Run UniController:
The Uniform Server's folder structure is shown on the right.
- A) Navigate to the folder UniServerZ.
- Locate the file UniController.exe and double click
- This starts the controller application UniController
- Before UniController is displayed the set MySQL password pop-up is displayed.
- You may click "cancel" and set the password later.
|
|
Run Servers:
- UniController is shown on the right.
- A) Click Start Apache button. Starts the Apache server
- B) Click Start MySQL button. Starts the MySQL server
- If challenged by your firewall, allow access.
- Buttons toggle state displaying Stop Apache and Stop MySQL.
- Indicators i1 and i2 change from red to green
indicating servers are running.
- Browser opens, displaying ref, splash and test pages.
- Greyed buttons are enabled accordingly.
Note 1: Be aware that the splash page is not the index.php file in www.
Note 2: Browser is either your default browser or the portable browser (plugin required)
|
|
General note:
There are various start-up conditions. If you receive a message unable to connect and are provided an option from your browser to try again, wait until all disk activity completes and click the "try again" button. Alternatively, wait a reasonable time to view the initial splash page, and enter the following into your browser: http://localhost/us_splash/index.php
If you do not have the VC14 library, when you attempt to start the servers, you will get a runtime error popup. See VC14 Libraries to resolve this.
Stop the Servers
UniController
- UniController is shown on the right.
- A) Click Stop Apache button. Stops the Apache server
- B) Click Stop MySQL button. Stops the MySQL server
- Buttons toggle state displaying Start Apache and Start MySQL.
- Indicators i1 and i2 change from green to red
indicating servers have stopped.
- Active buttons are disabled (greyed) accordingly.
Note: Stopping the MySQL server attempts to perform a clean shutdown
if this fails user is provided the option to forcibly kill the server.
|
|
Note: Closing UniController does not change servers’ state. Restarting UniController the current server state is picked up and displayed.
Set New MySQL root password
When UniController is started although you can skip setting a new MySQL root password,
it is highly recommended that you set this password at the first opportunity.
Well! This is the first opportunity; the pop-up allows you to change the current root password.
- The Set New MySQL Password menu opens (See image on right)
- A) Enter a new password
- B) Click the OK button.
You can click the cancel button and set the password later.
|
|
Note: You can re-open this menu from UniController as follows:
Click MySQL > Change MySQL root password
Root folder www - Test
The root folder www contains a very simple web-site consisting of a single page named index.php and associate folders css and images.
Clicking UniController button View www displays this page confirming that Apache is serving pages from this folder.
View pages
The default server name is localhost. Use this to access pages as follows:
Index Pages
To access index pages (such as index.htm, index.html, index.php) type the following into your browser.
http://localhost/
|
Specific pages
Display a specific page by appending its name to the server name. For example, if your test page is named test.php, then type the following into your browser:
http://localhost/test.php
|
Note: The Apache server automatically searches for index pages and displays the first one it finds. If it cannot find an index page, a directory listing is displayed instead.
Where to go next
This quick guide shows how to start and stop the servers and display a test page. You can copy an entire web-site into the root folder www and it will then be served by Apache.
How to put the servers on-line - Open up your server for public or intranet access and optionally restrict access using a name and password.
|


Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View > Class Template Reference
[Integer propagators]
#include <cumulatives.hh>
Inherits Gecode::Propagator.
Detailed Description
template<class ViewM, class ViewD, class ViewH, class View>
class Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View >
Propagator for the cumulatives constraint.
This class implements Beldiceanu's and Carlsson's sweep-line propagation algorithm for the cumulatives constraint.
Requires
#include "gecode/int/cumulatives.hh"
Definition at line 93 of file cumulatives.hh.
Public Member Functions | |
| virtual size_t | dispose (Space *home) |
| Delete actor and return its size. | |
| virtual Actor * | copy (Space *home, bool share) |
| Create copy. | |
| virtual PropCost | cost (ModEventDelta med) const |
| Cost function. | |
| virtual ExecStatus | propagate (Space *home, ModEventDelta med) |
| Propagation function. | |
| virtual Reflection::ActorSpec | spec (const Space *home, Reflection::VarMap &m) const |
| Specification for this propagator. | |
Static Public Member Functions | |
| static void | post (Space *home, Reflection::VarMap &vars, const Reflection::ActorSpec &spec) |
| Post propagator according to specification. | |
| static Support::Symbol | ati (void) |
| Name of this propagator. | |
| static ExecStatus | post (Space *home, const ViewArray< ViewM > &, const ViewArray< View > &, const ViewArray< ViewD > &, const ViewArray< View > &, const ViewArray< ViewH > &, const IntArgs &, bool) |
Member Function Documentation
template<class ViewM, class ViewD, class ViewH, class View>
| size_t Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View >::dispose | ( | Space * | home | ) | [inline, virtual] |
template<class ViewM, class ViewD, class ViewH, class View>
| Actor * Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View >::copy | ( | Space * | , | |
| bool | ||||
| ) | [inline, virtual] |
template<class ViewM, class ViewD, class ViewH, class View>
| PropCost Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View >::cost | ( | ModEventDelta | med | ) | const [inline, virtual] |
template<class ViewM, class ViewD, class ViewH, class View>
| ExecStatus Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View >::propagate | ( | Space * | home, | |
| ModEventDelta | med | |||
| ) | [inline, virtual] |
Propagation function.
The propagation function must return an execution status as follows:
- ES_FAILED: the propagator has detected failure
- ES_NOFIX: the propagator has done propagation
- ES_FIX: the propagator has done propagation and has computed a fixpoint. That is, running the propagator immediately again will do nothing.
Apart from the above values, a propagator can return the result from calling one of the functions
- ES_SUBSUMED: the propagator is subsumed and has been already deleted.
- ES_NOFIX_PARTIAL: the propagator has consumed some of its propagation events.
- ES_FIX_PARTIAL: the propagator has consumed some of its propagation events and with respect to these events is at fixpoint For more details, see the individual functions.
Implements Gecode::Propagator.
template<class ViewM, class ViewD, class ViewH, class View>
| Reflection::ActorSpec Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View >::spec | ( | const Space * | home, | |
| Reflection::VarMap & | m | |||
| ) | const [inline, virtual] |
template<class ViewM, class ViewD, class ViewH, class View>
| void Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View >::post | ( | Space * | home, | |
| Reflection::VarMap & | vars, | |||
| const Reflection::ActorSpec & | spec | |||
| ) | [inline, static] |
template<class ViewM, class ViewD, class ViewH, class View>
| Support::Symbol Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View >::ati | ( | void | ) | [inline, static] |
template<class ViewM, class ViewD, class ViewH, class View>
| ExecStatus Gecode::Int::Cumulatives::Val< ViewM, ViewD, ViewH, View >::post | ( | Space * | home, | |
| const ViewArray< ViewM > & | machine, | |||
| const ViewArray< View > & | start, | |||
| const ViewArray< ViewD > & | duration, | |||
| const ViewArray< View > & | end, | |||
| const ViewArray< ViewH > & | height, | |||
| const IntArgs & | limit, | |||
| bool | at_most | |||
| ) | [inline, static] |
The documentation for this class was generated from the following files:
- gecode/int/cumulatives.hh (Revision: 7482)
- gecode/int/cumulatives/val.icc (Revision: 7668)


/*eslint-env node */
'use strict';
var Promise = require('bluebird');
var _ = require('lodash');
var uuid = require('uuid');
/**
Timer Manager
Keep track of timers to ensure that disconnect() is
only called (via close()) at a time when it's safe
to do so.
Queues currently use two timers:
- The first one is used for delayed jobs and is
preemptible i.e. it is possible to close a queue
while delayed jobs are still pending (they will
be processed when the queue is resumed). This timer
is cleared by close() and is not managed here.
- The second one is used to lock Redis while
processing jobs. These timers are short-lived,
and there can be more than one active at a
time.
The lock timer executes Redis commands, which
means we can't close queues while it's active i.e.
this won't work:
queue.process(function (job, jobDone) {
handle(job);
queue.disconnect().then(jobDone);
})
The disconnect() call closes the Redis connections; then, when
a queue tries to perform the scheduled Redis commands,
they block until a Redis connection becomes available...
The solution is to close the Redis connections when there are no
active timers i.e. when the queue is idle. This helper class keeps
track of the active timers and executes any queued listeners
whenever that count goes to zero.
Since disconnect() simply can't work if there are active handles,
its close() wrapper postpones closing the Redis connections
until the next idle state. This means that close() can safely
be called from anywhere at any time, even from within a job
handler:
queue.process(function (job, jobDone) {
handle(job);
queue.close();
jobDone();
})
*/
function TimerManager() {
this.idle = true;
this.listeners = [];
this.timers = {};
}
/**
Create a new timer (setTimeout).
Expired timers are automatically cleared
@param {String} name - Name of a timer key. Used only for debugging.
@param {Number} delay - delay of timeout
@param {Function} fn - Function to execute after delay
@returns {Number} id - The timer id. Used to clear the timer
*/
TimerManager.prototype.set = function(name, delay, fn) {
var id = uuid.v4();
var timer = setTimeout(
function(timerInstance, timeoutId) {
timerInstance.clear(timeoutId);
try {
fn();
} catch (err) {
console.error(err);
}
},
delay,
this,
id
);
// XXX only the timer is used, but the
// other fields are useful for
// troubleshooting/debugging
this.timers[id] = {
name: name,
timer: timer
};
this.idle = false;
return id;
};
/**
Clear a timer (clearTimeout).
Queued listeners are executed if there are no
remaining timers
*/
TimerManager.prototype.clear = function(id) {
var timers = this.timers;
var timer = timers[id];
if (!timer) {
return;
}
clearTimeout(timer.timer);
delete timers[id];
Eif (!this.idle && _.size(timers) === 0) {
while (this.listeners.length) {
this.listeners.pop()();
}
this.idle = true;
}
};
TimerManager.prototype.clearAll = function() {
var _this = this;
_.each(this.timers, function(timer, id) {
_this.clear(id);
});
};
/**
* Returns a promise that resolves when there are no active timers.
*/
TimerManager.prototype.whenIdle = function() {
var _this = this;
return new Promise(function(resolve) {
Eif (_this.idle) {
resolve();
} else {
_this.listeners.unshift(resolve);
}
});
};
module.exports = TimerManager;
|


Provides functionality for Hibernate operations.
The classes in this package provide for database operations using Hibernate 3.2. All data access objects (classes with DAO at the end of their name) subclass GenericHibernateDAO. Data access objects encapsulate Hibernate operations on specific database tables.


These tests verify API and operation of the USART data exchange functions.
The data exchange tests verify the following driver functions (USART Driver function documentation):
- Send
int32_t Send (const void *data, uint32_t num);
- Receive
int32_t Receive ( void *data, uint32_t num);
- Transfer
int32_t Transfer (const void *data_out, void *data_in, uint32_t num);
- GetTxCount
uint32_t GetTxCount (void);
- GetRxCount
uint32_t GetRxCount (void);
- Control
int32_t Control (uint32_t control, uint32_t arg);
- GetStatus
ARM_USART_STATUS GetStatus (void);
- SignalEvent
void (*ARM_USART_SignalEvent_t) (uint32_t event);
All of these tests execute a data exchange and check the result of this data exchange.
Data exchange test procedure when Test Mode USART Server is selected:
- send command "SET BUF TX,.." to the USART Server: Set Tx buffer
- send command "SET BUF RX,.." to the USART Server: Set Rx buffer
- send command "SET COM .." to the USART Server: Set communication settings for the next XFER command
- send command "XFER .." to the USART Server: Specify transfer
- driver Control: Configure the USART interface
- driver Control: Set the default Tx value (in synchronous mode only)
- driver Send/Receive/Transfer: Start the requested operation
- driver GetStatus/SignalEvent: Wait for the current operation to finish or time-out
(operation is finished when appropriate tx_busy or rx_busy flag is 0 and send/receive/transfer completed event was signaled)
- assert that operation has finished in expected time
- assert that appropriate ARM_USART_EVENT_SEND_COMPLETE, ARM_USART_EVENT_RECEIVE_COMPLETE or ARM_USART_EVENT_TRANSFER_COMPLETE event was signaled
- driver GetStatus: Assert that appropriate tx_busy or rx_busy flag is 0
- driver GetTxCount: If it was a send or transfer operation assert that number of transmitted items is same as requested
- driver GetRxCount: If it was a receive or transfer operation assert that number of received items is same as requested
- if operation has timed out call driver Control function to Abort operation and wait timeout time
to make sure that the USART Server is ready for the next command
- assert that received content is as expected
- send command "GET BUF RX,.." to the USART Server: Get Rx buffer
- assert that sent content (read from the USART Server's receive buffer) is as expected
Data exchange Abort test procedure when Test Mode USART Server is selected:
- send command "SET BUF TX,.." to the USART Server: Set Tx buffer
- send command "SET BUF RX,.." to the USART Server: Set Rx buffer
- send command "SET COM .." to the USART Server: Set communication settings for the next XFER command
- send command "XFER .." to the USART Server: Specify transfer
- driver Control: Configure the USART interface
- driver Control: Set the default Tx value (in synchronous mode only)
- driver Send/Receive/Transfer: Start the requested operation
- wait up to 1 ms
- driver Control: Abort the current operation
- driver GetStatus: Assert that appropriate tx_busy or rx_busy flag is 0
- driver GetTxCount: If it was a send or transfer operation assert that number of transmitted items is less than requested
- driver GetRxCount: If it was a receive or transfer operation assert that number of received items is less than requested
Data exchange test procedure when Test Mode Loopback is selected:
- driver Control: Configure the USART interface
- driver Control: Set the default Tx value (in synchronous mode only)
- driver Send/Receive/Transfer: Start the requested operation
- driver GetStatus/SignalEvent: Wait for the current operation to finish or time-out
(operation is finished when appropriate tx_busy or rx_busy flag is 0 and send/receive/transfer completed event was signaled)
- assert that operation has finished in expected time
- assert that appropriate ARM_USART_EVENT_SEND_COMPLETE and ARM_USART_EVENT_RECEIVE_COMPLETE or ARM_USART_EVENT_TRANSFER_COMPLETE event was signaled
- driver GetStatus: Assert that appropriate tx_busy or rx_busy flag is 0
- driver GetTxCount: If it was a send and receive or transfer operation assert that number of transmitted items is same as requested
- driver GetRxCount: If it was a send and receive or transfer operation assert that number of received items is same as requested
- if operation has timed out call driver Control function to Abort operation
- assert that sent and received content is same
- Note
- Limitations of Data Exchange tests if Test Mode Loopback is selected:
- in synchronous mode only Master mode transfer can be tested
- only 8 data bit tests are supported
- parity tests are not supported
- stop bits tests are not supported
- flow control tests are not supported
- clock polarity and clock phase tests are not supported
| void USART_Mode_Asynchronous |
( |
void |
| ) |
|
The function USART_Mode_Asynchronous verifies data exchange:
- in Asynchronous mode
- with default data bits
- with default parity
- with default stop bits
- with default flow control
- at default baudrate
- for default number of data items
| void USART_Mode_Synchronous_Master |
( |
void |
| ) |
|
The function USART_Mode_Synchronous_Master verifies data exchange:
- in Synchronous Master mode
- with default data bits
- with no parity
- with 1 stop bit
- with no flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
- Note
- In Test Mode Loopback Receive function is not tested
| void USART_Mode_Synchronous_Slave |
( |
void |
| ) |
|
The function USART_Mode_Synchronous_Slave verifies data exchange:
- in Synchronous Slave mode
- with default data bits
- with no parity
- with 1 stop bit
- with no flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
- Note
- In Test Mode Loopback this test is not executed
| void USART_Mode_Single_Wire |
( |
void |
| ) |
|
The function USART_Mode_Single_Wire verifies data exchange:
- in Single-Wire mode
- with default data bits
- with default parity
- with default stop bits
- with no flow control
- at default baudrate
- for default number of data items
- Note
- In Test Mode Loopback this test is not executed
| void USART_Mode_IrDA |
( |
void |
| ) |
|
The function USART_Mode_IrDA verifies data exchange:
- in Infra-red Data mode
- with default data bits
- with default parity
- with default stop bits
- with default flow control
- at default baudrate
- for default number of data items
- Note
- In Test Mode Loopback this test is not executed
| void USART_Data_Bits_5 |
( |
void |
| ) |
|
The function USART_Data_Bits_5 verifies data exchange:
- in default mode
- with 5 data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
- Note
- In Test Mode Loopback this test is not executed
| void USART_Data_Bits_6 |
( |
void |
| ) |
|
The function USART_Data_Bits_6 verifies data exchange:
- in default mode
- with 6 data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
- Note
- In Test Mode Loopback this test is not executed
| void USART_Data_Bits_7 |
( |
void |
| ) |
|
The function USART_Data_Bits_7 verifies data exchange:
- in default mode
- with 7 data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
- Note
- In Test Mode Loopback this test is not executed
| void USART_Data_Bits_8 |
( |
void |
| ) |
|
The function USART_Data_Bits_8 verifies data exchange:
- in default mode
- with 8 data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
| void USART_Data_Bits_9 |
( |
void |
| ) |
|
The function USART_Data_Bits_9 verifies data exchange:
- in default mode
- with 9 data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
- Note
- In Test Mode Loopback this test is not executed
| void USART_Parity_None |
( |
void |
| ) |
|
The function USART_Parity_None verifies data exchange:
- in default mode
- with default data bits
- with no parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
| void USART_Parity_Even |
( |
void |
| ) |
|
The function USART_Parity_Even verifies data exchange:
- in default mode
- with default data bits
- with even parity
- with default stop bits
- with default flow control
- at default baudrate
- for default number of data items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Synchronous Master/Slave
| void USART_Parity_Odd |
( |
void |
| ) |
|
The function USART_Parity_Odd verifies data exchange:
- in default mode
- with default data bits
- with odd parity
- with default stop bits
- with default flow control
- at default baudrate
- for default number of data items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Synchronous Master/Slave
| void USART_Stop_Bits_1 |
( |
void |
| ) |
|
The function USART_Stop_Bits_1 verifies data exchange:
- in default mode
- with default data bits
- with default parity
- with 1 stop bit
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
| void USART_Stop_Bits_2 |
( |
void |
| ) |
|
The function USART_Stop_Bits_2 verifies data exchange:
- in default mode
- with default data bits
- with default parity
- with 2 stop bits
- with default flow control
- at default baudrate
- for default number of data items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Synchronous Master/Slave
| void USART_Stop_Bits_1_5 |
( |
void |
| ) |
|
The function USART_Stop_Bits_1_5 verifies data exchange:
- in default mode
- with default data bits
- with default parity
- with 1.5 stop bits
- with default flow control
- at default baudrate
- for default number of data items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Synchronous Master/Slave
| void USART_Stop_Bits_0_5 |
( |
void |
| ) |
|
The function USART_Stop_Bits_0_5 verifies data exchange:
- in default mode
- with default data bits
- with default parity
- with 0.5 stop bits
- with default flow control
- at default baudrate
- for default number of data items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Synchronous Master/Slave
| void USART_Flow_Control_None |
( |
void |
| ) |
|
The function USART_Flow_Control_None verifies data exchange:
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with no flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for default number of data items
| void USART_Flow_Control_RTS |
( |
void |
| ) |
|
The function USART_Flow_Control_RTS verifies functionality of the RTS line flow control by trying to receive half of default number of data items, after that, RTS line should be deactivated by the USART Client hardware and USART Server should stop sending further data.
The RTS line flow control functionality is tested with following settings:
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with flow control using RTS signal
- at default baudrate
Test procedure consists of the following steps:
- start reception of half of default number of items
- after half of default number of items was received the RTS line should go to inactive state
- USART Server after seeing that its CTS line (USART Clients RTS line) went to inactive state should stop sending further data
- after timeout read from USART Server the number of items it has sent and assert that it is less than default number of items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Synchronous Master/Slave or Single-wire
| void USART_Flow_Control_CTS |
( |
void |
| ) |
|
The function USART_Flow_Control_CTS verifies functionality of the CTS line flow control by trying to send default number of data items, while at half of transmitted number of items the USART Server deactivates its RTS line (it is connected to CTS line on the USART Client).
The CTS line flow control functionality is tested with following settings:
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with flow control using CTS signal
- at default baudrate
Test procedure consists of the following steps:
- start send of default number of items
- after USART Server receives half of default number of items it will drive its RTS line (USART Clients CTS line) inactive
- before timeout check that tx_busy is active and that number of transmitted items is less than default number of items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Synchronous Master/Slave or Single-wire
| void USART_Flow_Control_RTS_CTS |
( |
void |
| ) |
|
The function USART_Flow_Control_RTS_CTS verifies functionality of RTS And CTS lines. It calls function USART_Flow_Control_RTS that checks RTS line functionality, and USART_Flow_Control_CTS that checks CTS line functionality.
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Synchronous Master/Slave or Single-wire
| void USART_Clock_Pol0_Pha0 |
( |
void |
| ) |
|
The function USART_Clock_Pol0_Pha0 verifies data exchange:
- in default mode
- with default data bits
- with no parity
- with 1 stop bit
- with no flow control
- with clock polarity 0
- with clock phase 0
- at default baudrate
- for default number of data items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Asynchronous/Single-wire/IrDA
| void USART_Clock_Pol0_Pha1 |
( |
void |
| ) |
|
The function USART_Clock_Pol0_Pha1 verifies data exchange:
- in default mode
- with default data bits
- with no parity
- with 1 stop bit
- with no flow control
- with clock polarity 0
- with clock phase 1
- at default baudrate
- for default number of data items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Asynchronous/Single-wire/IrDA
| void USART_Clock_Pol1_Pha0 |
( |
void |
| ) |
|
The function USART_Clock_Pol1_Pha0 verifies data exchange:
- in default mode
- with default data bits
- with no parity
- with 1 stop bit
- with no flow control
- with clock polarity 1
- with clock phase 0
- at default baudrate
- for default number of data items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Asynchronous/Single-wire/IrDA
| void USART_Clock_Pol1_Pha1 |
( |
void |
| ) |
|
The function USART_Clock_Pol1_Pha1 verifies data exchange:
- in default mode
- with default data bits
- with no parity
- with 1 stop bit
- with no flow control
- with clock polarity 1
- with clock phase 1
- at default baudrate
- for default number of data items
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Asynchronous/Single-wire/IrDA
| void USART_Baudrate_Min |
( |
void |
| ) |
|
The function USART_Baudrate_Min verifies data exchange:
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at minimum baudrate (define
USART_CFG_MIN_BAUDRATE
in DV_USART_Config.h)
- for default number of data items
This test function checks the following requirement:
- measured bus speed for Send operation in Test Mode USART Server or Send/Receive operation in Test Mode Loopback is not 25% lower, or higher than requested
| void USART_Baudrate_Max |
( |
void |
| ) |
|
The function USART_Baudrate_Max verifies data exchange:
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at maximum baudrate (define
USART_CFG_MAX_BAUDRATE
in DV_USART_Config.h)
- for default number of data items
This test function checks the following requirement:
- measured bus speed for Send operation in Test Mode USART Server or Send/Receive operation in Test Mode Loopback is not 25% lower, or higher than requested
| void USART_Number_Of_Items |
( |
void |
| ) |
|
The function USART_Number_Of_Items verifies data exchange:
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- for different number of items (defines
USART_CFG_NUM1 .. USART_CFG_NUM5
in DV_USART_Config.h)
| void USART_GetTxCount |
( |
void |
| ) |
|
The function USART_GetTxCount verifies GetTxCount function (count changing) during data exchange (Send):
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
| void USART_GetRxCount |
( |
void |
| ) |
|
The function USART_GetRxCount verifies GetRxCount function (count changing) during data exchange (Receive):
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
| void USART_GetTxRxCount |
( |
void |
| ) |
|
The function USART_GetTxRxCount verifies GetTxCount and GetRxCount functions (count changing) during data exchange (Transfer):
- in default mode
- with default data bits
- with no parity
- with 1 stop bits
- with no flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- Note
- If Tests Default Mode Asynchronous/Single-wire/IrDA is selected this test is not executed
| void USART_AbortSend |
( |
void |
| ) |
|
The function USART_AbortSend verifies Abort function abort of data exchange (Send):
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with default flow control
- at default baudrate
| void USART_AbortReceive |
( |
void |
| ) |
|
The function USART_AbortReceive verifies Abort function abort of data exchange (Receive):
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with default flow control
- with default clock polarity
- with default clock phase
- at default baudrate
| void USART_AbortTransfer |
( |
void |
| ) |
|
The function USART_AbortTransfer verifies Abort function abort of data exchange (Transfer):
- in default mode
- with default data bits
- with no parity
- with 1 stop bit
- with no flow control
- with default clock polarity
- with default clock phase
- at default baudrate
- Note
- If Tests Default Mode Asynchronous/Single-wire/IrDA is selected this test is not executed
| void USART_TxBreak |
( |
void |
| ) |
|
The function USART_TxBreak verifies Break signaling:
- in default mode
- with default data bits
- with default parity
- with default stop bits
- with no flow control
- at default baudrate
- Note
- This test is not executed if any of the following settings are selected:
- Test Mode Loopback
- Tests Default Mode Synchronous Master/Slave


Word Guess Game
Animals of the North America
Wins
Losses
Current word
Number of guesses remaining
Letters already guessed


--- layout: post esbma_id: 1620 title: WPF Animation date: 2006-08-02 15:21:02 keywords: wpf teaser: Getting animation to work from C# wasn't quite simple or elegant. But once I got it working, it worked very nicely. ---
So when my woodworking app displays a join (two pieces of wood being glued or fastened together), I figured it would be nice to animate the display to make it easier to see how the join is done. And since WPF is supposed to have cool animation features, why not try it?
Until now, my experience with WPF has been so productive as to be surreal. With no prior experience, I can often get something new working with WPF in the amount of time it takes for my daughters to watch an episode of Sponge Bob.
However, animation wasn't quite that simple.
My first attempt was unsuccessful because I was going about things the wrong way.
Since I had two objects which I want to move back and forth, I figured I would just create ten frames by moving the objects apart a little bit further on each frame. The moving of the objects was done using a simple 3D translation in my solid modeler. Each time I moved the objects, I converted my solid model into a triangle mesh suitable for display. The result is that I would end up with ten meshes, one for each frame. Showing the animation would be a simple matter of showing each mesh in succession.
So I wrote the code to get my solid modeler to produce the ten sets of triangles, but things got difficult when I tried hooking this up to WPF's animation stuff. Life would have been simpler if I had looked at the WPF animation samples or documentation first. I assumed WPF would let me register a delegate or something which would get called when it's time to flip to the next frame. In that callback, I would switch my viewport3d to the next mesh. But that's not how WPF animation works.
The WPF animation stuff wants to tweak a property of an object. You tell it which object and which property. You provide it a range of values for that property and specify the amount of time it should take to get from the beginning to the end. For example, you might say "cycle the Angle property from 0 to 360 over a 7 second interval".
The absence of the notion of frames is a feature, not a bug. Somewhere deep in the bowels of System.Windows.Media.Animation there is some code which is making smart decisions about how many frames to use depending on how fast my hardware is.
However, this design certainly suggests that the property to be animated needs to be numeric, like a double or an int. If I'm allowed to pass in a collection of mesh objects, I don't see how.
I tried to create a wrapper class with a FrameNumber property so I could just use an Int32Animation to flip through the frames by number. But at this point it really seemed like I was swimming upstream. So I decided to step back and rethink.
WPF 3D has a really nice habit of using matrix transform objects all over the place. Model3DGroup has a Transform object. So does GeometryModel3D. The cameras and lights have one too. These things make it easier to scale, rotate and translate things without changing the actual geometry.
And they were designed to be animated. So...
Sweet. Everything worked perfectly, except for one silly hack.
The only problem here is that I don't like the way TranslateTransform3D works. It has three properties: OffsetX, OffsetY, and OffsetZ. Since I happened to be animating something moving parallel to an axis, this was not really a problem. But what if I wanted to be moving something in a straight line where X, Y and Z were all changing by different amounts? I suppose I could create three separate DoubleAnimation objects, but that feels like a silly hack.
What I really want is a different translation class. Instead of three separate offsets for X, Y and Z, what I want is a unit vector and scaling factor. The unit vector determines the direction. The scaling factor determines how far in that direction to translate. Then I could hook up a DoubleAnimation object to the scaling factor property.
So I decided to just create the class I need. All I have to do is subclass TranslateTransform3D and provide two new properties to do what I want.
Oops! That class is sealed. I wonder why?
Oh well, I guess I can just move up a level and subclass from AffineTransform3D. It'll be a little more work, but I'll live. So:
public class VectorTranslateTransform3D : AffineTransform3D
Ouch! The compiler says I have to implement CreateInstanceCore, AddRefOnChannelCore, ReleaseOnChannelCore and GetHandleCore.  The documentation is silent. I Googled "AddRefOnChannelCore" and found this post by somebody at Microsoft named Adam Smith who explains that subclassing from these classes is a bad idea. Bummer. I guess I'm stuck with my silly hack for now.
(If anybody in Redmond is reading this, please accept my vote for VectorTranslateTransform3D, with two properties: a Direction vector and a Distance double. Thanks!)
After giving up on the idea of having my animation work on one property instead of three, I couldn't sleep. So I decided to try one last thing: If inheritance won't work, maybe encapsulation will.
Success! Here's the code for my VectorTranslateTransform3D class:
/// <summary>
/// This
class encapsulates a TranslateTransform3D object but
///
presents a different interface. Instead of x, y, and z
///
offsets, we use a unit vector and a scaling factor.
///
/// This
class was created specifically to allow a DoubleAnimation
/// to use
the Distance property as a target. For that reason,
/// Distance
is a DependencyProperty.
///
///
Intuitively, this class should derive from DependencyObject,
/// but
when I do this, the code compiles but the animation
///
doesn't work. If I instead just change the base class
/// to
UIElement, it works. I'm not yet sure why.
/// </summary>
public class
VectorTranslateTransform3D : UIElement
{
// This is a unit vector
private Vector3D
_direction;
// This is the encapsulated transform object.
private TranslateTransform3D
_tt;
public VectorTranslateTransform3D(
TranslateTransform3D tt,
Vector3D dir,
double dist)
{
_tt = tt;
Direction = dir;
Distance = dist;
}
/// <summary>
///
When the vector or the distance changes, we need to
///
update the encapsulated transform object.
/// </summary>
private void
update()
{
// multiply the unit vector times the
distance to get
// the full translation
Vector3D vec = _direction *
Distance;
_tt.OffsetX = vec.X;
_tt.OffsetY = vec.Y;
_tt.OffsetZ = vec.Z;
}
public Vector3D
Direction
{
get
{
return _direction;
}
set
{
_direction = value;
_direction.Normalize();
update();
}
}
public double
Distance
{
get
{
return (double)this.GetValue(DistanceProperty);
}
set
{
this.SetValue(DistanceProperty,
value);
}
}
private static
void DistanceChangedCallback(
DependencyObject d,
DependencyPropertyChangedEventArgs
e)
{
VectorTranslateTransform3D v =
(VectorTranslateTransform3D)d;
v.update();
}
public static
readonly DependencyProperty
DistanceProperty =
DependencyProperty.Register(
"Distance",
typeof(double),
typeof(VectorTranslateTransform3D),
new PropertyMetadata(
new PropertyChangedCallback(DistanceChangedCallback)));
}
But I still wish a vector-based translation class was built in to the framework.
Another "problem" is that the WPF animation stuff is a bit awkward to use from C#. It appears to be designed to be used from XAML.
I already said that the animation objects require me to specify an object and a property on that object. I was kind of assuming this would be simple, like maybe just passing the object into the constructor of the animation object and giving the name of the property as a string. Instead, I had to fiddle around with classes called NameScope, DependencyProperty and PropertyPath, and I'm still not sure I understand any of them.
So first I create my translation object:
TranslateTransform3D ttmove = new TranslateTransform3D(0, 0, 0);
And a reference to this object is placed inside all the GeometryModel3D objects which need to move around.
Then I create my encapsulation object:
VectorTranslateTransform3D vtt = new VectorTranslateTransform3D(ttmove, new Vector3D(vec.x, vec.y, vec.z), 0);
Then I create a NameScope in my current window and register the translation object with a name.
NameScope.SetNameScope(this,
new NameScope());
this.RegisterName("whyistherumalwaysgone",
vtt);
Then when I create my Storyboard and DoubleAnimation objects, I need to hook them up through the namescope thingie:
DoubleAnimation ia = new DoubleAnimation(blah
blah blah);
Storyboard.SetTargetName(ia, "whyistherumalwaysgone");
And to specify which property is being manipulated for the animation, I have to do this:
Storyboard.SetTargetProperty(ia,
new PropertyPath(VectorTranslateTransform3D.DistanceProperty)));
All this code feels a bit dorky, but I understand why it's there.
In the end, the results are beautiful. I'm not going to publish an xbap demo since everybody had trouble getting the last one to work, presumably because I'm still on WPF beta 2. All this stuff will be easier when WPF is actually a shipping technology.
But suffice it to say that the animation works very well. It's very smooth, with no flicker. The CPU usage graph stays at zero while the animation is running. Using the mouse to rotate and zoom works perfectly even while the animation is going on. I can even print the Viewport3D while the animation is running, with the resulting page showing whatever was on the screen when I clicked the print button.


I -AS loucas aventuras
II -AS loucas aventuras
III - AS loucas aventuras
IV - AS loucas aventuras
Fade In
Fade Out


Image 01
Image 02
Image 03
Image 04
Image 05
Image 06
Image 07
Image 08
Image 09
Image 10
Image 11
Image 12
Image 13
Image 14
Image 15
Image 16
Image 17
Your Name


It is common to store images in a sub-folder. You must then include the folder name in the src attribute:


--- layout: post title: Episode 108 | Avdi Grimm - Your Passion Is Yours and Yours Alone link: http://traffic.libsyn.com/developeronfire/DeveloperOnFire-108-AvdiGrimm.mp3 length: 40488326 speaker: Dave Rael duration: '00:42:08' subtitle: 'Developer On Fire: Avdi Grimm' guest_name: Avdi Grimm image: /assets/images/AvdiGrimm.jpg guest_blog: http://devblog.avdi.org/ guest_twitter: avdi episode_number: 108 book_recommendations: - { url: "http://www.amazon.com/dp/0735619654/?tag=devonfir-20", title: "Object Thinking", author: "David West"} tags: - { url: "http://www.amazon.com/dp/0735619654/?tag=devonfir-20", title: "Object Thinking", author: "David West"} redirect_from: - "/108/" - "/108/" - "/108/" - "/0108/" - "/avdi-grimm-your-passion-is-yours-and-yours-alone/" - "/AvdiGrimm/" - "/Avdi-Grimm/" - "/Podcast/Episodes/108/" - "/Podcast/Episodes/108/" - "/Podcast/Episodes/108/" - "/Podcast/Episodes/0108/" - "/Podcast/Episodes/avdi-grimm-your-passion-is-yours-and-yours-alone/" - "/Podcast/Episodes/AvdiGrimm/" - "/Podcast/Episodes/Avdi-Grimm/" ---
Avdi Grimm is a husband, father, and software creator living in Eastern Tennessee in the foothills of the Smokies. He's a co-host of the Ruby Rogues podcast, author of Confident Ruby and a few books on Ruby development, and the head chef at Ruby Tapas. He's a blogger, conference talker, and a consulting pair-programmer. (photo credit: Robert Potter - http://rep3.com)


Personal Info First name: Last name: Phone: Email: Favorite Food: Salad: Pizza: Chicken: Feedback Message: Choose one of the following: Web developer Rocket scientist Cook Banker Janitor


{% extends 'base.html' %} {% block content %}
You see your neighbour waving from the street. You just helped her find her son's rattle under a pile of twigs.
In the neighbourhood, you are well known for your gardening know-how and inquisitive mind. You have uncovered more local mysteries than you can count -- maths was never your forte anyways. You are not a private investigator, but you could be, you think.
You will eventually summon up the courage to apply for a license. You have learned by now that investigating is not a glamorous endeavour. Your trusty {{ color }} umbrella in hand, you have braved spittle and deluge, dark basements and smelly back alleys whenever called for assistance.
Really, your nickname as the {{ mystical }} of your neighborhood is justified, such is your dedication to puzzles. But... to switch career from a gardener to a proper PI, to have your own agency and wear a fedora all day... You can only dream.
 They have heard of your investigative talent and ask you for help regarding the most unusual of situations.
They have inherited a little cottage in the countryside from relatives. Beside being a little spooky and dusty, it is quite charming and the couple wishes to use it as a summer house.
Recently, the McMillans went into the cottage to tidy it up. It looked like a scene straight out of the early 20th century; the previous house owners had left furniture and decorations intact. As the McMillans walked in, their big dog Montaguë bumped into the dining table, from which a vase fell down. Within its debris, there was a note:
The McMillans ask for your help deciphering the poem. You decide to help them with the riddle and tag along to look at the house.


--- layout: home search_exclude: true --- [![](https://img.shields.io/static/v1?label=View%20On%20Github&message=link&labelColor=2f363d&color=red&style=flat&logo=github&logoColor=959da5)](https://github.com/asvcode) Star Tutorials are listed at the bottom of the page ### What are DICOMs? **DICOM**(**D**igital **I**maging and **CO**mmunications in **M**edicine) is the de-facto standard that establishes rules that allow medical images(X-Ray, MRI, CT) and associated information to be exchanged between imaging equipment from different vendors, computers, and hospitals. The DICOM format provides a suitable means that meets [health infomation exchange](https://www.himss.org/interoperability-and-health-information-exchange) (HIE) standards for transmision of health related data among facilites and HL7 standards which is the messaging standard that enables clinical applications to exchange data.
DICOM files typically have a .dcm extension and provides a means of storing data in seperate **'tags'** such as patient information as well as image/pixel data. A DICOM file consists of a header and image data sets packed into a single file. The information within the header is organized as a constant and standardized series of tags. By extracting data from these tags one can access important information regarding the patient demographics, study parameters, etc 16 bit DICOM images have values ranging from -32768 to 32768 while 8-bit greyscale images store values from 0 to 255. The value ranges in DICOM images are useful as they correlate with the [Hounsfield Scale](https://en.wikipedia.org/wiki/Hounsfield_scale) which is a quantitative scale for describing radiodensity
Parts of a DICOM
### Requirements These tutorials are based on the most recent release of [fastai](https://github.com/fastai/fastai) which was officially released in August 2020 and hence will require installation of `fastai` Also requires installing `pydicom` - `pip install pydicom` and `scikit-image` - `pip install scikit-image` and `kornia` - `pip install kornia===0.2.0` (there is a current incompatability with the lastest version of `kornia`. Installing version `0.2.0` solves this issue ### Using with Google Colab: Click on the link below for an example of loading the dependancies on `Colab` [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/12yzCUieRREEb535XVbPzSzjv_7YUuTeb?usp=sharing) # Posts


This project was done during my time at TI-CEPD,NSIT,Delhi. They have an awesome Winter Internship program going on, Be sure to have a look.
I source a lot of my components from Local Markets in Delhi like Lajpat Rai Market etc. The problem was that when buying stuff from such places we dont always get a part number, datasheet or footprint details with it, this is very bad when you want to use it in a board that you want to etch or fabricate.
There are two ways to overcome this issue (assuming that the package is not standard) :
I used to do it for a long time, until i made this. This is a bit more labourious approach and it involves too much measuring. But , i noticed that most leaded parts can be resolved in a 0.1inch grid.
In this we make a reference for most common footprints and use them as a reference. What’s better is that the known reference helps in finding out packages of some component you found lying in the parts bin.
So, i kept on collecting ideas on what can be made into a tool that helps during the entire cycle from designing the part to etching the board comparing the parts and checking PCBs. Finally i had a list of things to do and started designing the Tool as a PCB on Eagle that can be etched. Nothing could offer me better precison than that.
After a few hours of designing, i etched the board (which took quite an effort), then selectively tinned a few pads and applied protective lacquer on the board.
Here’s what i mananged.
Continuity Tester : Built in basic continuity tester to check whether the tracks are correctly etched or whether there is any under cutting. Just plug those alligator clips on the exposed pads and see the LED light up incase of continuity.
Standard Packages : Some standard packages used, good to compare them and match.
Common Drills : Most common drill sizes(bits) , just see what inserts easily and voila, we have a good enough drill size.
Right angled rule with both inch and cm scale : Right angled makes it easy while cutting PCBs and marking them and cm and inch scales help in measuring.
I have now been using it for quite sometime and its really useful and serves the purpose.
If you are interested in this i can mail you the file , just drop me an email at indiantinker [at] gmail [dot] com.
Cheers!
Rohit
Read moreZu ZU ZU ZU ZU UUUU ..BR.BR.CHIK Thats how my old ‘Phillips All in One’ failed a couple of weeks back. It was a pretty archaic piece. All it could do was play Cassettes, Do Radio, Had an Aux In and offcourse the marketed CD Player with a segmented Display. But today most of the music is digital and hence Upgrade was necessary.
I was planning to buy one and browsing the estores but then then Makers Dilemma struck me.
Why Buy? When it can be Built!
And alas! I was fiddling with microcontrollers and SD Cards to make one. But couldnt get to the level i wanted. I wanted one that could:
Fitting such things in a project would rather be heavenly. I searched online for references and You have it boy! there is one ready to amplify (supply) module from our friends in China that does it all . See this .
I had seen this in a Taxi (less formally called Gramin Seva) while commuting to college once, which made me realise that this would certainly be available in India. The next day i was in the market looking for it and I did source it for about 9 $ (INR 500 )
Now all i need to do is :
Connections were pretty easy as the silkscreen had some references. It basically needs a 5V DC
supply that’s the two pin connected on the left for and give stereo output using the 3 of 4 connectors on right (Right, Left and GND) and the last one is for the FM Antenna
The next part was testing if i will see the blue smoke of death as sometimes they can mess up with silkscreens too. FingersCrossed
It worked fine and i was playing things off the USB straight away!
Now, the power supply and Amplifier. I used the omnipresent 7805 Regulator
that could power the module easily as i estimated the current requirements to be around 250-300mA
. The supply was going to be 12VDC
due to the Amp i was building and hence, a heat sink was necessary.
The Amp was build out of ST’s TDA2030 which is a 14W,voltage friendly, High Fidelity (Correct Portrayl of sound without much loss in clarity), Class AB , Mono Amplifier.
The Application circuit works charm. So, i assembled them on a single perfboard and was short of one heat sink. I now had to decide. Who needs the heat sink badly?
Demo runs showed TDA2030
needs it badly. Now using some thermal glue and nuts and bolts i screwed the heatsink to the TDA2030
and made a makeshift heat sink for 7805
I heard a strange buzz sometimes in the background which was because of some filtering issues. Adding a snubber (filter) for AC frequencies (50Hz) that was almost gone. Used the 10k
and 0.1uF
combination.
I had an Old but dis functional Column 2 component speaker, we had bought probably 12 years down the line. It was the ideal candidate for the purpose. Now opening and digging i found phenolic pcb with broken and corroded traces. I reworked them and the Woofer was working . (Oh! Yeah)
I planned to fit the circuit inside the speaker box itself. For that i had to cut a small square pocket in the body for the module to peep out and the other electronics would be inside it.
This was a bit more difficult than anticipated. After 2 hours and 2 broken saw blades , I was able to do this.
Now it was assembling time.
After a few half hours, i got it all working.. No Buzz and all music!
Cheers!
Rohit
Read moreI had this Nokia LCD i picked up a while back. It is perfect when you want to play with graphics on a tiny lcd that comes from the good old days of Nokia’s Monochome days. Several might have spent days playing space invaders/snakes etc.
The time came when I was bored in my hotel room and I had it in my parts bin which i was carrying while moving from Delhi to Pune.
The LCD used a Phillips PCD 8544 Driver which communicates on SPI.The voltage levels are 2.7-3.3V
happy for our MSP430.
NYC has a pretty nice explanation on how it works and how to play with it with MSP430 over on his blog
For TL:DR;
The LCD has the following pins to interface to:
| Pin Number | Pin Label | Pin Function | Input/Output? | Notes |
|---|---|---|---|---|
| 1 | VCC | Positive power supply | Input | Supply range is between 2.7V and 3.3V |
| 2 | GND | Ground | Input | |
| 3 | SCE | Chip select | Input | Active low |
| 4 | RST | Reset | Input | Active low |
| 5 | D/C | Mode select | Input | Select between command mode (low) and data mode (high). |
| 6 | DN(MOSI) | Serial data in | Input | |
| 7 | SCLK | Serial clock | Input | |
| 8 | LED | LED backlight supply | Input | Maximum voltage supply is 3.3V. |
The display is divided into 6 horizontal bands of 8 bits each (48) and 84 columns .
At a time you write to a single bank.
And you can continue to update only a single bank just in case you have dynamic data in that particular bank.
The communication is done using SPI.
The code that i used is based on RobG’s post.
It displays the temperature (from the internal sensor ofcourse!) and some static text
Connections are as follows(PORT1):
Just incase you need to play more with graphics see this cool post by Sparkfun
If you have any difficulties post here in comments
Read more


|
BlackBone
Windows memory hacking library
|
Public Types | |
| typedef std::list< ModuleData > | listModules |
Public Member Functions | |
| BLACKBONE_API | Native (HANDLE hProcess, bool x86OS=false) |
| BLACKBONE_API const Wow64Barrier & | GetWow64Barrier () const |
| virtual NTSTATUS | VirualAllocExT (ptr_t &lpAddress, size_t dwSize, DWORD flAllocationType, DWORD flProtect) |
| Allocate virtual memory More... | |
| virtual NTSTATUS | VirualFreeExT (ptr_t lpAddress, size_t dwSize, DWORD dwFreeType) |
| Free virtual memory More... | |
| virtual NTSTATUS | VirtualProtectExT (ptr_t lpAddress, DWORD64 dwSize, DWORD flProtect, DWORD *flOld) |
| Change memory protection More... | |
| virtual NTSTATUS | ReadProcessMemoryT (ptr_t lpBaseAddress, LPVOID lpBuffer, size_t nSize, DWORD64 *lpBytes=nullptr) |
| Read virtual memory More... | |
| virtual NTSTATUS | WriteProcessMemoryT (ptr_t lpBaseAddress, LPCVOID lpBuffer, size_t nSize, DWORD64 *lpBytes=nullptr) |
| Write virtual memory More... | |
| virtual NTSTATUS | VirtualQueryExT (ptr_t lpAddress, PMEMORY_BASIC_INFORMATION64 lpBuffer) |
| Query virtual memory More... | |
| virtual NTSTATUS | VirtualQueryExT (ptr_t lpAddress, MEMORY_INFORMATION_CLASS infoClass, LPVOID lpBuffer, size_t bufSize) |
| Query virtual memory More... | |
| virtual NTSTATUS | QueryProcessInfoT (PROCESSINFOCLASS infoClass, LPVOID lpBuffer, uint32_t bufSize) |
| Call NtQueryInformationProcess for underlying process More... | |
| virtual NTSTATUS | SetProcessInfoT (PROCESSINFOCLASS infoClass, LPVOID lpBuffer, uint32_t bufSize) |
| Call NtSetInformationProcess for underlying process More... | |
| virtual NTSTATUS | CreateRemoteThreadT (HANDLE &hThread, ptr_t entry, ptr_t arg, CreateThreadFlags flags, DWORD access=THREAD_ALL_ACCESS) |
| Creates new thread in the remote process More... | |
| virtual NTSTATUS | GetThreadContextT (HANDLE hThread, _CONTEXT64 &ctx) |
| Get native thread context More... | |
| virtual NTSTATUS | GetThreadContextT (HANDLE hThread, _CONTEXT32 &ctx) |
| Get WOW64 thread context More... | |
| virtual NTSTATUS | SetThreadContextT (HANDLE hThread, _CONTEXT64 &ctx) |
| Set native thread context More... | |
| virtual NTSTATUS | SetThreadContextT (HANDLE hThread, _CONTEXT32 &ctx) |
| Set WOW64 thread context More... | |
| virtual ptr_t | getPEB (_PEB32 *ppeb) |
| Get WOW64 PEB More... | |
| virtual ptr_t | getPEB (_PEB64 *ppeb) |
| Get native PEB More... | |
| virtual ptr_t | getTEB (HANDLE hThread, _TEB32 *pteb) |
| Get WOW64 TEB More... | |
| virtual ptr_t | getTEB (HANDLE hThread, _TEB64 *pteb) |
| Get native TEB More... | |
| BLACKBONE_API size_t | EnumRegions (std::list< MEMORY_BASIC_INFORMATION64 > &results, bool includeFree=false) |
| Enumerate valid memory regions More... | |
| BLACKBONE_API size_t | EnumModules (listModules &result, eModSeachType search=LdrList, eModType mtype=mt_default) |
| Enumerate process modules More... | |
| BLACKBONE_API ptr_t | minAddr () const |
| Get lowest possible valid address value More... | |
| BLACKBONE_API ptr_t | maxAddr () const |
| Get highest possible valid address value More... | |
| BLACKBONE_API uint32_t | pageSize () const |
| Get page size More... | |
Protected Attributes | |
| HANDLE | _hProcess |
| Wow64Barrier | _wowBarrier |
| uint32_t | _pageSize |
|
virtual |
Creates new thread in the remote process
| hThread | Created thread handle |
| entry | Thread entry point |
| arg | Thread argument |
| flags | Creation flags |
| access | Access override |
Reimplemented in blackbone::NativeWow64.
| size_t blackbone::Native::EnumModules | ( | listModules & | result, |
| eModSeachType | search = LdrList , |
||
| eModType | mtype = mt_default |
||
| ) |
Enumerate process modules
| result | Found modules |
| mtype | Module type: x86 or x64 |
| size_t blackbone::Native::EnumRegions | ( | std::list< MEMORY_BASIC_INFORMATION64 > & | results, |
| bool | includeFree = false |
||
| ) |
Enumerate valid memory regions
| results | Found regions |
| includeFree | If true - non-allocated regions will be included in list |
|
virtual |
Get WOW64 PEB
| ppeb | Retrieved PEB |
Reimplemented in blackbone::NativeWow64, and blackbone::x86Native.
|
virtual |
Get native PEB
| ppeb | Retrieved PEB |
Reimplemented in blackbone::NativeWow64, and blackbone::x86Native.
|
virtual |
Get WOW64 TEB
| ppeb | Retrieved TEB |
Reimplemented in blackbone::NativeWow64, and blackbone::x86Native.
|
virtual |
Get native TEB
| ppeb | Retrieved TEB |
Reimplemented in blackbone::NativeWow64, and blackbone::x86Native.
|
virtual |
Get native thread context
Reimplemented in blackbone::NativeWow64, and blackbone::x86Native.
|
virtual |
Get WOW64 thread context
Reimplemented in blackbone::NativeWow64, and blackbone::x86Native.
|
inline |
Get highest possible valid address value
|
inline |
Get lowest possible valid address value
|
inline |
Get page size
|
virtual |
Call NtQueryInformationProcess for underlying process
| infoClass | Information class |
| lpBuffer | Output buffer |
| bufSize | Buffer size |
Reimplemented in blackbone::NativeWow64.
|
virtual |
Read virtual memory
| lpBaseAddress | Memory address |
| lpBuffer | Output buffer |
| nSize | Number of bytes to read |
| lpBytes | Mumber of bytes read |
Reimplemented in blackbone::NativeWow64.
|
virtual |
Call NtSetInformationProcess for underlying process
| infoClass | Information class |
| lpBuffer | Input buffer |
| bufSize | Buffer size |
Reimplemented in blackbone::NativeWow64.
|
virtual |
Set native thread context
Reimplemented in blackbone::NativeWow64, and blackbone::x86Native.
|
virtual |
Set WOW64 thread context
Reimplemented in blackbone::NativeWow64, and blackbone::x86Native.
|
virtual |
Change memory protection
| lpAddress | Memory address. |
| dwSize | Region size |
| flProtect | New protection. |
| flOld | Old protection |
Reimplemented in blackbone::NativeWow64.
|
virtual |
Query virtual memory
| lpAddress | Address to query |
| lpBuffer | Retrieved memory info |
Reimplemented in blackbone::NativeWow64, and blackbone::x86Native.
|
virtual |
Query virtual memory
| lpAddress | Address to query |
| lpBuffer | Retrieved memory info |
Reimplemented in blackbone::NativeWow64.
|
virtual |
Allocate virtual memory
| lpAddress | Allocation address |
| dwSize | Region size |
| flAllocationType | Allocation type |
| flProtect | Memory protection |
Reimplemented in blackbone::NativeWow64.
|
virtual |
Free virtual memory
| lpAddress | Memory address |
| dwSize | Region size |
| dwFreeType | Memory release type. |
Reimplemented in blackbone::NativeWow64.
|
virtual |
Write virtual memory
| lpBaseAddress | Memory address |
| lpBuffer | Buffer to write |
| nSize | Number of bytes to read |
| lpBytes | Mumber of bytes read |
Reimplemented in blackbone::NativeWow64.


A B C D E F G H I J L M N O P Q R S T U V W
| R.utils-package | Package R.utils |
| addFinalizerToLast | Modifies .Last() to call 'finalizeSession() |
| addFinalizerToLast.default | Modifies .Last() to call 'finalizeSession() |
| Arguments | Static class to validate and process arguments |
| as.character.binmode | Converts a binary/octal/hexadecimal number into a string |
| Assert | The Assert class |
| attachLocally | Assigns an objects elements locally |
| attachLocally.data.frame | Assigns an objects elements locally |
| attachLocally.environment | Assigns an objects elements locally |
| attachLocally.list | Assigns an objects elements locally |
| bunzip2 | Compressing and decompressing files |
| bunzip2.default | Compressing and decompressing files |
| bzip2 | Compressing and decompressing files |
| bzip2.default | Compressing and decompressing files |
| callHooks | Call hook functions by hook name |
| callHooks.default | Call hook functions by hook name |
| callHooks.function | Call hook functions |
| callHooks.list | Call hook functions |
| capitalize | Capitalizes/decapitalizes each character string in a vector |
| capitalize.default | Capitalizes/decapitalizes each character string in a vector |
| captureOutput | Evaluate an R expression and captures the output |
| ccat | Miscellaneous functions for outputting via message() |
| cmdArg | Simple access to parsed command-line arguments |
| cmdArgs | Simple access to parsed command-line arguments |
| cmsg | Miscellaneous functions for outputting via message() |
| colClasses | Creates a vector of column classes used for tabular reading |
| colClasses.default | Creates a vector of column classes used for tabular reading |
| compressFile | Compressing and decompressing files |
| compressFile.default | Compressing and decompressing files |
| compressPDF | Compresses a PDF (into a new PDF) |
| compressPDF.default | Compresses a PDF (into a new PDF) |
| copyDirectory | Copies a directory |
| copyDirectory.default | Copies a directory |
| countLines | Counts the number of lines in a text file |
| countLines.default | Counts the number of lines in a text file |
| cout | Miscellaneous functions for outputting via message() |
| cprint | Miscellaneous functions for outputting via message() |
| cprintf | Miscellaneous functions for outputting via message() |
| createFileAtomically | Creates a file atomically |
| createFileAtomically.default | Creates a file atomically |
| createLink | Creates a link to a file or a directory |
| createLink.default | Creates a link to a file or a directory |
| createWindowsShortcut | Creates a Microsoft Windows Shortcut (.lnk file) |
| createWindowsShortcut.default | Creates a Microsoft Windows Shortcut (.lnk file) |
| cshow | Miscellaneous functions for outputting via message() |
| cstr | Miscellaneous functions for outputting via message() |
| dataFrame | Allocates a data frame with given column classes |
| dataFrame.default | Allocates a data frame with given column classes |
| decapitalize | Capitalizes/decapitalizes each character string in a vector |
| decapitalize.default | Capitalizes/decapitalizes each character string in a vector |
| decompressFile | Compressing and decompressing files |
| decompressFile.default | Compressing and decompressing files |
| detachPackage | Detaches packages by name |
| detachPackage.default | Detaches packages by name |
| dimNA< - | Sets the dimension of an object with the option to infer one dimension automatically |
| dimNA< -.default | Sets the dimension of an object with the option to infer one dimension automatically |
| dimNA<- | Sets the dimension of an object with the option to infer one dimension automatically |
| dimNA<-.default | Sets the dimension of an object with the option to infer one dimension automatically |
| displayCode | Displays the contents of a text file with line numbers and more |
| displayCode.default | Displays the contents of a text file with line numbers and more |
| doCall | Executes a function call with option to ignore unused arguments |
| doCall.default | Executes a function call with option to ignore unused arguments |
| downloadFile | Downloads a file |
| downloadFile.character | Downloads a file |
| egsub | Global substitute of expression using regular expressions |
| env | Creates a new environment, evaluates an expression therein, and returns the environment |
| evalCapture | Evaluates an expression and captures the code and/or the output |
| extract.array | Extract a subset of an array, matrix or a vector with unknown dimensions |
| extract.default | Extract a subset of an array, matrix or a vector with unknown dimensions |
| extract.matrix | Extract a subset of an array, matrix or a vector with unknown dimensions |
| fileAccess | Checks the permission of a file or a directory |
| fileAccess.default | Checks the permission of a file or a directory |
| filePath | Construct the path to a file from components and expands Windows Shortcuts along the pathname from root to leaf |
| filePath.default | Construct the path to a file from components and expands Windows Shortcuts along the pathname from root to leaf |
| FileProgressBar | A progress bar that sets the size of a file accordingly |
| finalizeSession | Function to call for finalizing the R session |
| finalizeSession.default | Function to call for finalizing the R session |
| findSourceTraceback | Finds all 'srcfile' objects generated by source() in all call frames |
| findSourceTraceback.default | Finds all 'srcfile' objects generated by source() in all call frames |
| gcat | Parses, evaluates and outputs a GString |
| gcat.default | Parses, evaluates and outputs a GString |
| gcat.GString | Parses, evaluates and outputs a GString |
| gcDLLs | Identifies and removes DLLs of packages already unloaded |
| getAbsolutePath | Gets the absolute pathname string |
| getAbsolutePath.default | Gets the absolute pathname string |
| getParent | Gets the string of the parent specified by this pathname |
| getParent.default | Gets the string of the parent specified by this pathname |
| getRelativePath | Gets the relative pathname relative to a directory |
| getRelativePath.default | Gets the relative pathname relative to a directory |
| GString | Character string with advanced substitutions |
| gstring | Parses and evaluates a GString into a regular string |
| gstring.default | Parses and evaluates a GString into a regular string |
| gstring.GString | Parses and evaluates a GString into a regular string |
| gunzip | Compressing and decompressing files |
| gunzip.default | Compressing and decompressing files |
| gzip | Compressing and decompressing files |
| gzip.default | Compressing and decompressing files |
| hasUrlProtocol | Checks if one or several pathnames has a URL protocol |
| hasUrlProtocol.default | Checks if one or several pathnames has a URL protocol |
| hpaste | Concatenating vectors into human-readable strings |
| hpaste.default | Concatenating vectors into human-readable strings |
| inAnyInterval.numeric | Checks if a set of values are inside one or more intervals |
| insert | Insert values to a vector at certain positions |
| insert.default | Insert values to a vector at certain positions |
| installPackages | Install R packages by name or URL |
| installPackages.default | Install R packages by name or URL |
| intervalsToSeq.matrix | Generates a vector of indices from a matrix of intervals |
| intToBin | Converts an integer to a binary/octal/hexadecimal number |
| intToHex | Converts an integer to a binary/octal/hexadecimal number |
| intToOct | Converts an integer to a binary/octal/hexadecimal number |
| isAbsolutePath | Checks if this pathname is absolute |
| isAbsolutePath.default | Checks if this pathname is absolute |
| isBzipped | Compressing and decompressing files |
| isBzipped.default | Compressing and decompressing files |
| isCompressedFile | Compressing and decompressing files |
| isCompressedFile.default | Compressing and decompressing files |
| isDirectory | Checks if the file specification is a directory |
| isDirectory.default | Checks if the file specification is a directory |
| isEof.connection | Checks if the current file position for a connection is at the 'End of File' |
| isFile | Checks if the file specification is a file |
| isFile.default | Checks if the file specification is a file |
| isGzipped | Compressing and decompressing files |
| isGzipped.default | Compressing and decompressing files |
| isOpen.character | Checks if there is an open connection to a file |
| isPackageInstalled | Checks if a package is installed or not |
| isPackageInstalled.default | Checks if a package is installed or not |
| isPackageLoaded | Checks if a package is loaded or not |
| isPackageLoaded.default | Checks if a package is loaded or not |
| isReplicated | Identifies all entries with replicated values |
| isSingle | Identifies all entries that exists exactly once |
| isUrl | Checks if one or several pathnames is URLs |
| isUrl.default | Checks if one or several pathnames is URLs |
| isZero | Checks if a value is (close to) zero or not |
| isZero.default | Checks if a value is (close to) zero or not |
| Java | Static class for Java related methods |
| lastModified | Gets the time when the file was last modified |
| lastModified.default | Gets the time when the file was last modified |
| LComments | The LComments class |
| listDirectory | Gets the file names in the directory |
| listDirectory.default | Gets the file names in the directory |
| loadObject | Method to load object from a file or a connection |
| loadObject.default | Method to load object from a file or a connection |
| mapToIntervals.numeric | Maps values to intervals |
| mcat | Miscellaneous functions for outputting via message() |
| mergeIntervals.numeric | Merges intervals |
| mkdirs | Creates a directory including any necessary but nonexistent parent directories |
| mkdirs.default | Creates a directory including any necessary but nonexistent parent directories |
| mout | Miscellaneous functions for outputting via message() |
| mpager | A \"pager\" function that outputs to standard error |
| mprint | Miscellaneous functions for outputting via message() |
| mprintf | Miscellaneous functions for outputting via message() |
| mshow | Miscellaneous functions for outputting via message() |
| mstr | Miscellaneous functions for outputting via message() |
| nullcon | Gets the pathname or a connection to the NULL device on the current platform |
| nullfile | Gets the pathname or a connection to the NULL device on the current platform |
| NullVerbose | A Verbose class ignoring everything |
| onGarbageCollect | Registers a function to be called when the R garbage collector is (detected to be) running |
| onGarbageCollect.default | Registers a function to be called when the R garbage collector is (detected to be) running |
| onSessionExit | Registers a function to be called when the R session finishes |
| onSessionExit.default | Registers a function to be called when the R session finishes |
| Options | The Options class |
| parseRepos | Sets package repositories |
| patchCode | Patches installed and loaded packages and more |
| patchCode.default | Patches installed and loaded packages and more |
| popBackupFile | Drops a backup suffix from the backup pathname |
| popBackupFile.default | Drops a backup suffix from the backup pathname |
| popTemporaryFile | Drops a temporary suffix from the temporary pathname |
| popTemporaryFile.default | Drops a temporary suffix from the temporary pathname |
| printf | C-style formatted output |
| printf.default | C-style formatted output |
| ProgressBar | Provides text based counting progress bar |
| pushBackupFile | Appends a backup suffix to the pathname |
| pushBackupFile.default | Appends a backup suffix to the pathname |
| pushTemporaryFile | Appends a temporary suffix to the pathname |
| pushTemporaryFile.default | Appends a temporary suffix to the pathname |
| queryRCmdCheck | Gets the on R CMD check if the current R session was launched by it |
| R.utils | Package R.utils |
| readBinFragments | Reads binary data from disjoint sections of a connection or a file |
| readBinFragments.default | Reads binary data from disjoint sections of a connection or a file |
| readRdHelp | Reads one or more Rd help files in a certain format |
| readRdHelp.default | Reads one or more Rd help files in a certain format |
| readTable | Reads a file in table format |
| readTable.default | Reads a file in table format |
| readTableIndex | Reads a single column from file in table format |
| readTableIndex.default | Reads a single column from file in table format |
| readWindowsShortcut | Reads a Microsoft Windows Shortcut (.lnk file) |
| readWindowsShortcut.default | Reads a Microsoft Windows Shortcut (.lnk file) |
| removeDirectory | Removes a directory |
| removeDirectory.default | Removes a directory |
| replicates | Identifies all entries with replicated values |
| resample | Sample values from a set of elements |
| resample.default | Sample values from a set of elements |
| saveObject | Saves an object to a file or a connection |
| saveObject.default | Saves an object to a file or a connection |
| seqToHumanReadable | Gets a short human readable string representation of an vector of indices |
| seqToHumanReadable.default | Gets a short human readable string representation of an vector of indices |
| seqToIntervals | Gets all contiguous intervals of a vector of indices |
| seqToIntervals.default | Gets all contiguous intervals of a vector of indices |
| setOption | Sets a option in R |
| setOption.default | Sets a option in R |
| Settings | Class for applicational settings |
| shell.exec2 | Open a file or URL using Windows File Associations |
| singles | Identifies all entries that exists exactly once |
| SmartComments | Abstract class SmartComments |
| sourceDirectory | Sources files recursively to either local or global environment |
| sourceDirectory.default | Sources files recursively to either local or global environment |
| sourceTo | Parses and evaluates code from a file or a connection |
| sourceTo.default | Parses and evaluates code from a file or a connection |
| splitByPattern | Splits a single character string by pattern |
| splitByPattern.default | Splits a single character string by pattern |
| stext | Writes text in the margin along the sides of a plot |
| stext.default | Writes text in the margin along the sides of a plot |
| strayDLLs | Identifies and removes DLLs of packages already unloaded |
| subplots | Creates a grid of subplots |
| subplots.default | Creates a grid of subplots |
| System | Static class to query information about the system |
| systemR | Launches another R process from within R |
| systemR.default | Launches another R process from within R |
| TextStatusBar | A status bar at the R prompt that can be updated |
| TimeoutException | TimeoutException represents timeout errors |
| touchFile | Updates the timestamp of a file |
| touchFile.default | Updates the timestamp of a file |
| toUrl | Converts a pathname into a URL |
| toUrl.default | Converts a pathname into a URL |
| unwrap.array | Unwrap an array, matrix or a vector to an array of more dimensions |
| unwrap.data.frame | Unwrap an array, matrix or a vector to an array of more dimensions |
| unwrap.default | Unwrap an array, matrix or a vector to an array of more dimensions |
| unwrap.matrix | Unwrap an array, matrix or a vector to an array of more dimensions |
| useRepos | Sets package repositories |
| VComments | The VComments class |
| Verbose | Class to writing verbose messages to a connection or file |
| withCapture | Evaluates an expression and captures the code and/or the output |
| withLocale | Evaluate an R expression with locale set temporarily |
| withOptions | Evaluate an R expression with options set temporarily |
| withRepos | Evaluate an R expression with repositories set temporarily |
| withSeed | Evaluate an R expression with a temporarily set random set |
| withSink | Evaluate an R expression while temporarily diverting output |
| withTimeout | Evaluate an R expression and interrupts it if it takes too long |
| wrap.array | Reshape an array or a matrix by permuting and/or joining dimensions |
| wrap.data.frame | Reshape an array or a matrix by permuting and/or joining dimensions |
| wrap.matrix | Reshape an array or a matrix by permuting and/or joining dimensions |
| writeBinFragments | Writes binary data to disjoint sections of a connection or a file |
| writeBinFragments.default | Writes binary data to disjoint sections of a connection or a file |
| writeDataFrame | Writes a data.frame to tabular text file |
| writeDataFrame.data.frame | Writes a data.frame to tabular text file |


Enter text that should match, and result of $1.expect re.match(____)[1] == ___
Enter text that should not match.expect !re.match(___)
Give me a hint.


--- title: Wisp Lisp layout: post tags: [lisp] uuid: f42662c9-f81e-361a-e342-58f9536ed0f8 ---
Update 2010-2-04: A lot of the information below is out of date. There is an update here: Wisp Screencasts.
This is a project I've been wanting to do for some time, and I finally got around to doing it. I spent the last few days implementing my own lisp interpreter in C. Today, after sinking in about 48 hours of work, I believe I completed enough of it to consider it in a working state, with a code base stable enough that other interested people could contribute. It was really exciting to see everything come together today.
You can make a clone of the Wisp repository with Git.
It doesn't use the readline library or one of it's clones to make a
nice interaction command line, so it's a good idea to run it
with rlwrap. That's
what I've been doing. If you plan on writing Wisp code in Emacs,
putting this in your .emacs
will give you all the syntax
niceties,
You should also be able to run it as an inferior lisp and send code to it like a normal lisp. I haven't done this yet myself.
I think the name is apt, because it really is a wisp of a lisp. As of this writing, it weighs in at 1500 lines of code and is still very feature-light. I haven't actually read any material about writing lisp interpreters, so I've been winging it based on my experience with it. It's already taught me a lot of subtle things about lisp that I hadn't been aware of before.
Right know it's very simple. It doesn't yet support any syntax beyond
parenthesis (no '
quoting). No closures. No garbage
collection, as I'm still working out how I'm going to do
that. Dynamically scoped, since that's a lot easier to do. And, like
Scheme, it's a lisp-1, meaning functions and variables share a common
namespace. I hope to expand it to include some features from other
lisps like Arc (particularly the anonymous function syntactical
sugar), Common Lisp, and Scheme.
However, it does have already anonymous functions, which many popular languages still don't have. :-) It's far enough along to let you define crazy stuff like this,
{% highlight cl %} (defun example (n) (if (<= n 0) (lambda (x) (* x 10)) (lambda (x) (* x 2.0)))) {% endhighlight %}Which you can call, interactively in this case, like so,
{% highlight cl %} wisp> ((example 1) 20) 40.000000 wisp> ((example -1) 20) 200 {% endhighlight %}Because there's no garbage collection yet, it leaks memory like a sieve. For garbage collection, I think I'll do a mark-and-sweep, marking objects based on their reachability from the symbol table. That still leaves some corner cases — such as worrying about objects in limbo in the evaluator — that I'm not sure about. I need to be careful not to free objects still in use. Still working that one out.
It has the multiplication, addition, subtraction, and division implemented, as well as the greater-than and less-than operators. Lisp macros are implemented. A number of special forms are defined, like let, if, set, defun, defmacro, car, cdr, not, progn, lambda, and while. All of the predicates are implemented. It has a C interface, which is how all the above got defined. I already have some functions and macros defined in terms of Wisp code, too. Most of the needed functions at this point are trivial to add, though a bit tedious, so I'm mostly trying to focus on the core parts of the interpreter right now.
It's amazing how much the internal code looks like lisp written in a C dialect. I have CAR and CDR macros defined, which get used all over the place, and code frequently uses them to walk lists like lisp code would.
The core struct that everything works with the the object struct. It's defined as such,
{% highlight c %} typedef struct object { type_t type; void *val; } object_t; {% endhighlight %}
The type_t
field comes from this enumeration,
The type indicates what type of data the void pointer points to, making it sort-of polymorphic. Note the CONS type, the cons cell, used to create lists,
{% highlight c %} typedef struct cons { object_t *car; object_t *cdr; } cons_t; {% endhighlight %}
There's the familiar car and cdr pointers.  For
example, c_cons()
creates a cons cell,
Look familiar? Yup, that's the lisp cons
function. Since
the nil
symbol is available in C code as NIL
you can chain these together in C to make a list,
Which puts together the simple list,
{% highlight cl %} (10 "hello") {% endhighlight %}Since that's so cumbersome to write out, there's a parser that can read nice lisp code and use all those same functions to make the lists. Hence, the lisp reader.
If you want to help, it's pretty easy to add more CFUNCs, C functions
that are exposed to Wisp lisp code.  The TODO
file in the
repository contains more things to be done.
Wisp will probably be getting it's own "project page" here at some point in the future. When it does, I'll update this post to point to it.
Oh, and I decided to make this available under a 2-clause BSD license, so someone could easily plug it into another program as an extension language (once Wisp has matured first, of course). That would be cool.


Sephiroth/Lila 25K
Dates 2018-05-11 to 2018-05-25
Max Laps 3
Lapis Cost per Lap 25000
Base 5★ in EX pool 58
Summary
| 1 Lap | 2 Laps | 3 Laps | |
|---|---|---|---|
|
Probability for
|
64.68% | 87.53% | 95.59% |
|
Probability for 7★
|
17.03% | 53.86% | 77.76% |
|
Probability for STMR
|
0.27% | 5.56% | 22.04% |
Stats per Lap
Pulls and Rates
| Pulls |
Rate
|
Banner Rate
OR
|
Rainbow Rate
|
|---|---|---|---|
| 47 | 0.5% | 1% | 3% |
| 5 | 1.875% | 3.75% | 5% |
| 1 | 50% | 100% | 100% |
| 1 | 1.724% | 3.448% | 100% |
Expected Value
Sephiroth
0.85
Banner Rainbows
OR
1.69
Rainbows
3.66
Probability for at least X units
| X |
Sephiroth
|
Banner
OR
|
Rainbows
|
|---|---|---|---|
| 1 | 64.682% | 100% | 100% |
| 2 | 17.028% | 50.27% | 100% |
| 3 | 2.597% | 15.197% | 81.512% |
| 4 | 0.27% | 3.169% | 49.772% |
| 5 | 0.021% | 0.495% | 23.071% |
| 6 | 0.001% | 0.061% | 8.401% |
| 7 | 0% | 0.006% | 2.48% |
Probability for exactly X units
| X |
Sephiroth
|
Banner
OR
|
Rainbows
|
|---|---|---|---|
| 0 | 35.318% | 0% | 0% |
| 1 | 47.654% | 49.73% | 0% |
| 2 | 14.431% | 35.073% | 18.488% |
| 3 | 2.326% | 12.028% | 31.74% |
| 4 | 0.249% | 2.674% | 26.701% |
| 5 | 0.02% | 0.434% | 14.671% |
| 6 | 0.001% | 0.055% | 5.92% |
| 7 | 0% | 0.006% | 1.871% |
Pulls and Rates
| Pulls |
Rate
|
Banner Rate
OR
|
Rainbow Rate
|
|---|---|---|---|
| 94 | 0.5% | 1% | 3% |
| 10 | 1.875% | 3.75% | 5% |
| 2 | 50% | 100% | 100% |
| 2 | 1.724% | 3.448% | 100% |
Expected Value
Sephiroth
1.69
Banner Rainbows
OR
3.38
Rainbows
7.32
Probability for at least X units
| X |
Sephiroth
|
Banner
OR
|
Rainbows
|
|---|---|---|---|
| 1 | 87.526% | 100% | 100% |
| 2 | 53.865% | 100% | 100% |
| 3 | 20.963% | 75.269% | 100% |
| 4 | 5.565% | 40.386% | 100% |
| 5 | 1.089% | 16.121% | 96.582% |
| 6 | 0.166% | 5.024% | 84.846% |
| 7 | 0.021% | 1.27% | 64.899% |
Probability for exactly X units
| X |
Sephiroth
|
Banner
OR
|
Rainbows
|
|---|---|---|---|
| 0 | 12.474% | 0% | 0% |
| 1 | 33.661% | 0% | 0% |
| 2 | 32.902% | 24.731% | 0% |
| 3 | 15.397% | 34.883% | 0% |
| 4 | 4.476% | 24.264% | 3.418% |
| 5 | 0.923% | 11.097% | 11.736% |
| 6 | 0.146% | 3.754% | 19.947% |
| 7 | 0.018% | 1.002% | 22.374% |
Pulls and Rates
| Pulls |
Rate
|
Banner Rate
OR
|
Rainbow Rate
|
|---|---|---|---|
| 141 | 0.5% | 1% | 3% |
| 15 | 1.875% | 3.75% | 5% |
| 3 | 50% | 100% | 100% |
| 3 | 1.724% | 3.448% | 100% |
Expected Value
Sephiroth
2.54
Banner Rainbows
OR
5.08
Rainbows
10.98
Probability for at least X units
| X |
Sephiroth
|
Banner
OR
|
Rainbows
|
|---|---|---|---|
| 1 | 95.594% | 100% | 100% |
| 2 | 77.762% | 100% | 100% |
| 3 | 48.3% | 100% | 100% |
| 4 | 22.035% | 87.701% | 100% |
| 5 | 7.554% | 61.68% | 100% |
| 6 | 2.022% | 34.404% | 100% |
| 7 | 0.437% | 15.518% | 99.368% |
Probability for exactly X units
| X |
Sephiroth
|
Banner
OR
|
Rainbows
|
|---|---|---|---|
| 0 | 4.406% | 0% | 0% |
| 1 | 17.833% | 0% | 0% |
| 2 | 29.462% | 0% | 0% |
| 3 | 26.265% | 12.299% | 0% |
| 4 | 14.481% | 26.021% | 0% |
| 5 | 5.533% | 27.276% | 0% |
| 6 | 1.584% | 18.886% | 0.632% |
| 7 | 0.359% | 9.718% | 3.255% |


watex: A machine learning in hydro-geophysics#
Synopsis
WATex is a Python package focused on the groundwater exploration field. It brings piece solutions to minimize the losses during the hydro-geophysical engineering projects. It uses the geophysical methods combined with the machine learning approaches to predict some water content targets. More about the ideas behind the package can be found in the introductory notes.
To getting started with the software, refer to the installation guide. You can also browse the examples page to see some of the expected results you can achieve using the software. The user guide is more in-depth guide about the different methods implemented supported by theories and concrete examples.


Money Game. How should Red play 62?
pips Red=153 White=151
(CorrectAnswer= 0/0, ErrorScore= 0)
This position occurred in last weekend's tournament in Texas. The message here is very simple - take what the dice give you!
You could try 22/16, 13/11 or 24/16 or 22/14 all of which have their merits but all of which give white some inviting targets to attack.
The simple 24/22, 13/7 is best and any other play is at least an error. The play creates an anchor, distributes a builder to a useful point and leaves no shots. With the race being very close this is the logical approach.
You could try 22/16, 13/11 or 24/16 or 22/14 all of which have their merits but all of which give white some inviting targets to attack.
The simple 24/22, 13/7 is best and any other play is at least an error. The play creates an anchor, distributes a builder to a useful point and leaves no shots. With the race being very close this is the logical approach.
1. Cubeful 2-ply 24/20 10/5 Eq.: +0.021 0.499 0.210 0.014 - 0.501 0.161 0.009 2. Cubeful 2-ply 24/15 Eq.: -0.007 (-0.028) 0.499 0.191 0.011 - 0.501 0.181 0.013 3. Cubeful 2-ply 10/1* Eq.: -0.035 (-0.055) 0.479 0.221 0.008 - 0.521 0.172 0.013 4. Cubeful 2-ply 13/8 5/1* Eq.: -0.139 (-0.160) 0.460 0.214 0.008 - 0.540 0.204 0.023 5. Cubeful 0-ply 24/20 13/8 Eq.: -0.309 (-0.330) 0.425 0.163 0.011 - 0.575 0.239 0.035


{% extends 'base.html' %} {% block title %}Geomancer{% endblock %} {% block content %}
Add geographically-related data to any spreadsheet.
All you need is a spreadsheet that includes a column about a location, like city, state or congressional district.
Take a look at the data sources and geographies we support.
Interested in integrating Geomancer into an application? Check out the API!


Manny Diaz Announces Update On Miami QB Tate Martell
by Alek ArendMiami’s 2019 season has gone through its ups and downs. The Hurricanes are 6-4 with two regular season games remaining against FIU and Duke.
Things haven’t gone Manny Diaz’ way this season. The same can be said for QB/WR Tate Martell.
Martell has had to bounce back and forth between quarterback and receiver during his time with the Hurricanes. But it appears his days at receiver are over, according to the tweet below.
Martell didn’t have any success catching passes for Miami as he didn’t record a single reception this season. All-in-all, he has just two carries for two yards through 10 games this year.
Martell now has the opportunity to focus 100 percent on quarterback, the position he was recruited to play in college.
The highly touted prospect out of Bishop Gorman high school has had a whirlwind of a collegiate career thus far. His days at Ohio State were short lived, and a transfer to Miami seemed to open a few doors for Martell.
But the quarterback hasn’t thrown a pass for the Hurricanes. In pre-season fall camp, rumors started to swirl regarding a position change to wide receiver. Those rumors were confirmed during Miami’s season opening loss to Florida as Martell lined up at receiver.
Will a move back to quarterback help Martell resurrect his skill-set?