|
|
View previous topic :: View next topic |
Author |
Message |
ressas
Joined: 15 Nov 2019 Posts: 135
|
(NOT) Saving data from Bluetooth to array |
Posted: Sun Nov 15, 2020 7:49 am |
|
|
18F46k22
Hello.
I am trying to save the data coming via Bluetooth into an array. However, I later realized that there was a problem reading the values from the array. Tell me like this:
Code: |
unsigned int16 value=0;
unsigned int16 dummy1=0;
unsigned int16 dummy2=0;
unsigned int16 array[];
unsigned int16 k=0;
#INT_RDA
void serialInterrupt()
{
clear_interrupt(INT_RDA);
value=getc();
array[k] = value;
k++;
delay_ms(20);
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
}
...
...
...
while(true){
dummy1=array[k];
dummy2=value;
printf("Array: %ld", dummy1); // This line of code doesn't work
printf("Value: %ld",dummy2); // This line of code work
}
|
I mean, when I read the value from the array, it's not the value I'm sending.
But when I directly read the value and put it on the 2nd dummy, there is no problem.
How do I fix this problem ?
Thank you |
|
|
temtronic
Joined: 01 Jul 2010 Posts: 9225 Location: Greensville,Ontario
|
|
Posted: Sun Nov 15, 2020 7:59 am |
|
|
Quick comments
For starters....
See EOL comments...
1st all variables should be bytes NOT words. Data from UART will be 8 bits.
2nd 'array' has zero space allocated. Pretty sure YOU need to specify an amount, say 32 bytes for test purposes.
3rd this...
#INT_RDA
void serialInterrupt()
{
clear_interrupt(INT_RDA); //// delete this line, compiler does this
value=getc();
array[k] = value;
k++;
delay_ms(20); //// delete this line, NEVER have delays in ISRs
enable_interrupts(INT_RDA); //// delete this line, compiler does this
enable_interrupts(GLOBAL); //// delete this line, compiler does this
}
edit/recompile/test/see what happens |
|
|
Ttelmah
Joined: 11 Mar 2010 Posts: 19506
|
|
Posted: Sun Nov 15, 2020 8:07 am |
|
|
Actually, I'd just 'disagree' with this comment:
enable_interrupts(GLOBAL); //// delete this line, compiler does this
The compiler does not do this. The _CHIP_ does this. The global
interrupt bit is disabled by the chip hardware as soon as an interrupt
handler is entered. The return from interrupt instruction automatically
re enables this bit when the interrupt exits.
It is absolutely vital on the PIC, that the global interrupt is never enabled
inside an interrupt handler. Doing so can/will result in the interrupt being
called again inside itself. Since the PIC's own hardware register saving
only supports one lot of values, if this happens, you are in a disaster.
You must never use enable_interrupts(GLOBAL) inside an interrupt handler.
Only a 'pedant mode' comment, but it is a critically important thing
about PIC interrupt handling.... |
|
|
ressas
Joined: 15 Nov 2019 Posts: 135
|
|
Posted: Sun Nov 15, 2020 9:06 am |
|
|
Thank you for your answer.
Actually, I knew my problem would not be solved since I did not share all of my code. I am not sharing it here because it is too long. But I have to share.
Before reviewing the code, please watch this short video and understand what the code will do.
[url] https://www.youtube.com/watch?v=iviJ6-IiJ10 [/url]
Actually the reason I define variables as 16 is because I don't want to drive the RGB display.
So the variables I guess the variables should remain 16 bits. Any other suggestions?
RGB.h
Code: |
//satır seçimi +5V
#DEFINE p1 pin_d7
#DEFINE p2 pin_d6
#DEFINE p3 pin_d5
#DEFINE p4 pin_d4
#DEFINE p5 pin_c1
#DEFINE p6 pin_c0
#DEFINE p7 pin_a6
#DEFINE p8 pin_a7
//Kırmızı renk seçimi
#DEFINE r1 pin_b7
#DEFINE r2 pin_b6
#DEFINE r3 pin_b5
#DEFINE r4 pin_b4
#DEFINE r5 pin_b3
#DEFINE r6 pin_b2
#DEFINE r7 pin_b1
#DEFINE r8 pin_b0
//Yeşil renk seçimi
#DEFINE g1 pin_c2
#DEFINE g2 pin_c3
#DEFINE g3 pin_d0
#DEFINE g4 pin_d1
#DEFINE g5 pin_d2
#DEFINE g6 pin_d3
#DEFINE g7 pin_c4
#DEFINE g8 pin_c5
//Mabi renk seçimi
#DEFINE b1 pin_e1
#DEFINE b2 pin_e0
#DEFINE b3 pin_a5
#DEFINE b4 pin_a4
#DEFINE b5 pin_a3
#DEFINE b6 pin_a2
#DEFINE b7 pin_a1
#DEFINE b8 pin_a0
|
RGB.c
Code: |
#include "rgb_matrix.h"
void martix_red(unsigned int16 power,unsigned int16 red ){
output_a(0x3f); output_b(0xff); output_c(0xfc); output_d(0x0f); output_e(0xff);
output_high(power);
output_low(red);
}
void martix_green(unsigned int16 power,unsigned int16 green){
output_a(0x3f); output_b(0xff); output_c(0xfc); output_d(0x0f); output_e(0xff);
output_high(power);
output_low(green);
}
void martix_blue(unsigned int16 power,unsigned int16 blue){
output_a(0x3f); output_b(0xff); output_c(0xfc); output_d(0x0f); output_e(0xff);
output_high(power);
output_low(blue);
}
|
Main.c
Code: |
#include <18f46k22.h>
#INCLUDE <stdlib.h>
#fuses NOWDT,NOBROWNOUT,NOPUT,NOWRT,NODEBUG,INTRC_io, NOMCLR, NOPROTECT, NOWDT, NOLVP, PLLEN
#use delay(internal=64000000)
#use standard_io(a) //A portu giriş çıkış olarak kullanılacak
#use standard_io(b)
#use fast_io(c)
#use standard_io(d)
#use standard_io(e)
#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
#include "rgb_matrix.c"
unsigned int16 gelenVeri=0;
unsigned int16 satirNumarasi =0;
unsigned int16 sutunNumarasi =0;
unsigned int16 rgbSecim =0;
int16 k =0;
unsigned int16 satir1[32];
unsigned int16 sutun1[32];
unsigned int16 sutunNumarasi2=0;
unsigned int16 satirNumarasi2=0;
const int16 dizi_p[8]={p1,p2,p3,p4,p5,p6,p7,p8};
const int16 dizi_r[8]={r1,r2,r3,r4,r5,r6,r7,r8};
const int16 dizi_g[8]={g1,g2,g3,g4,g5,g6,g7,g8};
const int16 dizi_b[8]={b1,b2,b3,b4,b5,b6,b7,b8};
#int_rda //seri haberleşme kesmesi oluşturuldu
void serihaberlesme_kesmesi()
{
clear_interrupt(INT_RDA); //kesme işlemleri yürütülürken yeni bir kesme gelmemesi için kesme kapatıldı
gelenVeri=getc();
switch (gelenVeri)
{
case 200: rgbSecim =1; break;
case 201: rgbSecim =2; break;
case 202: rgbSecim =3; break;
}
sutunNumarasi = (gelenVeri %8) - 1;
satirNumarasi = gelenVeri / 8;
if(sutunNumarasi==-1){
sutunNumarasi = 7;
}
switch (gelenVeri){ //8. Sutün için ekstra hesaplama
case 8 : satirNumarasi = 0; break;
case 16 : satirNumarasi = 1; break;
case 24 : satirNumarasi = 2; break;
case 32 : satirNumarasi = 3; break;
case 40 : satirNumarasi = 4; break;
case 48 : satirNumarasi = 5; break;
case 56 : satirNumarasi = 6; break;
case 64 : satirNumarasi = 7; break;
}
satir1[k]=satirNumarasi;
sutun1[k]=sutunNumarasi;
k++;
}
void main(){
setup_oscillator(OSC_64MHZ , OSC_PLL_ON);
set_tris_c(0b10111100);
output_a(0xff);
output_b(0xff);
output_c(0xff);
output_d(0xff);
output_e(0xff);
enable_interrupts(GLOBAL);
enable_interrupts(INT_RDA);
while(true){
// for(i=0;i<k+1;i++)
// {
satirNumarasi2 = satir1[k];//satirNumarasi;//
sutunNumarasi2 = sutun1[k];//sutunNumarasi;//
if(rgbSecim ==1)
{
martix_red(dizi_p[satirNumarasi2], dizi_r[sutunNumarasi2]);
}
else if(rgbSecim ==2)
{
martix_green(dizi_p[satirNumarasi], dizi_g[sutunNumarasi]);
}
else if(rgbSecim ==3)
{
martix_blue(dizi_p[satirNumarasi], dizi_b[sutunNumarasi]);
}
//}
delay_us(50);
}}
|
|
|
|
Ttelmah
Joined: 11 Mar 2010 Posts: 19506
|
|
Posted: Sun Nov 15, 2020 9:16 am |
|
|
First fix the ISR issues, and then give some space to the array you want to
store the values in,
You need something like:
Code: |
unsigned int8 value=0;
unsigned int16 dummy1=0;
unsigned int16 dummy2=0;
unsigned int8 array[256]; //now you have some space....
unsigned int16 k=0;
//Why waste space making the array int16?. The values being received
//are bytes. Single characters, not 'int16'.
#INT_RDA
void serialInterrupt()
{
value=getc();
array[k] = value;
k++;
if (k>=256)
k=0; //prevent overflow....
}
|
|
|
|
ressas
Joined: 15 Nov 2019 Posts: 135
|
|
Posted: Mon Nov 16, 2020 3:54 am |
|
|
Ttelmah wrote: | First fix the ISR issues, and then give some space to the array you want to
store the values in,
You need something like:
............
|
I tried the suggestion. But it didn't work. Do you have a second suggestion?
Should I add something like this?
sutunNumarasi = (unsigned int8)((gelenVeri %8) - 1);
satirNumarasi = (unsigned int8)(gelenVeri / 8); |
|
|
temtronic
Joined: 01 Jul 2010 Posts: 9225 Location: Greensville,Ontario
|
|
Posted: Mon Nov 16, 2020 6:07 am |
|
|
Ok I think I understand what it is.... the PIC has direct control over 8 'power' pins and 24 ( 3 x 8 ) 'colour' pins ( RGB) that are connected to the LED display module.
A PC sends a 'data stream' with the pixel # and color information, the PIC then turns on/off the required pin of the RGB 8x8 display.
First, you do not need 16bit variables, so change to 8 bits ( bytes). The port output functions are byte width. Code using bytes is faster than words (16 bits), and speed is important with direct drive LEDs.
looking at the code as I type...
you have main() include a file called RGB_martix.h BUT have shown RGB.h !
This file is the pin assignments . Since the program compiles, the 'matrix' file must exist but perhaps it's wrong ?
also you need 'errors' added to the use RS232(...options..)
if you can post the make/model LED display, that could be helpful. I might be able to find a translated version of code, well Google might !! |
|
|
ressas
Joined: 15 Nov 2019 Posts: 135
|
|
Posted: Mon Nov 16, 2020 8:47 am |
|
|
Thanks Temtronic. Actually, I already have a working code. You can review that code below. Since I don't want it to be too long, I try to shorten the following code with various algorithms. And yes I shortened it. The code above works fine. It only shows the current value on the matrix. It does not show previous values. So I want to apply what I did in the code below to it. Saving data in an array. If I can do that. The above code will work perfectly.
Code: |
#include <18f46k22.h>
#INCLUDE <stdlib.h>
#fuses NOWDT,NOBROWNOUT,NOPUT,NOWRT,NODEBUG,INTRC_IO, NOMCLR, NOPROTECT, NOWDT, NOLVP,pllen
#use delay(internal=64000000)
#use standard_io(a)
#use standard_io(b)
#use fast_io(c)
#use standard_io(d)
#use standard_io(e)
#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
//satır seçimi
#DEFINE p1 pin_d7
#DEFINE p2 pin_d6
#DEFINE p3 pin_d5
#DEFINE p4 pin_d4
#DEFINE p5 pin_c1
#DEFINE p6 pin_c0
#DEFINE p7 pin_a6
#DEFINE p8 pin_a7
//Kırmızı denk seçimi
#DEFINE r1 pin_b7
#DEFINE r2 pin_b6
#DEFINE r3 pin_b5
#DEFINE r4 pin_b4
#DEFINE r5 pin_b3
#DEFINE r6 pin_b2
#DEFINE r7 pin_b1
#DEFINE r8 pin_b0
//Yeşil renk seçimi
#DEFINE g1 pin_c2
#DEFINE g2 pin_c3
#DEFINE g3 pin_d0
#DEFINE g4 pin_d1
#DEFINE g5 pin_d2
#DEFINE g6 pin_d3
#DEFINE g7 pin_c4
#DEFINE g8 pin_c5
//Mabi renk seçimi
#DEFINE b1 pin_e1
#DEFINE b2 pin_e0
#DEFINE b3 pin_a5
#DEFINE b4 pin_a4
#DEFINE b5 pin_a3
#DEFINE b6 pin_a2
#DEFINE b7 pin_a1
#DEFINE b8 pin_a0
unsigned int8 valueNew;
unsigned int8 valueArray[];
unsigned int32 counter=0;
unsigned int8 valueOld=0;
unsigned int8 RGBSelect = 0;
#int_rda
void serihaberlesme_kesmesi()
{
clear_interrupt(INT_RDA);
valueNew=getc();
switch (valueNew)
{
case 200: RGBSelect=1; break;
case 201: RGBSelect=2; break;
case 202: RGBSelect=3; break;
}
if(valueNew!=200 && valueNew!=201 && valueNew!=202)
{
switch (RGBSelect)
{
case 1: valueNew = valueNew; break;
case 2: valueNew = valueNew+64; break;
case 3: valueNew = valueNew+128; break;
}
valueArray[counter]=valueNew;
counter++;
}
}
void redSelect()
{
switch (valueOld)
{
//sat1
case 1: output_high(p1); output_low(r1); break;
case 2: output_high(p1); output_low(r2); break;
case 3: output_high(p1); output_low(r3); break;
case 4: output_high(p1); output_low(r4); break;
case 5: output_high(p1); output_low(r5); break;
case 6: output_high(p1); output_low(r6); break;
case 7: output_high(p1); output_low(r7); break;
case 8: output_high(p1); output_low(r8); break;
//sat2
case 9: output_high(p2); output_low(r1); break;
case 10: output_high(p2); output_low(r2); break;
case 11: output_high(p2); output_low(r3); break;
case 12: output_high(p2); output_low(r4); break;
case 13: output_high(p2); output_low(r5); break;
case 14: output_high(p2); output_low(r6); break;
case 15: output_high(p2); output_low(r7); break;
case 16: output_high(p2); output_low(r8); break;
//sat3
case 17: output_high(p3); output_low(r1); break;
case 18: output_high(p3); output_low(r2); break;
case 19: output_high(p3); output_low(r3); break;
case 20: output_high(p3); output_low(r4); break;
case 21: output_high(p3); output_low(r5); break;
case 22: output_high(p3); output_low(r6); break;
case 23: output_high(p3); output_low(r7); break;
case 24: output_high(p3); output_low(r8); break;
//sat4
case 25: output_high(p4); output_low(r1); break;
case 26: output_high(p4); output_low(r2); break;
case 27: output_high(p4); output_low(r3); break;
case 28: output_high(p4); output_low(r4); break;
case 29: output_high(p4); output_low(r5); break;
case 30: output_high(p4); output_low(r6); break;
case 31: output_high(p4); output_low(r7); break;
case 32: output_high(p4); output_low(r8); break;
//sat5
case 33: output_high(p5); output_low(r1); break;
case 34: output_high(p5); output_low(r2); break;
case 35: output_high(p5); output_low(r3); break;
case 36: output_high(p5); output_low(r4); break;
case 37: output_high(p5); output_low(r5); break;
case 38: output_high(p5); output_low(r6); break;
case 39: output_high(p5); output_low(r7); break;
case 40: output_high(p5); output_low(r8); break;
//sat6
case 41: output_high(p6); output_low(r1); break;
case 42: output_high(p6); output_low(r2); break;
case 43: output_high(p6); output_low(r3); break;
case 44: output_high(p6); output_low(r4); break;
case 45: output_high(p6); output_low(r5); break;
case 46: output_high(p6); output_low(r6); break;
case 47: output_high(p6); output_low(r7); break;
case 48: output_high(p6); output_low(r8); break;
//sat7
case 49: output_high(p7); output_low(r1); break;
case 50: output_high(p7); output_low(r2); break;
case 51: output_high(p7); output_low(r3); break;
case 52: output_high(p7); output_low(r4); break;
case 53: output_high(p7); output_low(r5); break;
case 54: output_high(p7); output_low(r6); break;
case 55: output_high(p7); output_low(r7); break;
case 56: output_high(p7); output_low(r8); break;
//sat8
case 57: output_high(p8); output_low(r1); break;
case 58: output_high(p8); output_low(r2); break;
case 59: output_high(p8); output_low(r3); break;
case 60: output_high(p8); output_low(r4); break;
case 61: output_high(p8); output_low(r5); break;
case 62: output_high(p8); output_low(r6); break;
case 63: output_high(p8); output_low(r7); break;
case 64: output_high(p8); output_low(r8); break;
}
}
void greenSelect()
{
//output_a(0x3f); output_b(0xff); output_c(0xfc); output_d(0x0f); output_e(0xff);
switch (valueOld)
{
//sat1
case 65: output_high(p1); output_low(g1); break;
case 66: output_high(p1); output_low(g2); break;
case 67: output_high(p1); output_low(g3); break;
case 68: output_high(p1); output_low(g4); break;
case 69: output_high(p1); output_low(g5); break;
case 70: output_high(p1); output_low(g6); break;
case 71: output_high(p1); output_low(g7); break;
case 72: output_high(p1); output_low(g8); break;
//sat2
case 73: output_high(p2); output_low(g1); break;
case 74: output_high(p2); output_low(g2); break;
case 75: output_high(p2); output_low(g3); break;
case 76: output_high(p2); output_low(g4); break;
case 77: output_high(p2); output_low(g5); break;
case 78: output_high(p2); output_low(g6); break;
case 79: output_high(p2); output_low(g7); break;
case 80: output_high(p2); output_low(g8); break;
//sat3
case 81: output_high(p3); output_low(g1); break;
case 82: output_high(p3); output_low(g2); break;
case 83: output_high(p3); output_low(g3); break;
case 84: output_high(p3); output_low(g4); break;
case 85: output_high(p3); output_low(g5); break;
case 86: output_high(p3); output_low(g6); break;
case 87: output_high(p3); output_low(g7); break;
case 88: output_high(p3); output_low(g8); break;
//sat4
case 89: output_high(p4); output_low(g1); break;
case 90: output_high(p4); output_low(g2); break;
case 91: output_high(p4); output_low(g3); break;
case 92: output_high(p4); output_low(g4); break;
case 93: output_high(p4); output_low(g5); break;
case 94: output_high(p4); output_low(g6); break;
case 95: output_high(p4); output_low(g7); break;
case 96: output_high(p4); output_low(g8); break;
//sat5
case 97: output_high(p5); output_low(g1); break;
case 98: output_high(p5); output_low(g2); break;
case 99: output_high(p5); output_low(g3); break;
case 100: output_high(p5); output_low(g4); break;
case 101: output_high(p5); output_low(g5); break;
case 102: output_high(p5); output_low(g6); break;
case 103: output_high(p5); output_low(g7); break;
case 104: output_high(p5); output_low(g8); break;
//sat6
case 105: output_high(p6); output_low(g1); break;
case 106: output_high(p6); output_low(g2); break;
case 107: output_high(p6); output_low(g3); break;
case 108: output_high(p6); output_low(g4); break;
case 109: output_high(p6); output_low(g5); break;
case 110: output_high(p6); output_low(g6); break;
case 111: output_high(p6); output_low(g7); break;
case 112: output_high(p6); output_low(g8); break;
//sat7
case 113: output_high(p7); output_low(g1); break;
case 114: output_high(p7); output_low(g2); break;
case 115: output_high(p7); output_low(g3); break;
case 116: output_high(p7); output_low(g4); break;
case 117: output_high(p7); output_low(g5); break;
case 118: output_high(p7); output_low(g6); break;
case 119: output_high(p7); output_low(g7); break;
case 120: output_high(p7); output_low(g8); break;
//sat8
case 121: output_high(p8); output_low(g1); break;
case 122: output_high(p8); output_low(g2); break;
case 123: output_high(p8); output_low(g3); break;
case 124: output_high(p8); output_low(g4); break;
case 125: output_high(p8); output_low(g5); break;
case 126: output_high(p8); output_low(g6); break;
case 127: output_high(p8); output_low(g7); break;
case 128: output_high(p8); output_low(g8); break;
}
}
void blueSelect()
{
//output_a(0x3f); output_b(0xff); output_c(0xfc); output_d(0x0f); output_e(0xff);
switch (valueOld)
{
//sat1
case 129: output_high(p1); output_low(b1); break;
case 130: output_high(p1); output_low(b2); break;
case 131: output_high(p1); output_low(b3); break;
case 132: output_high(p1); output_low(b4); break;
case 133: output_high(p1); output_low(b5); break;
case 134: output_high(p1); output_low(b6); break;
case 135: output_high(p1); output_low(b7); break;
case 136: output_high(p1); output_low(b8); break;
//sat2
case 137: output_high(p2); output_low(b1); break;
case 138: output_high(p2); output_low(b2); break;
case 139: output_high(p2); output_low(b3); break;
case 140: output_high(p2); output_low(b4); break;
case 141: output_high(p2); output_low(b5); break;
case 142: output_high(p2); output_low(b6); break;
case 143: output_high(p2); output_low(b7); break;
case 144: output_high(p2); output_low(b8); break;
//sat3
case 145: output_high(p3); output_low(b1); break;
case 146: output_high(p3); output_low(b2); break;
case 147: output_high(p3); output_low(b3); break;
case 148: output_high(p3); output_low(b4); break;
case 149: output_high(p3); output_low(b5); break;
case 150: output_high(p3); output_low(b6); break;
case 151: output_high(p3); output_low(b7); break;
case 152: output_high(p3); output_low(b8); break;
//sat4
case 153: output_high(p4); output_low(b1); break;
case 154: output_high(p4); output_low(b2); break;
case 155: output_high(p4); output_low(b3); break;
case 156: output_high(p4); output_low(b4); break;
case 157: output_high(p4); output_low(b5); break;
case 158: output_high(p4); output_low(b6); break;
case 159: output_high(p4); output_low(b7); break;
case 160: output_high(p4); output_low(b8); break;
//sat5
case 161: output_high(p5); output_low(b1); break;
case 162: output_high(p5); output_low(b2); break;
case 163: output_high(p5); output_low(b3); break;
case 164: output_high(p5); output_low(b4); break;
case 165: output_high(p5); output_low(b5); break;
case 166: output_high(p5); output_low(b6); break;
case 167: output_high(p5); output_low(b7); break;
case 168: output_high(p5); output_low(b8); break;
//sat6
case 169: output_high(p6); output_low(b1); break;
case 170: output_high(p6); output_low(b2); break;
case 171: output_high(p6); output_low(b3); break;
case 172: output_high(p6); output_low(b4); break;
case 173: output_high(p6); output_low(b5); break;
case 174: output_high(p6); output_low(b6); break;
case 175: output_high(p6); output_low(b7); break;
case 176: output_high(p6); output_low(b8); break;
//sat7
case 177: output_high(p7); output_low(b1); break;
case 178: output_high(p7); output_low(b2); break;
case 179: output_high(p7); output_low(b3); break;
case 180: output_high(p7); output_low(b4); break;
case 181: output_high(p7); output_low(b5); break;
case 182: output_high(p7); output_low(b6); break;
case 183: output_high(p7); output_low(b7); break;
case 184: output_high(p7); output_low(b8); break;
//sat8
case 185: output_high(p8); output_low(b1); break;
case 186: output_high(p8); output_low(b2); break;
case 187: output_high(p8); output_low(b3); break;
case 188: output_high(p8); output_low(b4); break;
case 189: output_high(p8); output_low(b5); break;
case 190: output_high(p8); output_low(b6); break;
case 191: output_high(p8); output_low(b7); break;
case 192: output_high(p8); output_low(b8); break;
}
}
unsigned int32 i=0;
void main(){
setup_oscillator(OSC_64MHZ , OSC_PLL_ON);
set_tris_c(0b10111100);
output_a(0xff);
output_b(0xff);
output_c(0xff);
output_d(0xff);
output_e(0xff);
enable_interrupts(GLOBAL);
enable_interrupts(int_rda);
while(true){
for(i=0;i<counter+1;i++)
{
valueOld=valueArray[i];
output_a(0x3f); output_b(0xff); output_c(0xfc); output_d(0x0f); output_e(0xff);
redSelect();
greenSelect();
blueSelect();
}
}}
|
|
|
|
Ttelmah
Joined: 11 Mar 2010 Posts: 19506
|
|
Posted: Mon Nov 16, 2020 8:54 am |
|
|
One comment though.
This:
clear_interrupt(INT_RDA);
is completely pointless....
You _cannot_ clear INT_RDA, until the character is read from the UART.
So all this does is waste an instruction. The compiler itself automatically
clears interrupts when the ISR is exited (unless you specify 'NOCLEAR'),
so it is just a waste.... |
|
|
ressas
Joined: 15 Nov 2019 Posts: 135
|
|
Posted: Mon Nov 16, 2020 9:08 am |
|
|
Thank you Ttelmah
I care about your comments. These small fixes get me closer to writing professional code. Please tell me if there is any other error. Otherwise I'll keep making small mistakes forever :( |
|
|
|
|
You cannot post new topics in this forum You cannot reply to topics in this forum You cannot edit your posts in this forum You cannot delete your posts in this forum You cannot vote in polls in this forum
|
Powered by phpBB © 2001, 2005 phpBB Group
|