API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 9th, 2014
1,131
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.90 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  *    Author: nosilent@esdblog.org
  3.  *      Date: 9.10.2014
  4.  *      Project: STM32F429I-DISCO LED Matrix Hub Controller
  5.  */
  6.  
  7. #define USE_USB_OTG_HS //enable USB
  8.  
  9. #define OE  0//define if oe is high active=1 or low active=0
  10. //max. tested resolutions: WIDTH 32*8, HEIGHT 16, recommended MODULES<=6 with HEIGHT=16 and WIDTH=32
  11. #define MODULES 6
  12. #define WIDTH       32*MODULES//HUB08 type:64, HUB75 type:32
  13. #define HEIGHT  16//HUB08 type:32, HUB75 type:16
  14. #define BRIGHTNESS  8 //in Bit, ex. 8 bit=2^8=256 steps
  15.  
  16. #include "tm_stm32f4_usb_vcp.h"
  17. #include "tm_stm32f4_disco.h"
  18. #include "tm_stm32f4_delay.h"
  19. #include "defines.h"
  20. #include "stm32f4xx_tim.h"
  21. #include "stm32f4xx_dma.h"
  22. #include "fonts.h"
  23. #include "stm32f4xx_usart.h"
  24. #include "stm32f4xx_spi.h"
  25.  
  26. //the pixel image in RGB
  27. struct color{
  28.     uint8_t R;
  29.     uint8_t G;
  30.     uint8_t B;
  31. };
  32.  
  33. volatile struct color image[HEIGHT][WIDTH];//width height with each rgb
  34.  
  35. //temp variables
  36. volatile uint32_t pwm = 0, height=0, led_data_size=0, rgb_data=0, width=0,prescaler_size=0;
  37. volatile uint16_t abcd=0;
  38.  
  39. //calculate led data array/size
  40. #define PRESCALER_SIZE  WIDTH*BRIGHTNESS
  41. #define LED_DATA_SIZE   PRESCALER_SIZE*(HEIGHT/2)
  42. volatile uint16_t led_data[LED_DATA_SIZE];
  43. volatile uint16_t prescaler[PRESCALER_SIZE];
  44.  
  45. struct color foreground_color;
  46. struct color background_color;
  47.  
  48. volatile uint8_t color_correction[256];
  49.  
  50. void calcColorCorrection(void){
  51.     for(pwm=0;pwm<256;pwm++){
  52.         color_correction[pwm]=pwm;
  53.     }
  54. }
  55.  
  56. void calcPrescaler(void){
  57.     #if BRIGHTNESS>1
  58.     uint32_t prescaler_width,prescaler_brightness;
  59.     uint32_t prescaler_data[BRIGHTNESS];
  60.     prescaler_data[0]=0;
  61.     for(prescaler_width=0;prescaler_width<BRIGHTNESS-1;prescaler_width++){
  62.         prescaler_data[prescaler_width+1]=1<<prescaler_width;
  63.     }
  64.     for(prescaler_width=0;prescaler_width<MODULES;prescaler_width++){
  65.         prescaler[prescaler_size++]=prescaler_data[BRIGHTNESS-2];
  66.     }
  67.     for(prescaler_width=0;prescaler_width<WIDTH;prescaler_width++){
  68.         prescaler[prescaler_size++]=prescaler_data[BRIGHTNESS-1];
  69.     }
  70.     for(prescaler_brightness=0;prescaler_brightness<BRIGHTNESS-2;prescaler_brightness++){
  71.         for(prescaler_width=0;prescaler_width<WIDTH;prescaler_width++){
  72.             prescaler[prescaler_size++]=prescaler_data[prescaler_brightness];
  73.         }
  74.     }
  75.     for(prescaler_width=0;prescaler_width<WIDTH-MODULES;prescaler_width++){
  76.         prescaler[prescaler_size++]=prescaler_data[BRIGHTNESS-2];
  77.     }
  78.     #endif
  79. }
  80.  
  81. void DMA2_Stream1_IRQHandler(void){
  82.     if (DMA_GetITStatus(DMA2_Stream1, DMA_IT_TCIF1)){
  83.         DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_TCIF1);
  84.         DMA_Cmd(DMA2_Stream2, DISABLE);
  85.         DMA_SetCurrDataCounter(DMA2_Stream2,prescaler_size);
  86.         DMA_Cmd(DMA2_Stream2, ENABLE);
  87.     }
  88. }
  89.  
  90. void initLEDdata(void){
  91.     TIM_OCInitTypeDef  TIM_OCInitStructure;
  92.     GPIO_InitTypeDef  GPIO_InitStructure;
  93.     DMA_InitTypeDef  DMA_InitStructure;
  94.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  95.     NVIC_InitTypeDef NVIC_InitStructure;
  96.    
  97.     //pre calculate color correction
  98.     calcColorCorrection();
  99.    
  100.     //pre calculate the prescaler values
  101.     calcPrescaler();
  102.    
  103.     //set the gpios to output
  104.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
  105.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|/*GPIO_Pin_9|*/GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
  106.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  107.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  108.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  109.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  110.   GPIO_Init(GPIOC, &GPIO_InitStructure);
  111.    
  112.     //clk
  113.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  114.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  115.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  116.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  117.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  118.   GPIO_Init(GPIOC, &GPIO_InitStructure);
  119.    
  120.     GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_TIM8);
  121.    
  122.     //DMA related stuff
  123.    
  124.   /* Enable the DMA clock */
  125.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);
  126.  
  127.   /* Configure the DMA Stream */
  128.   DMA_Cmd(DMA2_Stream1, DISABLE);
  129.   DMA_DeInit(DMA2_Stream1);
  130.  
  131.   /* Set the parameters to be configured */
  132.   DMA_InitStructure.DMA_Channel = DMA_Channel_7;
  133.   DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&GPIOC->ODR;
  134.   DMA_InitStructure.DMA_Memory0BaseAddr    = (uint32_t)&led_data[0];
  135.   DMA_InitStructure.DMA_BufferSize = led_data_size;
  136.   DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
  137.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  138.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  139.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  140.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  141.   DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  142.  
  143.   DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
  144.   DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
  145.   DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_3QuartersFull;
  146.   DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  147.   DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  148.  
  149.   DMA_Init(DMA2_Stream1, &DMA_InitStructure);
  150.    
  151.     //DMA_DoubleBufferModeConfig(DMA2_Stream1,(uint32_t)&led_data[0],DMA_Memory_0);
  152.     //DMA_DoubleBufferModeCmd(DMA2_Stream1, ENABLE);
  153.    
  154.     DMA_ITConfig(DMA2_Stream1,DMA_IT_TC, ENABLE);
  155.    
  156.   /* Configure and enable DMA interrupt */
  157.   NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream1_IRQn;
  158.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  159.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  160.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  161.   NVIC_Init(&NVIC_InitStructure);
  162.    
  163.   DMA_Cmd(DMA2_Stream1, ENABLE);//enable the dma (led_data->gpio)
  164.    
  165.     //enable the timer for the dma requests
  166.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM8, ENABLE);  /* TIM8 clock enable */
  167.     TIM_Cmd(TIM8, DISABLE);  
  168.     TIM_DeInit(TIM8);
  169.   TIM_TimeBaseStructure.TIM_Period        = 9;
  170.   TIM_TimeBaseStructure.TIM_Prescaler     = 0;
  171.   TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  172.   TIM_TimeBaseStructure.TIM_CounterMode   = TIM_CounterMode_Up;
  173.  
  174.   TIM_TimeBaseInit(TIM8, &TIM_TimeBaseStructure);  /* Time base configuration */
  175.  
  176.     TIM_ARRPreloadConfig(TIM8, ENABLE);              /* Enable the time autoreload register */
  177.  
  178.     /* TIM PWM1 Mode configuration */
  179.   TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  180.   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  181.   TIM_OCInitStructure.TIM_Pulse = 5;
  182.   TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
  183.  
  184.   TIM_OC4Init(TIM8, &TIM_OCInitStructure);
  185.   TIM_OC4PreloadConfig(TIM8, TIM_OCPreload_Enable);
  186.  
  187.   /* TIM8 Main Output Enable */
  188.   TIM_CtrlPWMOutputs(TIM8, ENABLE);
  189.        
  190.     /* configure DMA */
  191.     DMA_DeInit(DMA2_Stream2);
  192.  
  193.     DMA_InitStructure.DMA_Channel = DMA_Channel_7;
  194.     DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)TIM8_BASE+ 0x28;   // physical address of Timer 8 + 14.4.11 TIM1&TIM8 prescaler (TIMx_PSC)
  195.     DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)prescaler;
  196.     DMA_InitStructure.DMA_BufferSize = prescaler_size;
  197.     DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
  198.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  199.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  200.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  201.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  202.     DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  203.    
  204.     DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  205.     DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
  206.   DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_3QuartersFull;
  207.   DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  208.   DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  209.  
  210.     DMA_Init(DMA2_Stream2, &DMA_InitStructure);
  211.    
  212.     //DMA_DoubleBufferModeConfig(DMA2_Stream2,(uint32_t)&prescaler[0],DMA_Memory_0);
  213.     //DMA_DoubleBufferModeCmd(DMA2_Stream2, ENABLE);
  214.    
  215.     DMA_Cmd(DMA2_Stream2, ENABLE);//enable the prescaler dma (prescaler_data->timer)
  216.    
  217.     TIM_DMACmd(TIM8, TIM_DMA_CC1, ENABLE);
  218.     TIM_DMACmd(TIM8, TIM_DMA_Update, ENABLE);        /* Enable TIM8_UP DMA Requests, enable the timer update requests (tim->dma->gpio) */
  219.  
  220.     TIM_Cmd(TIM8, ENABLE);                           /* TIM enable counter (timer->dma) */
  221. }
  222.  
  223. void calculateLEDdata(void){
  224.         rgb_data=0;height=0;led_data_size=0;pwm=0;
  225.         //GPIO Pin configuration: 3=B2,4=G2,5=R2,6=B1,7=G1,8=R1,9=CLK,10=LAT,11=OE,12=A,13=B,14=C,15=D 
  226.         for(height=0;height<(HEIGHT/2);height++){
  227.             //check row line arrangement (for 16 we need 3bits, so only ABC is used, for 32 we use ABCD)
  228.             #if HEIGHT<=16
  229.             abcd=(((15+height)&0xf)<<12)&0x7000;//No D
  230.             #elif HEIGHT<=32
  231.             abcd=(((15+height)&0xf)<<12);
  232.             #endif
  233.             //pwm
  234.             for(pwm=0;pwm<BRIGHTNESS;pwm++){
  235.                 for(width=0;width<(WIDTH-1);width++){
  236.                     //change image[height][width].R and so on to according led pixel color of your display (this is RBG)
  237.                     rgb_data=(((color_correction[image[height][width].R]>>pwm)&0x1)<<8)|(((color_correction[image[height][width].B]>>pwm)&0x1)<<7)|(((color_correction[image[height][width].G]>>pwm)&0x1)<<6)|(((color_correction[image[height+(HEIGHT/2)][width].R]>>pwm)&0x1)<<5)|(((color_correction[image[height+(HEIGHT/2)][width].B]>>pwm)&0x1)<<4)|(((color_correction[image[height+(HEIGHT/2)][width].G]>>pwm)&0x1)<<3);
  238.                     #if OE==1
  239.                     led_data[led_data_size++]=0x800|abcd|rgb_data;//ABCD,OE=1,LAT=0,CLK=0,R1=0,G1=0,B1=0,R2=0,G2=0,B2=0,NC,NC,NC
  240.                     #elif OE==0
  241.                     led_data[led_data_size++]=abcd|rgb_data;//0x800|abcd|e;//ABCD,OE=0,LAT=0,CLK=0,R1=0,G1=0,B1=0,R2=0,G2=0,B2=0,NC,NC,NC
  242.                     #endif
  243.                 }
  244.                 //last data line with latch
  245.                 abcd=(height<<12);
  246.                 //change image[height][width].R and so on to according led pixel color of your display (this is RBG)
  247.                 rgb_data=(((color_correction[image[height][width].R]>>pwm)&0x1)<<8)|(((color_correction[image[height][width].B]>>pwm)&0x1)<<7)|(((color_correction[image[height][width].G]>>pwm)&0x1)<<6)|(((color_correction[image[height+(HEIGHT/2)][width].R]>>pwm)&0x1)<<5)|(((color_correction[image[height+(HEIGHT/2)][width].B]>>pwm)&0x1)<<4)|(((color_correction[image[height+(HEIGHT/2)][width].G]>>pwm)&0x1)<<3);
  248.                 #if OE==1
  249.                 led_data[led_data_size++]=0x400|abcd|rgb_data;//ABCD,OE=0,LAT=1,CLK=0,R1=0,G1=0,B1=0,R2=0,G2=0,B2=0,NC,NC,NC
  250.                 #elif OE==0
  251.                 led_data[led_data_size++]=0xC00|abcd|rgb_data;//ABCD,OE=1,LAT=1,CLK=0,R1=0,G1=0,B1=0,R2=0,G2=0,B2=0,NC,NC,NC
  252.                 #endif
  253.             }
  254.         }
  255. }
  256.  
  257.  
  258. void calculateTestLEDData(void){
  259.     uint32_t height,width;
  260.     static uint32_t offset=0;
  261.     static uint8_t brightness=0;
  262.     for(height=0;height<HEIGHT;height++){
  263.         for(width=0;width<WIDTH;width++){
  264.             switch(offset){
  265.                 default:
  266.                 case 0:
  267.                     image[height][width].R=brightness;
  268.                     image[height][width].G=0x0;
  269.                     image[height][width].B=0x0;
  270.                     break;
  271.                 case 1:
  272.                     image[height][width].R=0x0;
  273.                     image[height][width].G=brightness;
  274.                     image[height][width].B=0x0;
  275.                     break;
  276.                 case 2:
  277.                     image[height][width].R=0x0;
  278.                     image[height][width].G=0x0;
  279.                     image[height][width].B=brightness;
  280.                     break;
  281.             }
  282.             offset=(offset+1)%3;
  283.         }
  284.     }
  285.     brightness++;
  286. }
  287.  
  288. void calculateLEDString(char *s, int32_t x, int32_t y, sFONT font){
  289.     int32_t i,l,j;
  290.     while(*s){
  291.         for(i=0;i<font.Height;i++){
  292.             l=font.table[((*s)-32)*(font.Height)+i];
  293.             for(j=0;j<font.Width;j++){
  294.                 if(WIDTH>x+(font.Width-1-j) && x+(font.Width-1-j)>=0){//check width
  295.                     if((l>>j)&0x1){
  296.                         image[y+i][x+(font.Width-1-j)].R=foreground_color.R;
  297.                         image[y+i][x+(font.Width-1-j)].G=foreground_color.G;
  298.                         image[y+i][x+(font.Width-1-j)].B=foreground_color.B;
  299.                     }else{
  300.                         image[y+i][x+(font.Width-1-j)].R=background_color.R;
  301.                         image[y+i][x+(font.Width-1-j)].G=background_color.G;
  302.                         image[y+i][x+(font.Width-1-j)].B=background_color.B;
  303.                     }
  304.                 }
  305.             }
  306.         }
  307.         x+=font.Width;
  308.         s++;
  309.     }
  310. }
  311.  
  312. void calculateLine(uint32_t x, uint32_t y, uint32_t width, uint32_t height, struct color line_color){
  313.     for(;x<width;x++){
  314.         for(;y<height;y++){
  315.             image[y][x].R=line_color.R;
  316.             image[y][x].G=line_color.G;
  317.             image[y][x].B=line_color.B;
  318.         }
  319.     }
  320. }
  321.  
  322. void calculateRectangle(uint32_t x, uint32_t y, uint32_t width, uint32_t height, struct color frame_color, struct color fill_color){
  323.     //fill
  324.     for(;x<width;x++){
  325.         for(;y<height;y++){
  326.             image[y][x].R=fill_color.R;
  327.             image[y][x].G=fill_color.G;
  328.             image[y][x].B=fill_color.B;
  329.         }
  330.     }
  331.     //lines
  332.     calculateLine(x,y,width,y+1,frame_color);
  333.     calculateLine(x,y,x+1,height,frame_color);
  334.     calculateLine(width,y,width+1,height,frame_color);
  335.     calculateLine(x,height,width,height+1,frame_color);
  336. }
  337.  
  338. void calculateClearImage(void){
  339.     for(height=0;height<HEIGHT;height++){
  340.             for(width=0;width<WIDTH;width++){
  341.                 image[height][width].R=0x0;
  342.                 image[height][width].G=0x0;
  343.                 image[height][width].B=0x0;
  344.             }
  345.     }
  346. }
  347.  
  348. void calculateScrollChar(char s, sFONT font){
  349.     char str[1];
  350.     static uint32_t x=WIDTH-8;
  351.     if(x<1){
  352.         calculateLEDString(" ",0,0,font);
  353.         x=WIDTH-8;
  354.     }
  355.     str[0]=s;
  356.     calculateLEDString(str,x,0,font);
  357.     x--;
  358. }
  359.  
  360. void calculateScrollText(char *s, sFONT font, uint8_t textlength, uint8_t y, int32_t *x){  
  361.     if((*x)<textlength*-8){
  362.         (*x)=WIDTH+8*textlength;
  363.         for(;textlength>0;textlength--){
  364.             calculateLEDString(" ",textlength*8,y,font);
  365.         }
  366.         calculateLEDString(" ",textlength*-8,y,font);
  367.     }
  368.     calculateLEDString(s,(*x),y,font);
  369.     (*x)--;
  370. }
  371.  
  372. void updateLEDData(void){
  373.     calculateLEDdata();
  374.     TIM_Cmd(TIM8, DISABLE);
  375.     DMA_Cmd(DMA2_Stream1, DISABLE);
  376.     DMA_Cmd(DMA2_Stream2, DISABLE);
  377.     DMA_SetCurrDataCounter(DMA2_Stream1,led_data_size);
  378.     DMA_SetCurrDataCounter(DMA2_Stream2,prescaler_size);
  379.     DMA_Cmd(DMA2_Stream1, ENABLE);
  380.     DMA_Cmd(DMA2_Stream2, ENABLE);
  381.     TIM_Cmd(TIM8, ENABLE);
  382. }
  383.  
  384. void invertForeBackgroundColor(void){
  385.     struct color temp_color;
  386.    
  387.     temp_color=foreground_color;
  388.     foreground_color=background_color;
  389.     background_color=temp_color;
  390. }
  391.  
  392. int main(void) {
  393.         int32_t scroll1=0,scroll2=0;
  394.         uint32_t image_width_index=0,image_height_index=0,image_rgb_index=0;
  395.     uint8_t c;
  396.    
  397.     /* System Init */
  398.     SystemInit();
  399.    
  400.         //Initialize delay Systick timer
  401.     TM_DELAY_Init();
  402.    
  403.     /* Initialize LED's and Button. Make sure to check settings for your board in tm_stm32f4_disco.h file */
  404.     TM_DISCO_LedInit();
  405.         TM_DISCO_ButtonInit();
  406.    
  407.     /* Initialize USB VCP */    
  408.     TM_USB_VCP_Init();
  409.  
  410.         //define used colors for some additional functionality
  411.         foreground_color.R=0xff;
  412.         foreground_color.G=0xff;
  413.         foreground_color.B=0xff;
  414.         background_color.R=0x1;
  415.         background_color.G=0x1;
  416.         background_color.B=0x0;
  417.    
  418.         //initialize the led driving (gpios,dma,timer)
  419.         initLEDdata();
  420.        
  421.         //clear image
  422.         calculateClearImage();
  423.         updateLEDData();
  424.        
  425.         //some test to display
  426.         calculateLEDString("ESD ",WIDTH-32,0,Font8x8);
  427.         calculateLEDString("Blog",WIDTH-32,8,Font8x8);
  428.         //calculateLine(5,5,10,10,foreground_color);
  429.         //calculateRectangle(1,2,10,10,foreground_color,background_color);
  430.         calculateLEDdata();
  431.         Delayms(1000);
  432.        
  433.     while (1) {
  434.             //calculateTestLEDData();
  435.             //calculateScrollChar('A',Font8x8);
  436.             calculateScrollText("ELECTRONICS iT and many more",Font8x8,28,0,&scroll1);
  437.             if(c>20){
  438.                 invertForeBackgroundColor();
  439.             }
  440.             calculateLEDString("  TODAY ",0,8,Font8x8);
  441.             if(c>20){
  442.                 invertForeBackgroundColor();
  443.             }
  444.             #if HEIGHT>16
  445.             calculateScrollText("www.esdblog.org",Font8x8,15,16,&scroll2);
  446.             if(c>20){
  447.                 invertForeBackgroundColor();
  448.             }
  449.             calculateLEDString("  NEW   ",0,24,Font8x8);
  450.             if(c>20){
  451.                 invertForeBackgroundColor();
  452.             }
  453.             #endif
  454.             calculateLEDdata();
  455.             c=(c+1)%40;
  456.             Delayms(25);
  457.            
  458.             //check if button pressed->enter usb mode
  459.             if(TM_DISCO_ButtonPressed()){
  460.             while(1){
  461.            
  462.             /* USB configured OK, drivers OK */
  463.             if (TM_USB_VCP_GetStatus() == TM_USB_VCP_CONNECTED) {
  464.             /* Turn off RED led */
  465.             //TM_DISCO_LedOff(LED_RED);
  466.             /* If something arrived at VCP */
  467.             while (TM_USB_VCP_Getc(&c) == TM_USB_VCP_DATA_OK) {
  468.                 /* Return data back */
  469.                 //TM_USB_VCP_Putc(c);
  470.                                 //write to temp image
  471.                                 switch(image_rgb_index){
  472.                                     default:
  473.                                     case 0:
  474.                                         image[image_height_index][image_width_index].R=c;
  475.                                         break;
  476.                                     case 1:
  477.                                         image[image_height_index][image_width_index].G=c;
  478.                                         break;
  479.                                     case 2:
  480.                                         image[image_height_index][image_width_index].B=c;
  481.                                         break;
  482.                                 }
  483.                                 image_rgb_index++;
  484.                                 if(image_rgb_index>=3){
  485.                                     image_rgb_index=0;
  486.                                     image_width_index++;                       
  487.                                     if(image_width_index>=WIDTH){
  488.                                         image_width_index=0;
  489.                                         image_height_index++;
  490.                                         if(image_height_index>=HEIGHT){
  491.                                             image_height_index=0;
  492.                                             image_height_index=0;image_width_index=0;image_rgb_index=0;
  493.                                             calculateLEDdata();
  494.                                     }
  495.                                 }
  496.                             }
  497.             }
  498.         } else {
  499.             /* USB not OK */
  500.             //TM_DISCO_LedOn(LED_RED);
  501.         }
  502.             }
  503.         }
  504.     }
  505. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!