]]>End of shift - one of the operators is leaving with his backpack slung over a shoulder. The other strap happens to catch the Halon release button by the door.
No problem. Pulling the button off did not cause a Halon release.
Putting the button back however...
Situated in the beautiful heart of Texas, Austin is one of the greatest creative and startup environment in the US. We have bands uploading videos and music, digital movie distribution, and the Silicon Hills full of gaming companies and IT startups. The annual SXSW film, interactive media and music conference bring thousands of creative people into town every spring.Submit your city here.
Austin is the hub for Smart metering and Green Power initiatives. AustinEnergy, our municipal owned power provider, is a leader in progressive power delivery. Texas is the largest generator of Wind Power in the US due to AustinEnergy's GreenChoice program. The city and the utility have partnered to form the Pecan Street project, which funds and provides technical assistance to Green Power and Green transportation startups.
This creates an unquenchable thirst for connectivity. Yet Austin is trapped in the Bermuda triangle of bandwidth. Surrounded by the large cities of Dallas, Houston, and San Antonio much connectivity and access bypasses Austin, going for the large datacenter havens in those cities. Choices for broadband providers are limited to the cable monopoly, and the phone monopoly. Both provide moderate download, but significantly restricted upload speeds. Neither provider offers a fiber to the home product, and neither is investing funds to upgrade their last mile connectivity.
The City of Austin's own efforts to create a alternative municipal network for universal access were stalled when the providers lobbied for a state law prohibiting municipalities from competing in the broadband space.
Austin's residents are leaders in technology and the arts. Our city is well positioned to develop and use, and contribute to Google's Fiber for Communities project, and we look forward to working with Google on the future of the Internet.
Trying to get basic CAN Transmission working on a PIC24HJ64GP504. There are a couple of app note examples, but all of them are complex and none seem to cover using CAN with PPS. I tried them anyway, and no success. In an attempt to make the simplest example possible I cut and pasted the code examples from the Family Guide into this application.
Speed is 500kbit with a 16mhz crystal and no PLL. I have a CANUSB adapter and an older 18F2580 based product on the bus. I can see frames from the 18F, but frames from the 24HJ just retransmit over and over until the EC reaches 128 and cause bus errors on the CANUSB. I don't have a bus analyzer, but on the scope the good frames look similar to the bad ones, so I think the timing is in the ballpark. Is there a way to tell which of the five CAN errors it is experiencing? Did I do my speed calculations correct?
#include <p24hxxxx.h>
_FBS( RBS_NO_RAM & BSS_NO_FLASH & BWRP_WRPROTECT_OFF );
_FSS( RSS_NO_RAM & SSS_NO_FLASH & SWRP_WRPROTECT_OFF );
_FGS( GSS_OFF & GCP_OFF & GWRP_OFF );
_FOSCSEL( FNOSC_PRI & IESO_OFF );
_FOSC( FCKSM_CSDCMD & IOL1WAY_OFF & OSCIOFNC_OFF & POSCMD_HS );
_FWDT( FWDTEN_OFF );
unsigned int ecan1MsgBuf[32][8] __attribute__(( space(dma)) );
int main(void) {
AD1PCFGL = 0xFFFF;
__builtin_write_OSCCONL(OSCCON & 0xbf);
_C1RXR = 9; // RX = RP9
_RP22R = 0b10000; // TX = RP22
__builtin_write_OSCCONL(OSCCON | 0x40);
/* Assign 32x8word Message Buffers for ECAN1 in DMA RAM */
DMA0STA = __builtin_dmaoffset(ecan1MsgBuf);
/* Data Transfer Size: Word Transfer Mode */
DMA0CONbits.SIZE = 0x0;
/* Data Transfer Direction: DMA RAM to Peripheral */
DMA0CONbits.DIR = 0x1;
/* DMA Addressing Mode: Peripheral Indirect Addressing mode */
DMA0CONbits.AMODE = 0x2;
/* Operating Mode: Continuous, Ping-Pong modes disabled */
DMA0CONbits.MODE = 0x0;
/* Assign ECAN1 Transmit event for DMA Channel 0 */
DMA0REQ = 70;
/* Set Number of DMA Transfer per ECAN message to 8 words */
DMA0CNT = 7;
/* Peripheral Address: ECAN1dmaxcnt Transmit Register */
DMA0PAD = (volatile unsigned int)&C1TXD;
/* Start Address Offset for ECAN1 Message Buffer 0x0000 */
DMA0STA = 0x0000;
/* Channel Enable: Enable DMA Channel 0 */
DMA0CONbits.CHEN = 0x1;
/* Channel Interrupt Enable: Enable DMA Channel 0 Interrupt */
IEC0bits.DMA0IE = 1;
/* Set the ECAN module for Configuration Mode before writing into the Baud
Rate Control Registers*/
C1CTRL1bits.REQOP = 4;
/* Wait for the ECAN module to enter into Configuration Mode */
while(C1CTRL1bits.OPMODE != 4);
/* Phase Segment 1 time is 8 TQ */
C1CFG2bits.SEG1PH = 0x8;
/* Phase Segment 2 time is set to be programmable */
C1CFG2bits.SEG2PHTS = 0x1;
/* Phase Segment 2 time is 6 TQ */
C1CFG2bits.SEG2PH = 0x6;
/* Propagation Segment time is 1 TQ */
C1CFG2bits.PRSEG = 1;
/* Bus line is sampled three times at the sample point */
C1CFG2bits.SAM = 0x1;
/* Synchronization Jump Width set to 1 TQ */
C1CFG1bits.SJW = 1;
/* Baud Rate Prescaler bits set to 1:1 */
C1CFG1bits.BRP = 0x0 ;
/* Put the ECAN Module into Normal Mode Operating Mode*/
C1CTRL1bits.REQOP = 0;
/* Wait for the ECAN module to enter into Normal Operating Mode */
while(C1CTRL1bits.OPMODE != 0);
/* Configure Message Buffer 0 for Transmission and assign priority*/
C1TR01CONbits.TXEN0 = 0x1;
C1TR01CONbits.TX0PRI = 0x3;
/* WRITE TO MESSAGE BUFFER 0 */
/* CiTRBnSID = 0bxxx1 0010 0011 1100
IDE = 0b0
SRR = 0b0
SID<10:0>= 0b100 1000 1111 */
ecan1MsgBuf[0][0] = 0x123C;
/* CiTRBnEID = 0bxxxx 0000 0000 0000
EID<17:6> = 0b0000 0000 0000 */
ecan1MsgBuf[0][1] = 0x0000;
/* CiTRBnDLC = 0b0000 0000 xxx0 1111
EID<17:6> = 0b000000
RTR = 0b0
RB1 = 0b0
RB0 = 0b0
DLC = 0b1000 */
ecan1MsgBuf[0][2] = 0x8;
/* WRITE MESSAGE DATA BYTES */
ecan1MsgBuf[0][3] = 0xabcd;
ecan1MsgBuf[0][4] = 0xabcd;
ecan1MsgBuf[0][5] = 0xabcd;
ecan1MsgBuf[0][6] = 0xabcd;
/* REQUEST MESSAGE BUFFER 0 TRANSMISSION */
C1TR01CONbits.TXREQ0 = 0x1;
while (C1TR01CONbits.TXREQ0);
while(1);
return 0;
}
void __attribute__((interrupt, no_auto_psv)) _DMA0Interrupt(void)
{
IFS0bits.DMA0IF = 0; // Clear the DMA0 Interrupt Flag;
}
]]>
2010-01-09 11:15:50,935 ERROR [org.mindbent.audit-test] (ajp-0.0.0.0-8009-12) error performing auditThe error above is useless.
javax.ejb.EJBException: javax.persistence.PersistenceException: org.hibernate.exception.SQLGrammarException: could not get next sequence value
//Seiko RTC chip uses an annoying packing system where the LSB
// of the BCD represented data is in the MSB of the value
// that has to be written to the register. This function
// does the bitwise flip of each nybble using a lookup, and
// swaps the two nybbles.
unsigned char RTC_ConvertRBCD( unsigned char value ) {
const unsigned char tobcd[] = { 0x0, 0x8, 0x4, 0xC,
0x2, 0xA, 0x6, 0xE, 0x1, 0x9, 0x5, 0xD, 0x3, 0xB,
0x7, 0xF };
return (tobcd[value & 0x0F] << 4 ) + tobcd[value >> 4];
}
//Input is a 8bit number, returns the BCD encoded, bit reversed
// value needed by the Seiko RTC chip registers
unsigned char RTC_ToRTCBCD( unsigned char value ) {
return RTC_ConvertRBCD( ( ( value / 10) << 4) + ( value % 10 ) );
//return RTC_ConvertRBCD( ( ( value / 10) << 4) + ( value & 0x0F) );
}
//Input is a bit reversed packed BCD register value from
// the Seiko RTC chip, return is a normal 8bit value
unsigned char RTC_FromRTCBCD( unsigned char bcdvalue ) {
unsigned char unpacked = RTC_ConvertRBCD( bcdvalue );
return ( ( unpacked >> 4 ) * 10) + ( unpacked & 0x0F );
}
It works seamlessly with any hardware and operating system combination supporting USB keyboards such as Windows, MacOS, Linux and others. The Key generates and sends unique time-variant authentication codes by emulating keystrokes through the standard keyboard interface. The computer to which the Key is attached receives this authentication code character by character just as if it were being typed in from the keyboard - yet it's all performed automatically. This process allows the Key to be used with any application or Web-based service without any need for special client computer interaction or drivers.Link
The YubiKey differs from traditional authentication tokens based on time-variant codes in that it needs no battery and therefore does not rely on an absolute time generated by an accurate time source. No battery means unlimited shelf life, no synchronization and customer support issues, and enables significant cost reduction.
#!/bin/bash
PATCH0=$SOURCES/jboss-4.2.3.GA.base.patch
PATCH1=$SOURCES/log4j-setup-append.patch
PATCH2=$SOURCES/jboss-set-call-by-value.patch
PATCH3=$SOURCES/add-security-policy-login.patch
MAXPATCHES=100 #The script searches for PATCH{value}= lines from zero to this number
echo "Applying patches"
i=0
while [ $i -lt $MAXPATCHES ] ; do
PATCH=$(eval echo $echo PATCH${i});
if [ ! "$PATCH" == "" ] ; then
echo "Applying patch: $PATCH"
patch -p0 < $PATCH
fi
i=$[$i+1]
done;
In the end it might have been simpler to use a datafile, or a language with Array support, but this works well enough and is fairly usable.
Because of the confiscation of computers at Core IP Networks, a number of legitimate businesses have been affected.Link
From the downtown office building in the 2300 block of Bryan Street, FBI agents seized what one source described as millions of dollars in computer equipment.
Matthew Simpson, the owner of Core IP Networks, said in a letter posted online that FBI agents raided two floors and 'pulled the plug' on his clients' web servers starting at 6 o'clock Thursday morning. Agents also raided Simpson's house in Ovilla.