Пример #1
0
void viewTOTPcode(totp* tkn) {
  unsigned short key = 0; int keyCol, keyRow;
  Bdisp_AllClr_VRAM();
  drawScreenTitle(tkn->name);
  int shown_since_beginning = 0;
  while(key != KEY_PRGM_EXIT && key != KEY_PRGM_LEFT) {
    int ThirtySecCode = computeTOTP(tkn);
    char buffer[10];
    itoa_zeropad(tkn->totpcode, buffer, 6);
    long long int ms_spent_ll = currentUTCUEBT() - (long long int)ThirtySecCode * 30LL * 1000LL;
    int ms_spent = (int)(ms_spent_ll);

    drawCircularCountdownIndicator(LCD_WIDTH_PX/2, 104, 44, COLOR_BLACK, COLOR_WHITE,
                                   (ms_spent*43)/30000, getCurrentSecond() < 30 ? 0 : 1);
    // fade in/out animation for text
    int val = 0;
    if(ms_spent >= 29000) {
      val += (-29000 + ms_spent)/4;
    } else if (ms_spent <= 1020) {
      val += (1020 - ms_spent)/4;
    }
    int color = drawRGB24toRGB565(val, val, val);
    printCentered(buffer, 164, color, COLOR_WHITE);
    if(ms_spent < 2500) shown_since_beginning = 1;
    else if(ms_spent < 15000 && shown_since_beginning)
      DefineStatusMessage((char*)totpHelpMessages[(ms_spent-2500)/2500], 1, 0, 0);
    else
      DefineStatusMessage((char*)"", 1, 0, 0);
    DisplayStatusArea();
    Bdisp_PutDisp_DD();
    key = PRGM_GetKey();
    if(key == KEY_PRGM_MENU)
      GetKeyWait_OS(&keyCol, &keyRow, 2, 0, 0, &key); //this is here to handle the Menu key
    if(key == KEY_PRGM_OPTN) {
      DefineStatusMessage((char*)"", 1, 0, 0);
      GetKeyWait_OS(&keyCol, &keyRow, 2, 0, 0, &key); // clear keybuffer
      RTCunadjustedWizard(0, 1);
      setTimezone();
      return; // so we don't have to redraw etc.
      // Also, this way the Shift+Menu instruction shown in the adjustment wizard becomes vali
      // immediately, which is great if the user wants to repeat the adjustment.
    }
  }
  DefineStatusMessage((char*)"", 1, 0, 0);
  // clear keybuffer:
  GetKeyWait_OS(&keyCol, &keyRow, 2, 0, 0, &key);
}
Пример #2
0
void draw_rb_incorrect_note_at(alt_up_pixel_buffer_dma_dev* pixel_buffer, int location, int x_location)
// FUNCTION: Draws the template for an incorrect note in the rock band game mode to the back buffer.
// Doesn't write the pitch to the char buffer. This is done inside the update_rb function.
// REQUIRES: 1 <= location <= 60
// RETURNS: None
{
	/*
	// Draw double thickness square in black
	alt_up_pixel_buffer_dma_draw_rectangle(pixel_buffer, x_location*4 - 9, location*4 - 12, x_location*4 + 11, location*4 + 8,0x0000, 1);
	alt_up_pixel_buffer_dma_draw_rectangle(pixel_buffer, x_location*4 - 8, location*4 - 11,  x_location*4 + 10, location*4 + 7,0x0000, 1);
	*/

	// Fill the inside in green
	uint16_t fill_colour = drawRGB24toRGB565(0x66, 0x33, 0x00); // Brown cave colour
	alt_up_pixel_buffer_dma_draw_box(pixel_buffer, x_location*4 - 7, location*4 - 10,  x_location*4 + 9, location*4 + 6, fill_colour, 1);

}
Пример #3
0
void welcomeScreen(){
  drawFill(drawRGB24toRGB565(nwazetYellowRed, nwazetYellowGreen, nwazetYellowBlue));
  lcdSetWindow(
    49, 49 + (142 - 1),
    82, 82 + (156 - 1));
  unsigned short imageSize = 44304;
  unsigned short* imagePixel = (unsigned short*) &nwazetLogo[0];
  while(imageSize){
    lcdWriteData(*imagePixel);
    imagePixel++;
    imageSize -= 2;
  }
  unsigned short y = 10;
  unsigned short spaceBetweenLines = 2;
  printString("Touch Display", y);
  y+=verdanabold14ptFontInfo.height+spaceBetweenLines;
  printString("By [nwazet", y);
  y = 295;
  printString("Raspberry Pi v0.1", y);
}
Пример #4
0
bmp_error_t bmpParseBitmap(uint16_t x, uint16_t y, FIL file)
{
  UINT              bytesRead;
  bmp_header_t      header;
  bmp_infoheader_t  infoHeader;

  // Read the file header
  // ToDo: Optimise this to read buffer once and parse it
  f_read(&file, &header.type, sizeof(header.type), &bytesRead);
  f_read(&file, &header.size, sizeof(header.size), &bytesRead);
  f_read(&file, &header.reserved1, sizeof(header.reserved1), &bytesRead);
  f_read(&file, &header.reserved2, sizeof(header.reserved2), &bytesRead);
  f_read(&file, &header.offset, sizeof(header.offset), &bytesRead);

  // Make sure this is a bitmap (first two bytes = 'BM' or 0x4D42 on little-endian systems)
  if (header.type != 0x4D42) return BMP_ERROR_NOTABITMAP;

  // Read the info header
  // ToDo: Optimise this to read buffer once and parse it
  f_read(&file, &infoHeader.size, sizeof(infoHeader.size), &bytesRead);
  f_read(&file, &infoHeader.width, sizeof(infoHeader.width), &bytesRead);
  f_read(&file, &infoHeader.height, sizeof(infoHeader.height), &bytesRead);
  f_read(&file, &infoHeader.planes, sizeof(infoHeader.planes), &bytesRead);
  f_read(&file, &infoHeader.bits, sizeof(infoHeader.bits), &bytesRead);
  f_read(&file, &infoHeader.compression, sizeof(infoHeader.compression), &bytesRead);
  f_read(&file, &infoHeader.imagesize, sizeof(infoHeader.imagesize), &bytesRead);
  f_read(&file, &infoHeader.xresolution, sizeof(infoHeader.xresolution), &bytesRead);
  f_read(&file, &infoHeader.yresolution, sizeof(infoHeader.yresolution), &bytesRead);
  f_read(&file, &infoHeader.ncolours, sizeof(infoHeader.ncolours), &bytesRead);
  f_read(&file, &infoHeader.importantcolours, sizeof(infoHeader.importantcolours), &bytesRead);

  // Make sure that this is a 24-bit image
  if (infoHeader.bits != 24) 
    return BMP_ERROR_INVALIDBITDEPTH;

  // Check image dimensions
  if ((infoHeader.width > lcdGetWidth()) | (infoHeader.height > lcdGetHeight()))
    return BMP_ERROR_INVALIDDIMENSIONS;

  // Make sure image is not compressed
  if (infoHeader.compression != BMP_COMPRESSION_NONE) 
    return BMP_ERROR_COMPRESSEDDATA;

  // Read 24-bit image data
  uint32_t px, py;
  FRESULT res;
  uint8_t buffer[infoHeader.width * 3];
  for (py = infoHeader.height; py > 0; py--)
  {
    // Read one row at a time
    res = f_read(&file, &buffer, infoHeader.width * 3, &bytesRead);
    if (res || bytesRead == 0)
    {
      // Error or EOF
      return BMP_ERROR_PREMATUREEOF;
    }
    for (px = 0; px < infoHeader.width; px++)
    {
      // Render pixel
      // ToDo: This is a brutally slow way of rendering bitmaps ...
      //        update to pass one row of data at a time
      drawPixel(x + px, y + py - 1, drawRGB24toRGB565(buffer[(px * 3) + 2], buffer[(px * 3) + 1], buffer[(px * 3)]));
    }
  }

  return BMP_ERROR_NONE;
}
Пример #5
0
int update_eq_sinc(int amplitude, int green)
// FUNCTION: Updates the equaliser for pretty graphics and swaps the pixel buffer
// REQUIRES: Initialised pixel buffer
// RETURNS: New green value
{
	// Declare variables
	int i, j, red, blue, height, y_value, original_top, x_axis, x_value;
	float period = ((rand() % 200) + 600.0) / 100.0; // Randomly generate period between 6.0 and 8.0
	uint16_t colour;
	int random_amplitude;
	float random_period;

	if(/* alt_timestamp()/(float) alt_timestamp_freq() > EQ_TIME_CONSTANT_S && */ m == eq)
	{
		v.blank_flag = FALSE;
		rb.background_flag = FALSE;
		alt_up_char_buffer_clear(v.char_buffer);
		random_amplitude = (rand() % 50) + 50;
		random_period = ((rand() % 200) + 600.0) / 100.0;
		printf("Random amplitude: %d\n", random_amplitude);
		if(rand() % 1 == 0)
		{
			if(green < 251) green += 5;
		}
		else if(green > 5) green -= 5;
		alt_up_pixel_buffer_dma_clear_screen(v.pixel_buffer, 1); // Clear back buffer
		x_axis = 190;
		original_top = x_axis - x_axis*amplitude/MAX_AMPLITUDE;


		for(x_value=0; x_value < 160; x_value++) // Draw two-sided sinc function, almost to each side of the screen
		{
			red = 255*(160-x_value)/160; // red will increase towards the middle of the screen

			// Calculate value of the sinc function for x-coordinate x_value
			if(x_value>0) height = (x_axis*amplitude/MAX_AMPLITUDE)*sin(x_value/period) /(x_value/period);
			else height = x_axis*amplitude/MAX_AMPLITUDE;

			y_value = x_axis - height;
			if(height>0) // This means the sinc function is above the x-axis
			{
				for(j=y_value; j<=x_axis; j++) // j is the y-coordinate
				{
					blue = 255*(j - original_top)/(x_axis*amplitude/MAX_AMPLITUDE); // blue will increase towards the x_axis of the screen
					colour = drawRGB24toRGB565(red, green, blue);
					i=160-x_value; // i is the x-coordinate
					alt_up_pixel_buffer_dma_draw(v.pixel_buffer, colour, i, j);
					i=160+x_value; // i is the x-coordinate
					alt_up_pixel_buffer_dma_draw(v.pixel_buffer, colour, i, j);
				}
			}
			else // This means the sinc function is on or below the x-axis
			{
				for(j=y_value; j>=x_axis; j--) // j is the y-coordinate
				{
					blue = 255*(2*x_axis-j - original_top)/(x_axis*amplitude/MAX_AMPLITUDE); // blue will increase towards the x_axis of the screen
					colour = drawRGB24toRGB565(red, green, blue);
					i=160-x_value; // i is the x-coordinate
					alt_up_pixel_buffer_dma_draw(v.pixel_buffer, colour, i, j);
					i=160+x_value; // i is the x-coordinate
					alt_up_pixel_buffer_dma_draw(v.pixel_buffer, colour, i, j);
				}
			}
		}
		// Swap buffers
		alt_up_pixel_buffer_dma_swap_buffers(v.pixel_buffer);
		while (alt_up_pixel_buffer_dma_check_swap_buffers_status(v.pixel_buffer));
		// alt_timestamp_start();
	}
	return green;
}