Здравейте! От скоро минах на XC8 и т. н. Имам малък проблем със статични променливи! Имам дефинирана статична променлива(масив):

Опитах да поставя тази дефиниция, както в .h, така и в .c! Проблемът е, че когато добавя нов файл (.h) под дефиницията не виждам буфера него.
Защо става така?
Мога лесно да се справя с някакъв допълнителен буфер, но не мисля това е редно...
Благодаря!

примерно това:

http://www.careerride.com/C-static-variables-scope.aspx

Махни тоз static че с него си правиш променливата видима само във файла в който си я дефинирал. На негово място сложи volatile и си готов.

Ясно! А volatile ще работи ли с putUSBUSART()?! Основният ми проблем е, че използвам USB CDC и до установих, че функциите му работят само със статични променливи(не че съм тествал с всички видове). Ще опитам с volatile, дано да работи така. Иначе от инфото по-горе става ясно, че статичните са видими само в текущия файл и ще трябва да оправя това по кофти начина - с допълнителен буфер и "преливане"!

Volatile не помага! Ще си го направя по баламския начин! Писна ми да се занимавам с това...

За пореден път: ако се експортва променлива в хедър, е задължително тя да бъде декларирана с extern отпред!
В .с файла:

В .h файла:

Абе не се карайте на детето, обяснето му

Стефчо, при Ц-то освен ако не пишеш нещо от сорта "hellow world" сорс кода рядко се събира в един единствен файл. То не че не можеш да наблъскаш всичко в един файл, ама може да стане голяма боза... Хубаво е да си групираш сорса в отделни файлчета по някаква прегледна логика.

Сега, номерът е че ако имаш повече файлчета, компилацията им е независима. Т.е. всеки си се компилира сам за себе си, независимо от останалите. Така всеки сорс файл се компилира до обектен файл. После има един процес нарече линкване, при който от обектните файлове се сглобява изпълним файл/hex/bin/elf или каквото там му кажеш.

Но да се върнем на сорса.... казахме, че той се компилира файл по файл, независимо един от друг. Какво става обаче ако код от един сорс файл ползва код или данни от друг сорс файл. Някак си компилаторът трябва да може да се ориентира дали кода/данните са локални или не. За целта се гледат няколко неща.
Първо имаш декларация и дефиниция. Декларациите са като обещанията... казваш на компилатора, че някъде ще има такова животно, ама къде ще е, не е ясно. Докато дефиницията буквално заковава това дето дефинираш на мястото дето го дефинираш. Демек един вид създаваш го това нещо.
Примерно:




Казахме, че говорим за много сорс файлове... За да може да ползваш в един сорс код/данни от друг ти трябват само декларациите. За удобство декларациите се пишат в h-файлове, докато дефинициите по принцип са в сорсовете. Не че е задължително, просто такава е практиката. Защо, ами защотото дефиницията ако се замисилиш малко ще се сетиш че трябва да е една. А пък декларациите трябва да ги имаш толкова пъти, колкото пъти ги ползваш в различни сорс файлове. Да ама тъпо да правиш copy&paste... много по-удобно е просто да вмъкнеш с #include декларациите на това дето ще ползваш.

Ако сложиш дефиниция в хедър и тоя хедърър го инклуднеш на 5 места все едно правиш 5 различни дефиниции. Ако това са променливи значи правиш 5 различни променливи. Дефакто ти може точно това да си искал, макар че често се случва и по погрешка. Затова повечето компилатори предупреждават, освен ако не сложиш "static" което значи че искаш storage class-а да е локален, демек казаш на компилатора че не си се объркал и искаш да работиш с локално дефинирана финкция/променлива. Дори и да има някъде другаде същата дефиниция със същото име не е проблем, ти си казал че работиш с локалната.

"volatile" пък означава, че въпросната променлива може да не е просто променлива, а хардуерен регистър или просто искаш да кажеш че операциите с това животно са важни (за теб) и компилаторът не трябва нито да ги оптимизира (маха) нито да ги разбърква във времето с други подобни.
Примерно ако имаш някакъв израз, обаче резултата не се използва, то компилатора може да реши да го "оптимизира". Ако обаче в израза имаш volatile, то те ще се четат независимо дали прочетеното после се ползва или не.

Миро, не поощрявай анти-програмиране с дефиниции на променливи в хедър. Той може и да иска, ама не трябва да иска

Аз да не съм му шеф та да му казвам как да си върши работата

Обеснявам кое как може пък после изборът си е негов....

Миро, благодаря за разяснението! Нямам много опит с XC компилаторите. Обикновено използвам CCS, а там се компилира целия проект и го няма това с многократното include на хедъри! Иначе съм наясно какво да слагам в .h и .c! Просто не бях наясно с видимостта на променливите в различните файлове! Когато нещо е static, очаквах да се вижда навсякъде ...
Иначе реших проблема Малко като първия човек, но поне работи...
Благодаря!

Това се избягва с условно компилиране.

Това дето казваш предпазва от многократно инклудване на един и същ хедър в един и същ compilation unit.

А аз обяснявах за инклудване на един хедър (съдържащ дефиниции) в няколко различни compilation unit-a.

тц, точно обратното е

Всъщност static не касае директно видимостта (scope), а къде се разполага нещото (storage class) но ефектът е същият...

Абсолютно! Но когато е заделена статична памет за дадена променлива и тя не се изменя(static), очаквах да се вижда навсякъде. Тук няма public, private, protected и ...
Както и да е! Има си особености и като не съм работил с това нЯщо...

Момци, нещо не правя, както трябва! Или поне аз си мисля така! До колкото разбрах трябва да си декларирам променливите с volatile в някой от файловете, след което ако искам да ги използвам в друг файл използвам extern. Програмата се компилира при това положение, обаче променливите нямат стойности - присвоявам стойност и като се опитам да я прочета няма нищо вътре!
Ето пример:
buffer.c:

main.c:

Какво бъркам? Видимостта на променливите е направена много шашаво...