int fzip()
{
unsigned char * b, p;
int i;
do
{
b=read_byte(F_SRC);
//printf("%d\n",(int)(*b));
if (b!=NULL)
{
for (i=0;i<tree_map[*b].l;i++)
{
p=get_bit(tree_map[*b].code,i/8,i%8);
if (p)
write_bit(F_DST,1);
else
write_bit(F_DST,0);
}
}
}while(b!=NULL);
for (i=0;i<tree_map[256].l;i++)
{
p=get_bit(tree_map[256].code,i/8,i%8);
if (p)
write_bit(F_DST,1);
else
write_bit(F_DST,0);
}
return 0;
}
/**
* Generates a write-0 or write-1 cycle.
* Only call if dev->bus_master->touch_bit is NULL
*/
static void w1_gpio_write_bit(void *data, u8 bit)
{
struct w1_gpio_msm_platform_data *pdata = data;
void (*write_bit)(void *, u8);
unsigned long irq_flags;
if (pdata->is_open_drain) {
write_bit = w1_gpio_write_bit_val;
} else {
write_bit = w1_gpio_write_bit_dir;
}
spin_lock_irqsave(&w1_gpio_msm_lock, irq_flags);
if (bit) {
write_bit(data, 0);
write_bit(data, 1);
(pdata->slave_speed == 0)? w1_delay(64) : w1_delay(10);
} else {
write_bit(data, 0);
#ifdef CONFIG_W1_SLAVE_DS28E15 /* delay time for DS28EL15 */
(pdata->slave_speed == 0)? w1_delay(60) : w1_delay(8);
#else /* delay time for DS28EL35 */
(pdata->slave_speed == 0)? w1_delay(60) : w1_delay(9);
#endif
write_bit(data, 1);
(pdata->slave_speed == 0)? w1_delay(10) : w1_delay(10);
}
spin_unlock_irqrestore(&w1_gpio_msm_lock, irq_flags);
}
void transmit(int gpio, unsigned int address, unsigned char receiver,
unsigned char command) {
unsigned int mask;
sync_transmit(gpio);
for (mask = 0x2000000; mask != 0x0; mask >>= 1) {
if (address & mask) {
write_bit(gpio, 1);
} else {
write_bit(gpio, 0);
}
}
// never grouped
write_bit(gpio, 0);
write_bit(gpio, command);
for (mask = 0b1000; mask != 0x0; mask >>= 1) {
write_bit(gpio, receiver & mask);
}
write_interval_gap(gpio);
}
/**
* Generates a write-0 or write-1 cycle.
* Only call if dev->bus_master->touch_bit is NULL
*/
static void w1_gpio_write_bit(void *data, u8 bit)
{
struct w1_gpio_msm_platform_data *pdata = data;
void (*write_bit)(void *, u8);
unsigned long irq_flags;
if (pdata->is_open_drain) {
write_bit = w1_gpio_write_bit_val;
} else {
write_bit = w1_gpio_write_bit_dir;
}
spin_lock_irqsave(&w1_gpio_msm_lock, irq_flags);
if (bit) {
write_bit(data, 0);
write_bit(data, 1);
(pdata->slave_speed == 0)? w1_delay(64) : w1_delay(10);
} else {
write_bit(data, 0);
(pdata->slave_speed == 0)? w1_delay(60) : w1_delay(8);
write_bit(data, 1);
(pdata->slave_speed == 0)? w1_delay(10) : w1_delay(5);
}
spin_unlock_irqrestore(&w1_gpio_msm_lock, irq_flags);
}
/**
* Generates a write-1 cycle and samples the level.
* Only call if dev->bus_master->touch_bit is NULL
*/
static u8 w1_gpio_read_bit(void *data)
{
struct w1_gpio_msm_platform_data *pdata = data;
int result;
void (*write_bit)(void *, u8);
unsigned long irq_flags;
if (pdata->is_open_drain) {
write_bit = w1_gpio_write_bit_val;
} else {
write_bit = w1_gpio_write_bit_dir;
}
spin_lock_irqsave(&w1_gpio_msm_lock, irq_flags);
/* sample timing is critical here */
write_bit(data, 0);
write_bit(data, 1);
result = w1_gpio_read_bit_val(data);
(pdata->slave_speed == 0)? w1_delay(55) : w1_delay(8);
spin_unlock_irqrestore(&w1_gpio_msm_lock, irq_flags);
return result & 0x1;
}
/**
* Generates a write-0 or write-1 cycle.
* Only call if dev->bus_master->touch_bit is NULL
*/
static void w1_gpio_write_bit_in8(void *data, u8 bit)
{
struct w1_gpio_msm_platform_data *pdata = data;
void (*write_bit)(void *, u8);
if (pdata->is_open_drain) {
write_bit = w1_gpio_write_bit_val;
} else {
write_bit = w1_gpio_write_bit_dir;
}
if (bit) {
write_bit(data, 0);
write_bit(data, 1);
(pdata->slave_speed == 0)? w1_delay(64) : w1_delay(10);
} else {
write_bit(data, 0);
#ifdef CONFIG_W1_SLAVE_DS28E15 /* delay time for DS28EL15 */
(pdata->slave_speed == 0)? w1_delay(60) : w1_delay(8);
#else /* delay time for DS28EL35 */
(pdata->slave_speed == 0)? w1_delay(60) : w1_delay(9);
#endif
write_bit(data, 1);
(pdata->slave_speed == 0)? w1_delay(10) : w1_delay(10);
}
}
// write encoded value to stream
void write_length( int value )
{
unsigned int mask = 32768;
++value;
// find highest bit set
while ( !( value & mask ) )
mask >>= 1;
while( true )
{
// if mask equals 1, last bit has been written
if ( mask == 1 )
{
write_bit( 0 );
return;
}
mask >>= 1;
// more data
write_bit(1);
// write data bit
write_bit( value & mask );
}
}
//功能 : 写串口数据
void write_data(uchar data)
{
CS;
write_bit(0xfa);//写数据
write_bit(data & 0xf0);//写高4位
write_bit((data<<4) & 0xf0);//写低4位
_delay_ms(2);
}
//功能 : 写串口指令
void write_command(uchar command)
{
CS;
write_bit(0xf8);//串口格式，写控制指令
write_bit(command & 0xf0);//写高4位
write_bit((command<<4) & 0xf0);//写低4位
_delay_ms(2);
}
unsigned char *compress(Optimal *optimal, unsigned char *input_data, size_t input_size, size_t *output_size) {
size_t input_index;
size_t input_prev;
int offset1;
int mask;
int i;
/* calculate and allocate output buffer */
input_index= input_size-1;
*output_size= (optimal[input_index].bits+16+7)/8;
output_data= (unsigned char *)malloc(*output_size);
if( !output_data )
fprintf(stderr, "Error: Insufficient memory\n"),
exit(1);
/* un-reverse optimal sequence */
optimal[input_index].bits= 0;
while ( input_index > 0 )
input_prev= input_index - (optimal[input_index].len > 0 ? optimal[input_index].len : 1),
optimal[input_prev].bits= input_index,
input_index= input_prev;
output_index= 0;
bit_mask= 0;
/* first byte is always literal */
write_byte(input_data[0]);
/* process remaining bytes */
while ( (input_index= optimal[input_index].bits) > 0)
if( optimal[input_index].len == 0)
write_bit(0),
write_byte(input_data[input_index]);
else{
/* sequence indicator */
write_bit(1);
/* sequence length */
write_elias_gamma(optimal[input_index].len-1);
/* sequence offset */
offset1= optimal[input_index].offset-1;
if( offset1 < 128 )
write_byte(offset1);
else{
offset1-= 128;
write_byte((offset1 & 127) | 128);
for ( mask= 1024; mask > 127; mask >>= 1)
write_bit(offset1 & mask);
}
}
/* end mark */
write_bit(1);
write_elias_gamma(0xff);
return output_data;
}
void write_compression(unsigned char sigbits[255], unsigned long bitencodings[255], FILE * fphuff, FILE * fporig)
{//write the huffman compression to the output file
//compression variables
int readchar;
int numsignificant;
unsigned long encoding;
//1000 0000 0000 0000 0000 0000 0000 0000
unsigned long mask = 0x80000000;
bitspot = 0;
currentbyte = 0;
//write file
while (!feof(fporig))
{//read every character in the file until the EOF is found
readchar = fgetc(fporig);
if (readchar != EOF) //keeps the standard EOF file from being written, we must write our own pseudo EOF
{//save encoding, save amount of digits, shift the most significant bit to the far left
encoding = bitencodings[(int) readchar];
numsignificant = sigbits[(int) readchar];
encoding <<= (32 - numsignificant);
while (numsignificant > 0)
{//loop until we have used all of the significant bits in our encoding
if ((mask & encoding) == mask)
{//if the furthest left bit is 1, pack a 1
write_bit(fphuff, 1);
} else
{//if the furthest left bit is 0, pack a 0
write_bit(fphuff, 0);
}
//set up the next bit to write, decrement the number of bits still to write
encoding <<= 1;
--numsignificant;
}
}
}
//write the pseudo EOF character, using ASCII NULL = 0000 0000
encoding = bitencodings[0];
numsignificant = sigbits[0];
encoding <<= (32 - numsignificant);
//same as above, except dedicated to writing pseudo EOF
while (numsignificant > 0)
{
if ((mask & encoding) == mask)
{
write_bit(fphuff, 1);
} else
{
write_bit(fphuff, 0);
}
encoding <<= 1;
--numsignificant;
}
//finish off the byte with 0's and write it
pad_file(fphuff);
return;
}
/**
* Transfer bits over SPI bit-bashing bus
*
* @v bus SPI bus
* @v data_out TX data buffer (or NULL)
* @v data_in RX data buffer (or NULL)
* @v len Length of transfer (in @b bits)
* @v endianness Endianness of this data transfer
*
* This issues @c len clock cycles on the SPI bus, shifting out data
* from the @c data_out buffer to the MOSI line and shifting in data
* from the MISO line to the @c data_in buffer. If @c data_out is
* NULL, then the data sent will be all zeroes. If @c data_in is
* NULL, then the incoming data will be discarded.
*/
static void spi_bit_transfer ( struct spi_bit_basher *spibit,
const void *data_out, void *data_in,
unsigned int len, int endianness ) {
struct spi_bus *bus = &spibit->bus;
struct bit_basher *basher = &spibit->basher;
unsigned int sclk = ( ( bus->mode & SPI_MODE_CPOL ) ? 1 : 0 );
unsigned int cpha = ( ( bus->mode & SPI_MODE_CPHA ) ? 1 : 0 );
unsigned int bit_offset;
unsigned int byte_offset;
unsigned int byte_mask;
unsigned int bit;
unsigned int step;
DBGC2 ( spibit, "SPIBIT %p transferring %d bits in mode %#x\n",
spibit, len, bus->mode );
for ( step = 0 ; step < ( len * 2 ) ; step++ ) {
/* Calculate byte offset and byte mask */
bit_offset = ( ( endianness == SPI_BIT_BIG_ENDIAN ) ?
( len - ( step / 2 ) - 1 ) : ( step / 2 ) );
byte_offset = ( bit_offset / 8 );
byte_mask = ( 1 << ( bit_offset % 8 ) );
/* Shift data in or out */
if ( sclk == cpha ) {
const uint8_t *byte;
/* Shift data out */
if ( data_out ) {
byte = ( data_out + byte_offset );
bit = ( *byte & byte_mask );
DBGCP ( spibit, "SPIBIT %p wrote bit %d\n",
spibit, ( bit ? 1 : 0 ) );
} else {
bit = 0;
}
write_bit ( basher, SPI_BIT_MOSI, bit );
} else {
uint8_t *byte;
/* Shift data in */
bit = read_bit ( basher, SPI_BIT_MISO );
if ( data_in ) {
DBGCP ( spibit, "SPIBIT %p read bit %d\n",
spibit, ( bit ? 1 : 0 ) );
byte = ( data_in + byte_offset );
*byte &= ~byte_mask;
*byte |= ( bit & byte_mask );
}
}
/* Toggle clock line */
spi_bit_delay();
sclk ^= 1;
write_bit ( basher, SPI_BIT_SCLK, sclk );
}
}
void write_chunk_fd_file(void *fptr, struct cp_file *file)
{
int have_contents = !!(file->contents);
write_string(fptr, file->filename);
write_bit(fptr, &file->deleted, sizeof(int));
write_bit(fptr, &file->size, sizeof(int));
write_bit(fptr, &have_contents, sizeof(int));
if (file->contents)
write_bit(fptr, file->contents, file->size);
}
/**
* Issues a reset bus sequence.
*
* @param dev The bus master pointer
* @return 0=Device present, 1=No device present or error
*/
static u8 w1_gpio_reset_bus(void *data)
{
int result=1, i;
struct w1_gpio_msm_platform_data *pdata = data;
void (*write_bit)(void *, u8);
unsigned long irq_flags;
int temp_read[MAX_SAMPLE]={'1',};
int loop_cnt = 3;
if (pdata->is_open_drain) {
write_bit = w1_gpio_write_bit_val;
} else {
write_bit = w1_gpio_write_bit_dir;
}
spin_lock_irqsave(&w1_gpio_msm_lock, irq_flags);
while (loop_cnt > 0) {
write_bit(data, 0);
/* minimum 48, max 80 us(In DS Documnet)
* be nice and sleep, except 18b20 spec lists 960us maximum,
* so until we can sleep with microsecond accuracy, spin.
* Feel free to come up with some other way to give up the
* cpu for such a short amount of time AND get it back in
* the maximum amount of time.
*/
(pdata->slave_speed == 0)? __const_udelay(500*UDELAY_MULT) : __const_udelay(50*UDELAY_MULT);
write_bit(data, 1);
(pdata->slave_speed == 0)? __const_udelay(60*UDELAY_MULT) : __const_udelay(1*UDELAY_MULT);
for(i=0;i<MAX_SAMPLE;i++)
temp_read[i] = gpio_get_value_msm(pdata->pin);
for(i=0;i<MAX_SAMPLE;i++)
result &= temp_read[i];
/* minmum 70 (above) + 410 = 480 us
* There aren't any timing requirements between a reset and
* the following transactions. Sleeping is safe here.
*/
/* w1_delay(410); min required time */
(pdata->slave_speed == 0)? msleep(1) : __const_udelay(40*UDELAY_MULT);
if (result)
loop_cnt--;
else
break;
}
spin_unlock_irqrestore(&w1_gpio_msm_lock, irq_flags);
return result;
}
void oled_reset(void)
{
// repeat 2 times
write_bit(RES_n, 0); //clr(CTRL, RES_n); //RES_n = 0;
oled_delay(DELAY_CAL2);
write_bit(RES_n, 1); //set(CTRL, RES_n); //RES_n = 1;
oled_delay(DELAY_CAL2);
write_bit(RES_n, 0); //clr(CTRL, RES_n); //RES_n = 0;
oled_delay(DELAY_CAL2);
write_bit(RES_n, 1); //set(CTRL, RES_n); //RES_n = 1;
oled_delay(DELAY_CAL2);
}
void write_elias_gamma(int value) {
int bits= 0, rvalue= 0;
while ( value>1 )
++bits,
rvalue<<= 1,
rvalue|= value&1,
value>>= 1;
while ( bits-- )
write_bit(0),
write_bit(rvalue & 1),
rvalue>>= 1;
write_bit(1);
}
// FIXME: parity
void tape::write(uint8_t b) {
#if defined(PWM_DUTY)
pwm.set_duty(PWM_DUTY);
#endif
write_bit(0);
for (int i = 0; i < _data_bits; i++) {
write_bit(b & 1);
b >>= 1;
}
write_bit(1);
if (_stop_bits == 2)
write_bit(1);
pwm.set_duty(0);
}
void oled_write_cmd(unsigned char command)
{
write_bit(CS_n, 0); //clr(CTRL, CS_n); //CS_n =0;
oled_delay(DELAY_CAL);
write_bit(DC_n, 0); //clr(CTRL, DC_n); //DC_n =0;
oled_delay(DELAY_CAL);
unsigned char i;
for(i = 0; i<8; i++)
{
unsigned char tmp;
write_bit(SCLK, 0); //clr(DATA, SCLK); // low
oled_delay(DELAY_CAL);
tmp = check(command, (7-i));
if(tmp != 0)
{
write_bit(SDIN, 1); //set(DATA, SDIN); // data
oled_delay(DELAY_CAL);
write_bit(SCLK, 1); //set(DATA, SCLK); // hi
oled_delay(DELAY_CAL);
}
if(tmp == 0)
{
write_bit(SDIN, 0); //clr(DATA, SDIN); // data
oled_delay(DELAY_CAL);
write_bit(SCLK, 1); //set(DATA, SCLK); // hi
oled_delay(DELAY_CAL);
}
}
oled_delay(DELAY_CAL);
write_bit(SCLK, 0); //set(CTRL, CS_n); //CS_n=1;
}
// Write path in reverse to ouput
// root -> point
static void write_path_inverse() {
// Index
int i;
// Write each direction as a bit
for (i = path_size - 1 ; i >= 0 ; --i) {
if (path[i] == 0) {
// Left direction
write_bit(0);
} else {
// Right direction
write_bit(1);
}
}
}
int i2c_bitbang_read_byte (struct i2c *base, u8 devaddr, u8 regoffset, u8 * value)
{
// printf("i2c-bb read dev=%02x regoffset=%02x ", devaddr, regoffset);
start(base);
if (write_byte(base, (devaddr<<1))) { // send chip address for write command
if (write_byte(base, regoffset)) { // send register offset - this defines where we want to read
start(base); // repeated start
if (write_byte(base, (devaddr<<1) | 1)) { // send chip address for read command
*value = read_byte(base);
// printf("%02x\n", *value);
write_bit(base, 1); // NAK
stop(base); // send stop condition
return 0; // ok
}
else {
// printf(" 2nd chip address error ");
}
}
else {
// printf(" offset error ");
}
}
else {
// printf(" chip address error ");
}
stop(base); // send stop condition
return 1; // fail
}
/********************************************************************
* write_byte
* Writes one byte to the COM
*
* Inputs: serdevice - opened file handle
* byte - byte to write
*
* Returns: nothing
*
********************************************************************/
int write_byte(WEATHERSTATION ws, int byte) {
int status;
int i;
char str[20];
sprintf(str,"Writing byte %i",byte);
print_log(3,str);
for (i = 0; i < 8; i++)
{
write_bit(ws, byte & 0x80);
byte <<= 1;
byte &= 0xff;
}
set_RTS(ws,0);
nanodelay();
status = get_CTS(ws);
//TODO: checking value of status, error routine
nanodelay();
set_DTR(ws,0);
nanodelay();
set_DTR(ws,1);
nanodelay();
if (status)
return 1;
else
return 0;
}
void compucolor_floppy_device::tx(UINT8 state)
{
if (!m_sel && m_rw)
{
write_bit(state);
}
}
/**
* Write one byte.
* @param value Value to write.
* @param verify Whether the write has to be verified (default: true).
* @return Whether the write was successful.
*/
bool SerialInterface::write_byte(byte value, bool verify)
{
//clog(trace) << "Send byte 0x" << std::hex << value << std::endl;
for (size_t i = 0; i < 8; i++)
{
write_bit((value & 0x80) > 0);
value <<= 1;
}
set_RTS(false);
nanodelay();
bool status = true;
if (verify)
{
status = get_CTS();
//TODO: checking value of status, error routine
// TODO: exceptions?
nanodelay();
set_DTR(false);
nanodelay();
set_DTR(true);
nanodelay();
}
return status;
}
static void test_serialization_2(void)
{
byte serialized[2] = {0};
byte const expected[2] =
{
0xfe,
0x05
};
bit_writer writer = {&serialized[0], 1};
writer = write_byte(writer, 0xff);
writer = write_bit(writer, 0);
writer = write_bit(writer, 1);
TEST(writer.current_byte == &serialized[1]);
TEST(writer.used_bits_in_byte == 3);
TEST(memcmp(expected, serialized, sizeof(expected)) == 0);
}
static int write_byte(struct i2c *base, int byte)
{
int i;
for (i=7; i>=0; i--)
write_bit(base, (byte & (1<<i)) != 0);
return read_bit(base) == 0; // ok (1) if NACK is asserted
}
void pad_file(FILE * fphuff)
{//pad the remaining bits with 0's until the byte is written
while (bitspot != 0)
{
write_bit(fphuff, 0);
}
return;
}
void write_header(Node * root, FILE * fphuff)
{//write the header information recursively as a post-order tree traversal
if (root != NULL)
{
if ((root -> left == NULL) && (root -> right == NULL))
{//found a leaf node, header should always start with 1
write_bit(fphuff, 1);
write_bit_char(fphuff, root -> data);
return;
}
}
//post-order traversal of tree
write_header(root -> left, fphuff);
write_header(root -> right, fphuff);
write_bit(fphuff, 0);
return;
}
void oled_init(void)
{
oled_write_cmd(0x81); // contrast
oled_write_cmd(0x00); // 0..0xFF
oled_write_cmd(0xAF); // OLED on
write_bit(1, 1);
}
unsigned i2c_write(uint8_t x)
{
int i;
for(i = 0; i < 8; i++) {
write_bit(x&0x80);
x <<= 1;
}
return read_bit();
}
void write_byte(uint8_t value)
{
uint8_t i;
for(i = 0; i < 8; i++)
{
write_bit(value & 0x01);
value >>= 1; /* Shift to get ready for next bit */
_delay_us(10); /* Give interrupt a chance to happen*/
}
}
