Ejemplos de writebits en C++ (Cpp)

Ejemplo n.º 1

Archivo: ft232testapp0.cpp Proyecto: BusPirate/Bus_Pirate

int _tmain(int argc, _TCHAR* argv[])
{
			
	get_info();
	//configure CBUS for bitbang mode
	
	printf("Setting cbus1 to I/O mode..\n");
	
	setCBUSbits(0x0A);  // will use only cbus1 rxled, 0x0A set to Bitbang I/O mode
	
	FT_SetBitMode(ftHandle,0,0);  // try resetting

	//Still having trouble  response is always FAILED
	
	for (int x=0;x<10;x++)   //blink rxlex 10x
	{
		writebits( 0x22);  //  0010 0010 
		//Sleep(1000);
		readBits();
		writebits( 0x20);  // 0010 0000 
		//Sleep(1000);
		readBits();
	}
	printf("Restoring Cbus1....\n");
	setCBUSbits(old_cbus1_state); // restore it back
	printf("Press any key to exit.... \n");
	while(!_kbhit());

	return 0;
}

Ejemplo n.º 2

Archivo: dico.c Proyecto: invicnaper/Lar

void write(lzw_t *ctx, lzw_u code)
{
	// increase the code size (number of bits) if needed
	if (ctx->max == (1 << ctx->codesize))
		ctx->codesize++;

	writebits(ctx, code, ctx->codesize);
}

Ejemplo n.º 3

Archivo: sdram.c Proyecto: RafaelRMachado/Coreboot

/* PMC must be configured before clock-enable and de-reset of MC/EMC. */
static void sdram_configure_pmc(const struct sdram_params *param,
				struct tegra_pmc_regs *regs)
{
	/* VDDP Select */
	write32(&regs->vddp_sel, param->PmcVddpSel);
	udelay(param->PmcVddpSelWait);

	/* Set DDR pad voltage */
	writebits(param->PmcDdrPwr, &regs->ddr_pwr, PMC_DDR_PWR_VAL_MASK);

	/* Set package and DPD pad control */
	writebits(param->PmcDdrCfg, &regs->ddr_cfg,
		  (PMC_DDR_CFG_PKG_MASK | PMC_DDR_CFG_IF_MASK |
		   PMC_DDR_CFG_XM0_RESET_TRI_MASK |
		   PMC_DDR_CFG_XM0_RESET_DPDIO_MASK));

	/* Turn on MEM IO Power */
	writebits(param->PmcNoIoPower, &regs->no_iopower,
		  (PMC_NO_IOPOWER_MEM_MASK | PMC_NO_IOPOWER_MEM_COMP_MASK));

	write32(&regs->reg_short, param->PmcRegShort);
}

Ejemplo n.º 4

Archivo: sdram.c Proyecto: RafaelRMachado/Coreboot

static void sdram_set_emc_timing(const struct sdram_params *param,
				 struct tegra_emc_regs *regs)
{
	/* Program EMC timing configuration */
	write32(&regs->cfg_2, param->EmcCfg2);
	write32(&regs->cfg_pipe, param->EmcCfgPipe);
	write32(&regs->dbg, param->EmcDbg);
	write32(&regs->cmdq, param->EmcCmdQ);
	write32(&regs->mc2emcq, param->EmcMc2EmcQ);
	write32(&regs->mrs_wait_cnt, param->EmcMrsWaitCnt);
	write32(&regs->mrs_wait_cnt2, param->EmcMrsWaitCnt2);
	write32(&regs->fbio_cfg5, param->EmcFbioCfg5);
	write32(&regs->rc, param->EmcRc);
	write32(&regs->rfc, param->EmcRfc);
	write32(&regs->rfc_slr, param->EmcRfcSlr);
	write32(&regs->ras, param->EmcRas);
	write32(&regs->rp, param->EmcRp);
	write32(&regs->r2r, param->EmcR2r);
	write32(&regs->w2w, param->EmcW2w);
	write32(&regs->r2w, param->EmcR2w);
	write32(&regs->w2r, param->EmcW2r);
	write32(&regs->r2p, param->EmcR2p);
	write32(&regs->w2p, param->EmcW2p);
	write32(&regs->rd_rcd, param->EmcRdRcd);
	write32(&regs->wr_rcd, param->EmcWrRcd);
	write32(&regs->rrd, param->EmcRrd);
	write32(&regs->rext, param->EmcRext);
	write32(&regs->wext, param->EmcWext);
	write32(&regs->wdv, param->EmcWdv);
	write32(&regs->wdv_mask, param->EmcWdvMask);
	write32(&regs->quse, param->EmcQUse);
	write32(&regs->quse_width, param->EmcQuseWidth);
	write32(&regs->ibdly, param->EmcIbdly);
	write32(&regs->einput, param->EmcEInput);
	write32(&regs->einput_duration, param->EmcEInputDuration);
	write32(&regs->puterm_extra, param->EmcPutermExtra);
	write32(&regs->puterm_width, param->EmcPutermWidth);
	write32(&regs->puterm_adj, param->EmcPutermAdj);
	write32(&regs->cdb_cntl_1, param->EmcCdbCntl1);
	write32(&regs->cdb_cntl_2, param->EmcCdbCntl2);
	write32(&regs->cdb_cntl_3, param->EmcCdbCntl3);
	write32(&regs->qrst, param->EmcQRst);
	write32(&regs->qsafe, param->EmcQSafe);
	write32(&regs->rdv, param->EmcRdv);
	write32(&regs->rdv_mask, param->EmcRdvMask);
	write32(&regs->qpop, param->EmcQpop);
	write32(&regs->ctt, param->EmcCtt);
	write32(&regs->ctt_duration, param->EmcCttDuration);
	write32(&regs->refresh, param->EmcRefresh);
	write32(&regs->burst_refresh_num, param->EmcBurstRefreshNum);
	write32(&regs->pre_refresh_req_cnt, param->EmcPreRefreshReqCnt);
	write32(&regs->pdex2wr, param->EmcPdEx2Wr);
	write32(&regs->pdex2rd, param->EmcPdEx2Rd);
	write32(&regs->pchg2pden, param->EmcPChg2Pden);
	write32(&regs->act2pden, param->EmcAct2Pden);
	write32(&regs->ar2pden, param->EmcAr2Pden);
	write32(&regs->rw2pden, param->EmcRw2Pden);
	write32(&regs->txsr, param->EmcTxsr);
	write32(&regs->txsrdll, param->EmcTxsrDll);
	write32(&regs->tcke, param->EmcTcke);
	write32(&regs->tckesr, param->EmcTckesr);
	write32(&regs->tpd, param->EmcTpd);
	write32(&regs->tfaw, param->EmcTfaw);
	write32(&regs->trpab, param->EmcTrpab);
	write32(&regs->tclkstable, param->EmcTClkStable);
	write32(&regs->tclkstop, param->EmcTClkStop);
	write32(&regs->trefbw, param->EmcTRefBw);
	write32(&regs->odt_write, param->EmcOdtWrite);
	write32(&regs->odt_read, param->EmcOdtRead);
	write32(&regs->fbio_cfg6, param->EmcFbioCfg6);
	write32(&regs->cfg_dig_dll, param->EmcCfgDigDll);
	write32(&regs->cfg_dig_dll_period, param->EmcCfgDigDllPeriod);

	/* Don't write bit 1: addr swizzle lock bit. Written at end of sequence. */
	write32(&regs->fbio_spare, param->EmcFbioSpare & 0xfffffffd);

	write32(&regs->cfg_rsv, param->EmcCfgRsv);
	write32(&regs->dll_xform_dqs0, param->EmcDllXformDqs0);
	write32(&regs->dll_xform_dqs1, param->EmcDllXformDqs1);
	write32(&regs->dll_xform_dqs2, param->EmcDllXformDqs2);
	write32(&regs->dll_xform_dqs3, param->EmcDllXformDqs3);
	write32(&regs->dll_xform_dqs4, param->EmcDllXformDqs4);
	write32(&regs->dll_xform_dqs5, param->EmcDllXformDqs5);
	write32(&regs->dll_xform_dqs6, param->EmcDllXformDqs6);
	write32(&regs->dll_xform_dqs7, param->EmcDllXformDqs7);
	write32(&regs->dll_xform_dqs8, param->EmcDllXformDqs8);
	write32(&regs->dll_xform_dqs9, param->EmcDllXformDqs9);
	write32(&regs->dll_xform_dqs10, param->EmcDllXformDqs10);
	write32(&regs->dll_xform_dqs11, param->EmcDllXformDqs11);
	write32(&regs->dll_xform_dqs12, param->EmcDllXformDqs12);
	write32(&regs->dll_xform_dqs13, param->EmcDllXformDqs13);
	write32(&regs->dll_xform_dqs14, param->EmcDllXformDqs14);
	write32(&regs->dll_xform_dqs15, param->EmcDllXformDqs15);
	write32(&regs->dll_xform_quse0, param->EmcDllXformQUse0);
	write32(&regs->dll_xform_quse1, param->EmcDllXformQUse1);
	write32(&regs->dll_xform_quse2, param->EmcDllXformQUse2);
	write32(&regs->dll_xform_quse3, param->EmcDllXformQUse3);
	write32(&regs->dll_xform_quse4, param->EmcDllXformQUse4);
	write32(&regs->dll_xform_quse5, param->EmcDllXformQUse5);
	write32(&regs->dll_xform_quse6, param->EmcDllXformQUse6);
	write32(&regs->dll_xform_quse7, param->EmcDllXformQUse7);
	write32(&regs->dll_xform_quse8, param->EmcDllXformQUse8);
	write32(&regs->dll_xform_quse9, param->EmcDllXformQUse9);
	write32(&regs->dll_xform_quse10, param->EmcDllXformQUse10);
	write32(&regs->dll_xform_quse11, param->EmcDllXformQUse11);
	write32(&regs->dll_xform_quse12, param->EmcDllXformQUse12);
	write32(&regs->dll_xform_quse13, param->EmcDllXformQUse13);
	write32(&regs->dll_xform_quse14, param->EmcDllXformQUse14);
	write32(&regs->dll_xform_quse15, param->EmcDllXformQUse15);
	write32(&regs->dll_xform_dq0, param->EmcDllXformDq0);
	write32(&regs->dll_xform_dq1, param->EmcDllXformDq1);
	write32(&regs->dll_xform_dq2, param->EmcDllXformDq2);
	write32(&regs->dll_xform_dq3, param->EmcDllXformDq3);
	write32(&regs->dll_xform_dq4, param->EmcDllXformDq4);
	write32(&regs->dll_xform_dq5, param->EmcDllXformDq5);
	write32(&regs->dll_xform_dq6, param->EmcDllXformDq6);
	write32(&regs->dll_xform_dq7, param->EmcDllXformDq7);
	write32(&regs->dll_xform_addr0, param->EmcDllXformAddr0);
	write32(&regs->dll_xform_addr1, param->EmcDllXformAddr1);
	write32(&regs->dll_xform_addr2, param->EmcDllXformAddr2);
	write32(&regs->dll_xform_addr3, param->EmcDllXformAddr3);
	write32(&regs->dll_xform_addr4, param->EmcDllXformAddr4);
	write32(&regs->dll_xform_addr5, param->EmcDllXformAddr5);
	write32(&regs->acpd_control, param->EmcAcpdControl);
	write32(&regs->dsr_vttgen_drv, param->EmcDsrVttgenDrv);
	write32(&regs->txdsrvttgen, param->EmcTxdsrvttgen);
	write32(&regs->bgbias_ctl0, param->EmcBgbiasCtl0);

	/*
	 * Set pipe bypass enable bits before sending any DRAM commands.
	 * Note other bits in EMC_CFG must be set AFTER REFCTRL is configured.
	 */
	writebits(param->EmcCfg, &regs->cfg,
		  (EMC_CFG_EMC2PMACRO_CFG_BYPASS_ADDRPIPE_MASK |
		   EMC_CFG_EMC2PMACRO_CFG_BYPASS_DATAPIPE1_MASK |
		   EMC_CFG_EMC2PMACRO_CFG_BYPASS_DATAPIPE2_MASK));
}

Ejemplo n.º 5

Archivo: bmp.c Proyecto: praetorian-inc/highlight

void bmp_write_image(char *filename, struct image_t *bmp) {
    unsigned int headers[13];
    FILE *outfile = NULL;
    unsigned width = bmp->bit_width;
    unsigned height = bmp->bit_height;
    unsigned int paddedsize;
    int n;
    unsigned r, g, b;
    uint8_t *compressed = NULL;
    unsigned compressed_len = 0;

    compressed = bmp_make_compressed(bmp, &compressed_len);
    assert(compressed);

    // Header + color table (RGB and Alpha)
    paddedsize = 54 + (256 * 4);

    headers[0]  = paddedsize + compressed_len;  // bfSize (whole file size)
    headers[1]  = 0;                            // bfReserved (both)
    headers[2]  = paddedsize;                   // bfOffbits
    headers[3]  = 40;                           // biSize
    headers[4]  = width;                        // biWidth
    headers[5]  = height;                       // biHeight
    headers[6]  = 0x00080001;                   // biPlanes and biBitCounts are fixed
    headers[7]  = 1;                            // biCompression -  8 bit RLE
    headers[8]  = compressed_len;               // biSizeImage
    headers[9]  = 0;                            // biXPelsPerMeter
    headers[10] = 0;                            // biYPelsPerMeter
    headers[11] = 256;                          // biClrUsed
    headers[12] = 256;                          // biClrImportant

    outfile = fopen(filename, "wb");

    //
    // Headers begin...
    // Write out 1 character at a time to avoid endian issues.
    //

    fprintf(outfile, "BM");

    for (n = 0; n < (sizeof(headers) / sizeof(headers[0])); n++) {
        fprintf(outfile, "%c", headers[n] & 0x000000FF);
        fprintf(outfile, "%c", (headers[n] & 0x0000FF00) >> 8);
        fprintf(outfile, "%c", (headers[n] & 0x00FF0000) >> 16);
        fprintf(outfile, "%c", (headers[n] & 0xFF000000) >> 24);
    }

    // Now do the color table
    for (n = 0; n < 256; n++) {
        color_to_rgb(n, &r, &g, &b);
        fprintf(outfile, "%c", b);
        fprintf(outfile, "%c", g);
        fprintf(outfile, "%c", r);
        fprintf(outfile, "%c", 0);
    }

    // And blather out the compressed table
    writebits(outfile, compressed, compressed_len);

    fclose(outfile);
    free(compressed);  compressed = NULL;
    return;
}

Ejemplo n.º 6

Archivo: ddsbase.cpp Proyecto: BillTheBest/Equalizer

// write a Differential Data Stream
void writeDDSfile(const char *filename,unsigned char *data,size_t bytes,unsigned int skip,unsigned int strip,int nofree)
   {
   int version=1;

   unsigned char *ptr1,*ptr2;

   int pre1,pre2,
       act1,act2,
       tmp1,tmp2;

   unsigned int cnt,cnt1,cnt2;
   int bits,bits1,bits2;

   if (bytes<1) ERRORMSG();

   if (bytes>DDS_INTERLEAVE) version=2;

   if (skip<1 || skip>4) skip=1;
   if (strip<1 || strip>65536) strip=1;

   if ((DDS_file=fopen(filename,"wb"))==NULL) ERRORMSG();

   fprintf(DDS_file,"%s",(version==1)?DDS_ID:DDS_ID2);

   deinterleave(data,bytes,skip,DDS_INTERLEAVE);

   initbuffer();

   writebits(DDS_file,skip-1,2);
   writebits(DDS_file,strip++-1,16);

   ptr1=ptr2=data;
   pre1=pre2=0;

   cnt=cnt1=cnt2=0;
   bits=bits1=bits2=0;

   while (cnt++<bytes)
      {
      tmp1=*ptr1++;
      if (cnt<=strip) act1=tmp1-pre1;
      else act1=tmp1-pre1-*(ptr1-strip)+*(ptr1-strip-1);
      pre1=tmp1;

      while (act1<-128) act1+=256;
      while (act1>127) act1-=256;

      if (act1<=0)
         for (bits=0; (1<<bits)/2<-act1; bits++) ;
      else
         for (bits=0; (1<<bits)/2<=act1; bits++) ;

      bits=DDS_decode(DDS_code(bits));

      if (cnt1==0)
         {
         cnt1++;
         bits1=bits;
         continue;
         }

      if (cnt1<(1<<DDS_RL)-1 && bits==bits1)
         {
         cnt1++;
         continue;
         }

      if (cnt1+cnt2<(1<<DDS_RL) && (cnt1+cnt2)*max(bits1,bits2)<cnt1*bits1+cnt2*bits2+DDS_RL+3)
         {
         cnt2+=cnt1;
         if (bits1>bits2) bits2=bits1;
         }
      else
         {
         writebits(DDS_file,cnt2,DDS_RL);
         writebits(DDS_file,DDS_code(bits2),3);

         while (cnt2-->0)
            {
            tmp2=*ptr2++;
            if (ptr2-strip<=data) act2=tmp2-pre2;
            else act2=tmp2-pre2-*(ptr2-strip)+*(ptr2-strip-1);
            pre2=tmp2;

            while (act2<-128) act2+=256;
            while (act2>127) act2-=256;

            writebits(DDS_file,act2+(1<<bits2)/2,bits2);
            }

         cnt2=cnt1;
         bits2=bits1;
         }

      cnt1=1;
      bits1=bits;
      }

   if (cnt1+cnt2<(1<<DDS_RL) && (cnt1+cnt2)*max(bits1,bits2)<cnt1*bits1+cnt2*bits2+DDS_RL+3)
      {
      cnt2+=cnt1;
      if (bits1>bits2) bits2=bits1;
      }
   else
      {
      writebits(DDS_file,cnt2,DDS_RL);
      writebits(DDS_file,DDS_code(bits2),3);

      while (cnt2-->0)
         {
         tmp2=*ptr2++;
         if (ptr2-strip<=data) act2=tmp2-pre2;
         else act2=tmp2-pre2-*(ptr2-strip)+*(ptr2-strip-1);
         pre2=tmp2;

         while (act2<-128) act2+=256;
         while (act2>127) act2-=256;

         writebits(DDS_file,act2+(1<<bits2)/2,bits2);
         }

      cnt2=cnt1;
      bits2=bits1;
      }

   if (cnt2!=0)
      {
      writebits(DDS_file,cnt2,DDS_RL);
      writebits(DDS_file,DDS_code(bits2),3);

      while (cnt2-->0)
         {
         tmp2=*ptr2++;
         if (ptr2-strip<=data) act2=tmp2-pre2;
         else act2=tmp2-pre2-*(ptr2-strip)+*(ptr2-strip-1);
         pre2=tmp2;

         while (act2<-128) act2+=256;
         while (act2>127) act2-=256;

         writebits(DDS_file,act2+(1<<bits2)/2,bits2);
         }
      }

   flushbits(DDS_file);
   fclose(DDS_file);

   if (nofree==0) free(data);
   else interleave(data,bytes,skip,DDS_INTERLEAVE);
   }

Ejemplo n.º 7

Archivo: LiquidCrystalDogC.cpp Proyecto: manfredjonsson/LiquidCrystalAddons

void LiquidCrystalDogC::begin(uint8_t cols, uint8_t rows, uint8_t mode) {
  uint8_t bias;

  _numcols = cols;
  _numrows = rows;

  if (rows > 1) {
    _displayfunction |= LCD_2LINE;
  } else {
    _displayfunction &= ~LCD_2LINE;
  }

  if (mode & LCD_DOG33V) {
    _dogpower = LCD_DOGBOOSTON;
    bias = LCD_DOGBIASLOW;
  } else {
    _dogpower = LCD_DOGBOOSTOFF;
    bias = LCD_DOGBIASHIGH;
  }

  // for some 1 line displays you can select a 10 pixel high font
  if ((mode & LCD_5x10DOTS) && (rows == 1)) {
    _displayfunction |= LCD_5x10DOTS;
  } else {
    _displayfunction &= ~LCD_5x10DOTS;
  }

  // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
  // according to datasheet, we need at least 40ms after power rises above 2.7V
  // before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
  delayMicroseconds(50000); 

  //we don't know which mode the LCD is in. maybe in the middle of a 4 bit mode transfer. force 8 bit mode.
  for(int i = 0; i < 3; i++) {
    // we start in 8bit mode, try to set 8 bit mode
    writebits(LCD_FUNCTIONSET | LCD_8BITMODE, LOW);
    delayMicroseconds(5000); // wait min 4.1ms
  }

  //put the LCD into 4 bit or 8 bit mode
  if (! (_displayfunction & LCD_8BITMODE)) {
    // finally, set to 4-bit interface
    writebits(LCD_FUNCTIONSET, LOW);
    delayMicroseconds(100);   // commands and writes need > 37us to settle
  }

  if (mode & LCD_TYPEDOG) {
    _displaytype = LCD_TYPEDOG;
    command(LCD_FUNCTIONSET | _displayfunction | LCD_DOGIS1);
    command(LCD_DOGBIAS | bias | (rows == 3));	  // bias
    command(LCD_DOGFOLLOW | 0x02);  // follower control

    contrast(36, 1);
  } else {
    _displaytype = LCD_TYPESTD;
  }

  // finally, set # rows, font size, etc.
  command(LCD_FUNCTIONSET | _displayfunction);  
  delay(5);
  // turn the display on with no cursor or blinking default
  _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;  
  display();

  // clear it off
  clear();

  // Initialize to default text direction (for romance languages)
  _displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDISABLE;
  // set the entry mode
  command(LCD_ENTRYMODESET | _displaymode);
}