algoritma desteği

[Maxim]

şöyle bir matrix oluşturarak
iki değişkenin çakıştığı noktadaki değeri değiştirmek istiyorum .

yazarak olmuyor resim vereyim ,



sol taraf, yani yatay sütünlar pwm
50hz den başlayıp 300 hz e kadar

dikey sütünlarda volt ,
10 dan başlayı 60 volta kadar diye düşünebiliriz kabaca .

16 x 16 lık bir matrix olduğunu farz edersek, (resimdeki 6x6)
16x16 = 256 adet kutu demek

nasıl bir algoritma kurmalıyımki hem karışık olmasın hem çok yer kaplamadan, sade bir şekilde çakışan yerdeki değerleri değiştirebileyim ?

[arslan74]

sade bir şekilde çakışan yerdeki değerleri değiştirebileyim ?

Merhaba,

Bu sözünden tam olarak ne yapmak istediğini anlamadım. Ama matrix kullandığın için en basit şekilde 2 boyutlu diziyle ulaşabilirsin.

Selamlar

[ete]

Bu işi çözmenin en iyi yolu iki boyutlu dizi kullanmaktır. SAYI(X,Y) şeklinde.
Ancak kullanacağın dili belirtmemişsin.  Biliyorsun bazı derleyicilerde dizi yalnızca tek boyutlu tanımlanabiliyor. Ama bazı teknikler kullanılarak bu iki boyutlu gibi değerlendirilebilir.

Yapacağın tek şey bu sistemi iki boyutlu dizi şeklinde değerlendirmek olmalı.

Ete

[Maxim]

2 boyutlu dizi mantığını anlamaya çalışıyorum ,

sadeden kastım ,
formülü karışık olmayan ,fazla dallanıp budaklanmadan ..
sonuçta bir problemin, birkaç farklı şekilde çözümü olabiliyor, o yüzden .

ete hocam,
proton+ kullanıyorum .

[Maxim]

yanlış anlatım olmaması açısından :

1 pwm girişi var ,
bu girişteki pwm 50hz ile 300hz arasında sürekli değişen bir değer ..
yatay sütün

1 voltaj girişi var ,
bu girişte 10 volt ile 60 volt arasında değişiyor .
dikey sütün

1 de çıkışımız var ,
bu tabloda çakışan yerdeki, değerler bu çıkışımıza ait değer.

[MURSEL]

sanırım ccs de yazıyordun

long microcell[3][3]=   // degişkenlerin türüne dikkat et  ve 3x3 taplo olusturdum bu mantıkta 16x16 yap
{
{250,250,250}   //v1,v2,v3
{253,245,230}   //v4,v5,v6
{255,222,17}     //v7,v8,v9
}



deger=read_adc();

microcell[0][0]=deger;  // v1 hücresine degerimizi yükeldik
microcell[1][1]=deger;  // v5 hücresine degerimizi yükeldik
microcell[2][0]=deger;   // v3 hücresine degerimizi yükeldik

[ete]

Bildiğim kadarı ile Proton da da yalnızca tek boyutlu dizi değişkeni tanımlanabiliyor. Senin yapman gereken ikinci boyutu sanal yaratıp kullanmak.
Benzer işlerde kullandığım yöntemi açıklayayım.

Diyelimki verdiğin tablodaki gibi toplam 36 adet elemanı olan bir dizi yaratmak.  Çift boyut kullanabilse idik.  Boyutun birinde yata bileşen diğerinde ise dikey bileşen kullanıp bütün değişkenleri diziye aktarır ve sonrada elde ettiğimiz değerler bağlı olarak bu değerleri geri çağırabilirdik. Örnek vermek gerekir ise senin tabloya göre Dizi (2,4)=V3 bilgisini bize verecek idi.
Şimdi elimizde tek boyut olduğuna göre yapacağımız iş 36 elemanı olan tek boyutlu bir dizi yaratmak.
Matriks deki bilgileri ise diziye vermek için şu yöntemi kullanman gerek.
Dizi(0-5)=ilk sıradaki bilgiler.
Dizi(6-11)=ikinci sıradaki bilgiler
Dizi (12-17)=üçüncü sıradaki bilgiler.
...
Dizi (30-35)= son sıradaki bilgiler.
Şimdi elindeki bilgileri değerlendirerek dizinin hangi elmanını bulacağını belirlemen gerekiyor.
PWM değeri hangi sıradaki diziye ulaşacağını belirleyecektir. Ufak bir hesap yapalım
PWM frekansı 50-300 arasında değişiyor. O halde dizi başlangıcı (PWM/50)-1*6 bize dizininbaşlanıgıcını verecektir.
Diğer boyutu tayin eden ise Volt değeridir. Buda 10V ile 60V arasında değişmektedir. O halde yatay sırada dizi elemanını tespit etmek için;
Volt/10-1 eşitliği de yatay sırayı bize verecektir.

Şimdi bir örnek yapalım;

PWM=150 ve Volt=60 olsun Bu değerlere karşılık gelen dizi elemanı hangisi olacaktır.
Önce dizi başlangıcını tespit edelim.
Y=(PWM/50)-1 * 6 = (150/50)-1 * 6= (3-1)*6 = 12 olacaktır.
Yatay sıra içinde X=(Volt/10)-1=(60/10)-1 =5 olarak bulunacaktır.
O halde Dizi(12+5)) Dizi(17) bize bu değeri vermesi gerekecektir. Buda V6 değeridir.

Gördüğün gibi çok zor değil.

Umarım ne yaptığımı anlamışsındır.

Ete

[Maxim]

ete hocam uğraşıyorum

1 sorum daha var

"2 boyutlu dizi değişkeni" ingilizce karşılığı nedir ?
proton özelliklerine bakmak için sordum.

[ete]

dizi değişkenleri array diye tanımlanıyor. Array variables veya variable arrays diye araman gerek sanırım.

Ete

[M_B]

@maxiboost hocam;
su sekilde bir sey yapılsa nasıl olur.
Sadece bir baska bakıs acısı
Yalnız taplodaki degerler hep aynı ise ( Tabloya gore dıyorum )

oncelikle 3 tane tanım olacak
birtanesi pwm ( Dikey satır )
digeride volt ( Yatay satır )
deger

oncelikle okunan iki veri carpılacak.

ornek olarak
pwm=50 volt=10  degerleri verilmiş olsun.
deger = pwm*volt
deger=500 cıkar.
Sonra karşılastırma işlemine tabi tutulacak.

eger deger=500 ise v1
eger deger=1000 ise v5
eger deger=4500 ise v3
gibi
Program yazmadan anlatmaya calıstım.
sonuc olarak alınan iki veri carpılacak sonuca gore cıkıs verılecek
eger tablomus sabıt se

bir baska bakıs acısı ıle  
Kolay gelsın

[Maxim]

okuduğum kadarıyla ,

2 boyutlu dizin olayı protonda varmı yokmu halen anlamış değilim ?


helpinde şöyle bir yazı var ,

The PROTON+ compiler supports multi part byte, and word variables named arrays. An array is a group of variables of the same size (8-bits wide, or 16-bits wide), sharing a single name, but split into numbered cells, called elements.

bu yazının devamıda var ama hiç sizin dediğiniz şekilde tanımlama yok ,
yani " DIM ABC[15][15] AS WORD " şeklinde yok,

[ete]

Protonda çok boyutlu tanımlama olmadığını söylemiştim. Tek boyutlu tanımlama  ise aşağıdaki başlıkta açıklanmıştır.
Köşeli parantez içindeki değer eleman sayısıdır . Sıfır dikkate alınarak verilmeldir. 10 eleman için 0-9 olarak kullanılır.

Ete

Creating and using Arrays
The PROTON+ compiler supports multi part BYTE, and WORD variables named arrays. An array
is a group of variables of the same size (8-bits wide, or 16-bits wide), sharing a single
name, but split into numbered cells, called elements.
An array is defined using the following syntax: -
DIM Name[ length ] AS BYTE
DIM Name[ length ] AS WORD
where Name is the variable's given name, and the new argument, [ length ], informs the compiler
how many elements you want the array to contain. For example: -
DIM MYARRAY[10] AS BYTE ' Create a 10 element byte array.
DIM MYARRAY[10] AS WORD ' Create a 10 element word array.

[Maxim]

ete hocam bakın ne buldum
normalde yok ama taklalar atarak yapmış bir şekilde.
kodu anlamaya çalışıyorum.

çalışır haline bakmak isterseniz ;
http://rapidshare.com/files/325787305/2D.rar.html


*[ ] eleman sayısını düzelttim .



contributed by Les Johnson.

'
' Two macros that simulate a 2 dimensional byte array load and retrieve
' The macros use NO variable RAM other that SFR registers, and use no Call Stack space.
'
' For 16-bit core (18F) devices only. Using PROTON+ Version 3.03 Onwards.
'
' This program can be tested using the PIC18_ALCD_VHB file in the ISIS simulator.

Include "PROTON18_4.INC" ' Use the PROTON Dev board for the demonstration

Dim INDEX1 As Byte                              ' \
Dim INDEX2 As Byte                              '   Create some variables for the demo loop
Dim BYTE_OUT As Byte                            ' / 

Symbol DIMENSION_1 = 10                         ' Array dimension 1 size 
Symbol DIMENSION_2 = 10                         ' Array dimension 2 size 

Dim XY_ARRAY[DIMENSION_1 * DIMENSION_2] As Byte ' Create an array large enough for all the elements 
Symbol XY_ARRAY_LENGTH = 10                     ' The length of dimension 2 of the array


'-------------------------------------------------------------------------------------- 
' Simulate a two part array XY_ARRAY[INDEX1 , INDEX2] = VALUE_IN
' The algorithm for accessing the elements is: -
' FSR0 = ARRAY_NAME
' FSR0 = FSR0 + INDEX2
' PROD = INDEX1 * INDEX2_LENGTH 
' FSR0 = FSR0 + PROD

' Syntax: -
' MARRAY_OUT XY_ARRAY , INDEX2_LENGTH , [INDEX1 , INDEX2] , VALUE_IN

' Where: - 
' ARRAY_NAME is the name of the array in question
' INDEX2_LENGTH is the second index's length
' INDEX1 is the first index value of the array
' INDEX2 is the second index value of the array
' VALUE_IN is the 8-bit value to place at the position in the array

MARRAY_OUT MACRO- ARRAY_NAME, INDEX2_LENGTH, INDEX_1, INDEX_2, VALUE_IN

#IF(Prm_1 != BYTE_ARRAY_PTR)
#ERROR "Parameter 1 must be a BYTE ARRAY for MARRAY_OUT macro" 
EXITM
#ENDIF
ASM- 
lfsr 0,ARRAY_NAME ; Point FSR0 to the Array
#IF((Prm_4 == NUM8) || (Prm_4 == NUM16) || (Prm_4 == NUM32)) ; \
movlw INDEX_2                                                ;  \
#ENDIF                                                       ;  |
#IF((Prm_4 == Byte) || (Prm_4 == Word) || (Prm_4 == DWord))  ;  |
#IF(INDEX_2 <= BANKA_END)                                    ;   Get the second INDEX value into WREG
movf INDEX_2,W                                               ;  |
#ELSE                                                        ;  |
movff INDEX_2,WREG                                           ;  /
#ENDIF                                                       ; /
#ENDIF 
addwf FSR0L,F                                                ; \ 
movlw 0                                                      ;   Add this to FSR0
addwfc FSR0H,F                                               ; /

#IF((Prm_3 == NUM8) || (Prm_3 == NUM16) || (Prm_3 == NUM32)) ; \
movlw INDEX_1                                                ;  \
#ENDIF                                                       ;  |
#IF((Prm_3 == Byte) || (Prm_3 == Word) || (Prm_3 == DWord))  ;  |
#IF(INDEX_1 <= BANKA_END)                                    ;  |  
movf INDEX_1,W                                               ;   Get the first INDEX into WREG
#ELSE                                                        ;  |
movff INDEX_1,WREG                                           ;  |
#ENDIF                                                       ;  /
#ENDIF                                                       ; /
ENDASM-
#IF((Prm_2 != NUM8) && (Prm_2 != NUM16) && (Prm_2 != NUM32))
#ERROR "INDEX LENGTH must be a constant value for MARRAY_OUT macro" 
#ENDIF
ASM-
mullw INDEX2_LENGTH                                          ; \
movf PRODL,W                                                 ;  \
addwf FSR0L,F                                                ;   Calculate the offset within the array
movf PRODH,W                                                 ;  /
addwfc FSR0H,F                                               ; /
; 
; At this point FSR0 is pointing to the correct element based on INDEX_1, INDEX_2 and INDEX2_LENGTH
;
#IF((Prm_5 == NUM8) || (Prm_5 == NUM16) || (Prm_5 == NUM32)) ; \
#IF(VALUE_IN == 0)                                           ;  \
clrf INDF0                                                   ;  |
#ELSE                                                        ;  |
#IF(VALUE_IN == 255)                                         ;  |
setf INDF0                                                   ;  |
#ELSE                                                        ;  |
movlw VALUE_IN                                               ;   Place the value into the element
movwf INDF0                                                  ;  |
#ENDIF                                                       ;  |
#ENDIF                                                       ;  |
#ENDIF                                                       ;  |
#IF((Prm_5 == Byte) || (Prm_5 == Word) || (Prm_5 == DWord))  ;  |
movff VALUE_IN,INDF0                                         ;  /
#ENDIF                                                       ; /
#IF(Prm_5 == Float)
#ERROR "Floating point not supported with the MARRAY_OUT macro"
#ENDIF
ENDASM-
ENDM
'--------------------------------------------------------------------------------------
' Simulate a two part array VARIABLE = XY_ARRAY [INDEX1 , INDEX2]
' The algorithm for accessing the elements is: -
' FSR0 = ARRAY_NAME
' FSR0 = FSR0 + INDEX2
' PROD = INDEX1 * INDEX2_LENGTH 
' FSR0 = FSR0 + PROD

' Syntax: 
' VARIABLE = MARRAY_IN XY_ARRAY , INDEX2_LENGTH , [INDEX1 , INDEX2]

' Where: - 
' VARIABLE is the 8-bit value extracted from the array
' ARRAY_NAME is the name of the array in question
' INDEX2_LENGTH is the second index's length
' INDEX1 is the first index value of the array
' INDEX2 is the second index value of the array

MARRAY_IN MACRO- ARRAY_NAME, INDEX2_LENGTH, INDEX_1, INDEX_2

#IF(Prm_1 != BYTE_ARRAY_PTR)
#ERROR "Parameter 1 must be a BYTE ARRAY for MARRAY_IN macro" 
EXITM
#ENDIF
ASM- 
lfsr 0,ARRAY_NAME ; Point FSR0 to the start of the ARRAY
#IF((Prm_4 == NUM8) || (Prm_4 == NUM16) || (Prm_4 == NUM32)) ; \
movlw INDEX_2                                                ;  \
#ENDIF                                                       ;  |
#IF((Prm_4 == Byte) || (Prm_4 == Word) || (Prm_4 == DWord))  ;  |
#IF(INDEX_2 <= BANKA_END)                                    ;  |
movfw INDEX_2                                                ;   Get the second INDEX value into WREG
#ELSE                                                        ;  |
movff INDEX_2,WREG                                           ;  |
#ENDIF                                                       ;  /
#ENDIF                                                       ; /
addwf FSR0L,F                                                ; \
movlw 0                                                      ;   Add this to FSR0
addwfc FSR0H,F                                               ; /

#IF((Prm_3 == NUM8) || (Prm_3 == NUM16) || (Prm_3 == NUM32)) ; \
movlw INDEX_1                                                ;  \
#ENDIF                                                       ;  |
#IF((Prm_3 == Byte) || (Prm_3 == Word) || (Prm_3 == DWord))  ;  |
#IF(INDEX_1 <= BANKA_END)                                    ;  |
movfw INDEX_1                                                ;   Get the first INDEX value into WREG 
#ELSE                                                        ;  |
movff INDEX_1,WREG                                           ;  |
#ENDIF                                                       ;  /
#ENDIF                                                       ; /
ENDASM-
#IF((Prm_2 != NUM8) && (Prm_2 != NUM16) && (Prm_2 != NUM32))
#ERROR "INDEX LENGTH must be a constant value for MARRAY_IN macro" 
#ENDIF
ASM-
mullw INDEX2_LENGTH                                          ; \
movf PRODL,W                                                 ;  \
addwf FSR0L,F                                                ;   Calculate the offset within the array
movf PRODH,W                                                 ;  /
addwfc FSR0H,F                                               ; /
; 
; At this point FSR0 is pointing to the correct element based on INDEX_1, INDEX_2 and INDEX2_LENGTH
; 
#IF(MARRAY_IN_RETURN == 1)                                   ; Is there a return variable ?
#IF(Return_Type == Byte)                                     ; \
movff INDF0,Return_Var                                       ;  \
#ENDIF                                                       ;  |
#IF(Return_Type == Word)                                     ;  |
Byte_Word INDF0,Return_Var                                   ;   Place the contents of the element into the return variable
#ENDIF                                                       ;  |  
#IF(Return_Type == DWord)                                    ;  |
Byte_Word INDF0,Return_Var                                   ;  /
#ENDIF                                                       ; /
#IF(Return_Type == Float) 
#ERROR "Floating point not supported with the MARRAY_IN macro"
#ENDIF 
#ENDIF 
ENDASM-
ENDM 
'
'-------------------------------------------------------------------
' The MAIN PROGRAM LOOP STARTS HERE
' Test the macros by loading then retieving values

DelayMS 100                                  ' Wait for things to stabilise
Clear                                        ' Clear all RAM before we start
HSerOut [" ARRAY CONTENTS",13,13]
HSerOut [" 00 01 02 03 04 05 06 07 08 09",13]
HSerOut [" -----------------------------",13]
'
' Fill the 2 dimension array with values
'
For INDEX1 = 0 To DIMENSION_1 - 1            ' Create an outer loop for the first dimension
  HSerOut [DEC2 INDEX1," | "]
    For INDEX2 = 0 To DIMENSION_2 - 1        ' Create an inner loop for the second dimension
      MARRAY_OUT XY_ARRAY,XY_ARRAY_LENGTH,[INDEX1,INDEX2], INDEX2   ' Fill array with value in INDEX2
      BYTE_OUT = MARRAY_IN XY_ARRAY,XY_ARRAY_LENGTH,[INDEX1,INDEX2] ' Read array value to BYTE_OUT
      HSerOut [HEX2 BYTE_OUT,","]            ' Display the value read from the array serially
    Next                                     ' Close the inner loop
    HSerOut [8,13]                           ' Send a Backspace and Carriage Return
Next                                         ' Close the outer loop
Stop

[z]

2x4 ARRAY YAPALIM

DIM A0(4)
DIM A1(4)

I=1: REM SATIR
j=3: REM SUTUN

GOSUB DEGER

REM SONUC=ARRAY[I,J]

DEGER:
IF I=0 THEN SONUC=A0(J) :RETURN
IF I=1 THEN SONUC=A1(J)
RETURN

[hasangurlek]

ete hocam bakın ne buldum
normalde yok ama taklalar atarak yapmış bir şekilde.
kodu anlamaya çalışıyorum.

' For 16-bit core (18F) devices only. Using PROTON+ Version 3.03 Onwards.

Vatandaş proton demiş ama kodun çoğunluğu assembly ile yazılmış

Protonda pointer kullanılamıyormu ?