NormaTec - Pneumatic Medicine Treatments for Wounds, Venous Insufficiency, Lymphedema, Sports Injuries, and Other Circulatory and Peripheral Vascular Conditions
Introducing the NormaTec PCD
Harnessing the power of Pneumatic Medicine, the NormaTec PCD (Pneumatic Compression Device) uses a patented Peristaltic Pulse to provide dynamic compression to limbs compromised by poor circulation.
Achieve outstanding results treating:
non-healing wounds
venous insufficiency
lymphedema
sports injuries
other circulatory and peripheral vascular conditions
Watch a quick video on how to use the NormaTec PCD.
Call 1-800-335-0960 now to speak with a NormaTec nurse
or explore one of the sections below:
Learn about the
NormaTec PCD, how it works, insurance coverage, and the medical conditions that are finally treatable.
Explore how the
NormaTec PCD can help your patients with circulatory disorders, and how to start prescribing.
Discover how athletes and athletic trainers use NormaTec's sports model, the NormaTec MVP, to train harder, recover faster, and perform better.From eLinux.org
The onboard UART-controller can usually be tested via a loop-back connection using a cable. However, when testing the behavior during suspend/resume this is not feasible and an external platform having a UART device is needed as a test stub.
The following describes such a setup and how it can be used for testing UART HW flow control and wake-up.
Specifically this test setup was created to test the omap-serial UART driver which was introduced in the kernel to enable some OMAP specific features as eg. DMA and Power Management without cluttering the previously used 8250 UART driver.
As of writing, the omap-serial driver configures the OMAP UART CTS pins as wakeup-enabled.
Refer to . The board on the left is a Zoom2, and the board on the right is a Zoom1. The Zoom2 is the device we want to test. The Zoom1 is merely acting as a test device and could in principle be replaced with any other platform on which it is possible to control the UARTs RX/TX and RTS/CTS pins (eg. a PC). Going forward, this guide will assume a Zoom1 is used.
An expansion card is plugged into the 200-pin expansion connector on each of the 2 boards (see
- the Zoom2 has been flipped upside-down). The reason for this is to expose UART1 on the boards, which is otherwise not easily accessible. The expansion boards are modified modem test boards, which have the 200-pin connector's UART1 RX/TX and RTS/CTS lines routed through an RS232 driver and level converter. This exposes the UART1 as any normal RS-232 interface.
Note. Make sure to remove any modem inserted in either zoom board before testing. They also use UART1.
A null-modem cable (female-female, RX/TX and RTS/CTS lines crossed) is used to interconnect the 2 expansion cards.
So, to sum up, here's the HW required for the setup:
2 Modem expansion cards
1 RS-232 null-modem cable
The device under test (Zoom2) needs to run the kernel with the UART driver to be tested.
The omap-serial driver has to be enabled, if not already. So run make menuconfig and enable it - also with console. The test description below does not assume that DMA is enabled, but there is not reason it could not be. On the Zoom2 kernel, also disable the 8250 serial driver.
The enabling/disabling of serial drivers can be found in menuconfig under: device drivers-&Char Drivers-&Serial Drivers
The following text assumes that a kernel from the p-android-omap-2.6.29 branch on the APG sync-tree:
is used at commit ID not older than af04c2b6f263d28a5e54.
The test device (Zoom1) can run any kernel, as long as the driver allows for control of the RTS line on UART1. In this setup the control is implemented as a sys-fs entry, which toggles the RTS output line of the zoom1.
To accommodate this, the following changes were made to drivers/serial/8250.c in the kernel:
The patch is based of Android APG kernel, commit ID 8e0ee43bc2c3e19db56a4adaa9a9b04ce885cd84, available at
The sys-fs node is used like this:
Toggle the RTS output (using OMAP mux safe mode pull-up and pull-down):
#echo 1 & /sys/devices/platform/serial8250.0/uart1_rts_toggle
Set the RTS pin to UART mode, to be used for normal HW flow control
#echo 0 & /sys/devices/platform/serial8250.0/uart1_rts_toggle
The RTS line, when used for normal HW flow control, only enables/disables the other device's ability to send data. It is connected to the other device's CTS input. In this context, RTS stands for: "Request To Send to me". When asserted, the other device can send data. When de-asserted the other device is blocked from sending data. Thus, if the purpose of the test solely is to test the other device during power management (the Zoom2), the RTS pin can be put into safe mode and toggled randomly on the Zoom1 without impacting the flow of data to the Zoom2.
As for the file systems used, the following sections Android FS on the Zoom2 and Busybox FS on the Zoom1.
To verify the operation of the RTS toggling, boot the Zoom1 and echo 1 into the sys-fs node, while scope-probing the physical RTS line shown on , which shows a detailed photo of the DB9 connector on the expansion card. Remember that the RS-232 driver inverts the signal, so an assertion of RTS, which is logical low on the OMAP, translates to a "high" signal on the RS-232 cable.
The purpose of the user-space test application is two-sided: Data needs to be sent from the Zoom1 and the RTS pin needs to be toggled, and on the Zoom2 side data needs to be received. Also, when sending data, the application should be able to send sporadic burst to simulate the behavior of eg. control data from a modem. This would help test some PM aspects (eg. inactivity timeouts).
Using an existing UART test application written by TI developers in India as basis, the above requirements could be fulfilled using the same small application on both the Zoom1 and Zoom2 side. Depending on its mode of operation (send/receive), the application can be configured using command-line parameters.
The source code for the application ts_uart is available here:
Compilation
To compile for ARM and busybox file system, you need to specify the location of your cross-compiler in the CROSS_COMPILE environment variable. Eg., after cd'ing to the source directory:
#make CROSS_COMPILE=/usr/bin/arm-2009q1/bin/arm-none-linux-gnueabi ts_uart
To compile for use in the Google Android file system, as of writing, the google compiler is required, since Android links up against its own Bionic c libraries. To do this, copy the ts_uart source dir into /path/to/mydroid/external/
Then, to compile, cd to /path/to/mydroid and run:
#make -j2 ts_uart
Look at the output logs to see where the executable is moved.
Deploy the ts_uart test application to both the Zoom1 and Zoom2 file systems - preferably in a dir that's included in the PATH variable. Connect the boards as mentioned above with a null-modem cable.
To get console control of each board, one needs to have two serial terminal emulators running on one's PC, eg. minicom. The two minicoms each need to connect to the UART or USB port of the PC, that is wired to the console UART port on each of the boards.
After boot-up, a the connection between the boards can be verified (if needed) using a terminal emulator running on each board (eg. nanocom, microcom, picocom, minicom). The source for these is available on the internet, but needs to be compiled for ARM.
In the console, just connect each terminal emulator program to /dev/ttyS0 at 115200 baud respectively. When typing something in one terminal, it should appear in the other.
Also, have test file ready for transfer in the same directory as the ts_uart directory on the Zoom1. Any file can be used, but it should be something that can easily be checked for integrity afterwards, like eg, a PDF file. Currently the application does not support any data validation upon transfer, so a manual method is needed.
The first test should be without power management on the Zoom2 (more specifically, without retention and OFF mode) enabled.
To see a help screen listing the parameters to ts_uart, just cd to its dir and run it without parameters:
On the Zoom2:
Configure ts_uart for receiving data into sample.file at 115200 baud with flow control enabled:
#ts_uart ts_uart r sample.file
The last 2 parameters are just dummies, when receiving data.
On the Zoom1:
Before the ts_uart receive on the Zoom2 times out (about 10 seconds), configure ts_uart on Zoom1 for sending data from sample.file at 115200 baud with flow control enabled:
#ts_uart ts_uart s sample.file
When sending, the last two parameters do take effect. In this case, no delay between bursts or random data burst size is set, so ts_uart will transmit data at maximum speed (the given baud rate).
Note: As of now, the ts_uart application always sends/receives on /dev/ttyS0.
The sample.file should transfer, and a confirmation log should be printed in the console on both sending and receiving side. Even if it the number of bytes sent and received is identical, it is sensible to check for data validity.
Since neither OFF or Retention mode has been enabled, the Zoom2 does not fall into low power states. The only power-saving feature that could kick in is the cpu idle thread after some inactivity timer expires. As of writing this, however, when DMA is disabled, this timer is reset upon each received interrupt on the RX pin. If DMA is enabled, the timer is reset after a given DMA timeout, if there is still data in the RX FIFO.
Thus, while data is being transferred continuously, the Zoom2 idle thread never kicks in.
Try changing the ts_uart parameters for the Zoom1 to the following and re-run the test:
#ts_uart ts_uart s sample.file
The last 2 parameters now introduce a random delay between each buffer sent up to 6 seconds and also randomly changes the size of the buffer being sent between 0-4096 bytes.
If printk()s were placed in omap_uart_idle() function in the Zoom2 kernel, one would see that the idle thread kicks in between data bursts. The active state is then resumed upon receipt of RX data, and the inactivity timer is reset.
Enable the OFF mode or Retention transitions during idle for the Zoom2:
#echo 1 & /sys/power/sleep_while_idle
Issue the following, or press the "OFF" button on the keypad on the Zoom2:
#echo -n "mem" & /sys/power/state
This suspends the board. It's possible to wake it up again either by pressing a keypad or by typing something in the console. Another way of waking it up is by toggling the CTS line, which is what the ts_uart test application will do.
Now then, rerun the same test as above.
On the Zoom2:
#ts_uart ts_uart r sample.file
On the Zoom1:
#ts_uart ts_uart s sample.file
The random delay between burst is now up to 9 seconds. Furthermore, when a delay other than 0 is set, the RTS line of the Zoom1 (that is, the CTS line of Zoom2) is toggled before each data burst is transmitted to the Zoom2. The line is toggled in ts_uart using the previously mentioned sysfs interface uart1_toggle_rts. Because the current omap-serial driver has CTS wakeups enabled, the toggling of the CTS line on the Zoom2 will wake-up the board from suspend. Thus, the Zoom2 will be in active state and ready to receive the data.
However, a problem was reported regarding the state of the RTS pin on the Zoom2. It was found that the RTS, which should be de-asserted by hardware when the device goes to retention or OFF, was not de-asserted when the board went into low power modes. This resulted in lost data, since the sending device saw an asserted Zoom2 RTS, and for HW flow control that means that the Zoom2 is ready to receive data when it is not.
A software workaround was introduced to "manually" de-assert the RTS line in the omap-serial driver, when a driver shutdown was initialized based on an active to low-power transition. This was done by putting the pin into mux SAFE mode. The pin would be returned to normal UART mode when leaving the low-power state.
The patch needed for this has been ported to the p-android-omap-2.6.29 branch:
The expected result when doing this transfer is that the delay between each burst should allow the Zoom2 to suspend, after which it will wake up when its CTS line is toggled by the Zoom1, thus enabling the Zoom1 to send data.This item has been banned because it violates the Steam Terms of Service. It is only visible to you. If you believe your item has been banned mistakenly, please contact .
This item is incompatible with Greenlight. Please see the
for reasons why this item might not work within Greenlight.
Current visibility:&Hidden
This item will only be visible to you, admins, and anyone marked as a creator.
Current visibility:&Friends-only
This item will only be visible in searches to you, your friends, and admins.
Asagao Academy: Normal Boots Club
Description
Discussions
Announcements
#text_need_flash_capsule_lrg
#text_need_flash_capsule_lrg
#text_need_flash_capsule_lrg
#text_need_flash_capsule_lrg
#text_need_flash_capsule_lrg
#text_need_flash_capsule_lrg
#text_need_flash_capsule_lrg
#text_need_flash_capsule_lrg
Autoplay videos
Unfavorite
Add to Collection
This item has been added to your .
2 Nov, 2014 @ 7:02pm
7 Jan @ 11:08am
Created by
Last Online 2 hrs, 18 mins ago
Illus Seed
Last Online 383 days ago
(some may be hidden)
Kickstarter
Hello, everyone!
There's only 16 hours left on the . If you were interested in donating or wanted to get a certain reward, this is your last chance!
Additionally, the members of Hidden Block are confirmed for the game as the rival club for the Normal Boots Club in the gaming tournament. This means that Brutalmoose, SpaceHamster, Caddicarus, NintendoFanFTW, Yungtown, and BalrogtheMaster will all be making appearances in the game alongside the Normal Boots crew.
We're 28% of the way towards the Top 100 - that's amazing! If you want to see this game on Greenlight, please keep voting and spreading the word.
Thanks again!
- Cara
Hello, everyone!
I just wanted
to thank you so much for your support. We've raised over $6,000 for the project (halfway there!) and we're already more than 10% of the way to the Top 100!
We've just released a new gameplay video, this one featuring Jared the part-time model. You can watch it in the media above, or by
Thank you all once again, and keep commenting and showing your support!
Cara
Disclaimer: This game is being created with permission from Normal Boots, although we are not officially affiliated with Normal Boots or its members.
When things in her life get to be too much to handle, Hana Mizuno transfers to Asagao Academy to start fresh. Once there, she runs into the Normal Boots Club - a group of handsome, competitive gamers, and the most popular guys in school. And they need her to compete in this year's gaming tournament!
Asagao Academy: Normal Boots Club is a free fan-made otome game (romance-oriented visual novel from a female perspective) based on the guys of Normal Boots. It is light-hearted and tongue-in-cheek, affectionately parodying visual novel, anime, and video game tropes, while also incorporating a serious story about a girl's journey through romance and friendship.
Support us on Kickstarter!
2 Nov, 2014 @ 10:23pm
What's the name of the song in the first video?
{3G} Dirty Macarons
You need to sign in or create an account to do that.
On Facebook
Enter the full URL of your item or group's Facebook page
On Twitter
Enter the full URL of your item or group's Twitter page
On Youtube
If you have a related Youtube channel, enter the URL.
Steam Community Group
Do you have a Steam Community group for followers of this item?
Kickstarter Project
Is your project on Kickstarter?
Indiegogo Project
Or on Indiegogo?
IndieDB Page
If your project is also on IndieDB
View mobile websiteTop 8 WORST Zelda Items! – PBG (Ft. MatPat)
the latest video by
& / & November 18, 2015
Watch the Game Theory collab! ? /watch?v=ZtYoL...
Exclusive Zelda Month Shirts HERE! Only through November! ? /peanutbuttergamer
PeanutButterGamer a ...
You’ll never know what you can find in a Hidden Block.
The best source of gaming trivia on the web.
Providing general trivia about the subject of video games.
Home of the AVGN and Monster Madness, New videos weekly.